def get_header_info(self,
fields,
request,
context,
from_addr=None,
to_addr=None,
subject=None):
"""Return header info
header info is a dictionary
Keyword arguments:
request -- (optional) alternate request object to use
"""
portal = getToolByName(context, 'portal_url').getPortalObject()
utils = getToolByName(context, 'plone_utils')
(to, from_addr, reply) = self.get_addresses(fields, request, context)
subject = self.get_subject(fields, request, context)
headerinfo = OrderedDict()
headerinfo['To'] = self.secure_header_line(to)
headerinfo['From'] = self.secure_header_line(from_addr)
if reply:
headerinfo['Reply-To'] = self.secure_header_line(reply)
# transform subject into mail header encoded string
email_charset = portal.getProperty('email_charset', 'utf-8')
if not isinstance(subject, unicode):
site_charset = utils.getSiteEncoding()
subject = unicode(subject, site_charset, 'replace')
msgSubject = self.secure_header_line(subject).encode(
email_charset, 'replace')
msgSubject = str(Header(msgSubject, email_charset))
headerinfo['Subject'] = msgSubject
# CC
cc_recips = filter(None, self.cc_recipients)
if hasattr(self, 'ccOverride') and self.ccOverride and get_expression(
context, self.ccOverride):
cc_recips = get_expression(context, self.ccOverride)
if cc_recips:
headerinfo['Cc'] = self._destFormat(cc_recips)
# BCC
bcc_recips = filter(None, self.bcc_recipients)
if hasattr(self,
'bccOverride') and self.bccOverride and get_expression(
context, self.bccOverride):
bcc_recips = get_expression(context, self.bccOverride)
if bcc_recips:
headerinfo['Bcc'] = self._destFormat(bcc_recips)
for key in getattr(self, 'xinfo_headers', []):
headerinfo['X-{0}'.format(key)] = self.secure_header_line(
request.get(key, 'MISSING'))
return headerinfo
def getOrder(self, original):
neworder = OrderedDict()
keys = original.keys()
last = keys.pop()
keys.insert(1, last)
for schemata in keys:
neworder[schemata] = original[schemata]
return neworder
def testSwapTwoSchemata(self):
schema = ManagedSchema()
schema.addField(MockField("one", "one"))
schema.addField(MockField("two", "two"))
command = OrderedDict()
command["two"] = ["two"]
command["one"] = ["one"]
set_schema_order(schema, command)
self.assertEqual(schema.getSchemataNames(), ["two", "one"])
def lookupVocabulary(context, field):
if IVocabulary.providedBy(field.vocabulary):
return field.vocabulary.getVocabularyDict(context)
else:
vocab = field.Vocabulary(context)
tree = OrderedDict()
for key in vocab:
tree[key] = vocab.getValue(key)
return tree
def _getUntranslatedVocabularyDict(self):
"""returns a vocabulary dictionary as defined in the interface
"""
vdict = OrderedDict()
for obj in self.contentValues():
vsubdict = obj._getUntranslatedVocabularyDict()
vdict[obj.getVocabularyKey()] = ( \
obj.getVocabularyValue(), vsubdict)
return vdict
def get_schema_order(schema):
"""Return the order of all schemata and their fields.
The ordering is returned as an OrderedList for schemata
with the schemata names as keys fields names as values.
"""
result = OrderedDict()
for name in schema.getSchemataNames():
fields = schema.getSchemataFields(name)
result[name] = list(x.getName() for x in fields)
return result
def getSchemata(obj):
"""Returns an ordered dictionary, which maps all Schemata names to fields
that belong to the Schemata."""
schema = obj.Schema()
schemata = OrderedDict()
for f in schema.fields():
sub = schemata.get(f.schemata, WrappedSchemata(name=f.schemata))
sub.addField(f)
schemata[f.schemata] = sub.__of__(obj)
return schemata
def __init__(self, results, context, request):
"""Take the results and the request.
"""
self.context = context
self.results = results
self.currentresults = []
self.pagemap = OrderedDict()
self.request = request
self.showBatch = True
if len(results) < self.threshold:
self.showBatch = False
self.currentresults = results
else:
self.initialize()
def _getTranslatedVocabularyDict(self, lang):
"""returns a vocabulary dict using the titles of the
translations for language ``lang``
Only canonical objects are used to build up this
dictionary. If available, the translation's titles
are used.
"""
vdict = OrderedDict()
for obj in self.contentValues():
if obj.isCanonical():
# we only add the canonical objects to this dict
key = obj.getTermKey()
# but use the title of the appropriate translation
# if it is available (getTermValue is LP aware)
vsubdict = obj._getTranslatedVocabularyDict(lang)
vdict[key] = (obj.getTermValue(lang=lang), vsubdict)
return vdict
def _get_issues(self):
" fetch all oshmail issues "
folder = self.context.data.oshmail
pc = self.context.portal_catalog
yearmap = dict()
allissues = []
latestissue = None
for issue in pc(portal_type='Collage', review_state="published"):
if not 'oshmail' in issue['getId']:
continue
# Don't list OSHMails that are both expired and outdated,
# aka "deleted"
if getattr(issue, 'outdated', False) and isExpired(issue):
continue
date = issue['effective']
if latestissue is None or date > latestissue['effective']:
latestissue = issue
(name, num) = issue['getId'].split('-')
yearlist = yearmap.get(date.year(), [])
yearlist.append((int(num),
dict(id=issue['getId'],
day=date.Day(),
month=date.Month(),
year=date.year(),
url=issue.getURL(),
title=issue['Title'])))
yearmap[date.year()] = yearlist
ordered_yearmap = OrderedDict()
years = yearmap.keys()
years.sort()
years.reverse()
for year in years:
yearlist = yearmap[year]
yearlist.sort()
yearlist.reverse()
ordered_yearmap[year] = yearlist
return latestissue, ordered_yearmap
def getVocabularyDict(self, instance=None):
"""Returns a vocabulary dictionary as defined in the interface
"""
if self.isLinguaPloneInstalled():
# if lp is installed
# obtain language and return translated dict
try:
# we use the language of instance for this dictionary
lang = instance.getLanguage()
except AttributeError:
# we retrieve the current language
langtool = getToolByName(self, 'portal_languages')
lang = langtool.getPreferredLanguage()
return self._getTranslatedVocabularyDict(lang)
else:
# just return all terms
vdict = OrderedDict()
for obj in self.contentValues():
vdict[obj.getTermKey()] = obj.getTermValue()
return vdict
def sortByDate(self, competitions):
yearmap = dict()
for competition in competitions:
date = competition.effective()
yearlist = yearmap.get(date.year(), [])
yearlist.append((
date.month(),
dict(id=competition.getId(),
url=competition.absolute_url(),
title=competition.Title()),
))
yearmap[date.year()] = yearlist
ordered_yearmap = OrderedDict()
keys = yearmap.keys()
keys.sort()
keys.reverse()
for year in keys:
yearlist = yearmap[year]
yearlist.sort()
yearlist.reverse()
ordered_yearmap[year] = yearlist
return ordered_yearmap
# See CMFPlone/tests/dummy.py for faking a FileField
return "Created %d PHC Videos." % i
def CreateTestData(self, portal):
out = []
out.append(CreateRootPHC(self, portal))
out.append(CreateUsers(self, portal))
out.append(CreateHowtos(self, portal))
out.append(CreateTutorials(self, portal))
out.append(CreateFaqs(self, portal))
out.append(CreateErrorRefs(self, portal))
out.append(CreateDefinitions(self, portal))
out.append(CreateLinks(self, portal))
out.append(CreateReferenceManuals(self, portal))
out.append(CreateVideos(self, portal))
return ' \n'.join(out)
functions = OrderedDict()
functions['Create Test Data'] = CreateTestData
functions['Create Test Users'] = CreateUsers
functions['Create Test PloneHelpCenter'] = CreateRootPHC
functions['Create Test Tutorials'] = CreateTutorials
functions['Create Test Howtos'] = CreateHowtos
functions['Create Test FAQs'] = CreateFaqs
functions['Create Test Error References'] = CreateReferenceManuals
functions['Create Test Definitions'] = CreateDefinitions
functions['Create Test Links'] = CreateLinks
functions['Create Test Reference Manuals'] = CreateReferenceManuals
functions['Create Test Videos'] = CreateVideos
def afterSetUp(self):
self.d = OrderedDict()
self.d['a'] = '1'
self.d['b'] = '2'
self.d['c'] = '3'
def get_header_body_tuple(self,
fields,
request,
from_addr=None,
to_addr=None,
subject=None,
**kwargs):
"""Return header and body of e-mail as an 3-tuple:
(header, additional_header, body)
header is a dictionary, additional header is a list, body is a StringIO
Keyword arguments:
request -- (optional) alternate request object to use
"""
pprops = getToolByName(self, 'portal_properties')
site_props = getToolByName(pprops, 'site_properties')
portal = getToolByName(self, 'portal_url').getPortalObject()
pms = getToolByName(self, 'portal_membership')
utils = getToolByName(self, 'plone_utils')
body = self.get_mail_body(fields, **kwargs)
# fields = self.fgFields()
# get Reply-To
reply_addr = None
if shasattr(self, 'replyto_field'):
reply_addr = request.form.get(self.replyto_field, None)
# get subject header
nosubject = '(no subject)'
if shasattr(self, 'subjectOverride') and self.getRawSubjectOverride():
# subject has a TALES override
subject = self.getSubjectOverride().strip()
else:
subject = getattr(self, 'msg_subject', nosubject)
subjectField = request.form.get(self.subject_field, None)
if subjectField is not None:
subject = subjectField
else:
# we only do subject expansion if there's no field chosen
subject = self._dreplace(subject)
# Get From address
if shasattr(self, 'senderOverride') and self.getRawSenderOverride():
from_addr = self.getSenderOverride().strip()
else:
from_addr = from_addr or site_props.getProperty('email_from_address') or \
portal.getProperty('email_from_address')
# Get To address and full name
if shasattr(self,
'recipientOverride') and self.getRawRecipientOverride():
recip_email = self.getRecipientOverride()
else:
recip_email = None
if shasattr(self, 'to_field'):
recip_email = request.form.get(self.to_field, None)
if not recip_email:
recip_email = self.recipient_email
recip_email = self._destFormat(recip_email)
recip_name = self.recipient_name.encode('utf-8')
# if no to_addr and no recip_email specified, use owner adress if possible.
# if not, fall back to portal email_from_address.
# if still no destination, raise an assertion exception.
if not recip_email and not to_addr:
ownerinfo = self.getOwner()
ownerid = ownerinfo.getId()
fullname = ownerid
userdest = pms.getMemberById(ownerid)
if userdest is not None:
fullname = userdest.getProperty('fullname', ownerid)
toemail = ''
if userdest is not None:
toemail = userdest.getProperty('email', '')
if not toemail:
toemail = portal.getProperty('email_from_address')
assert toemail, """
Unable to mail form input because no recipient address has been specified.
Please check the recipient settings of the PloneFormGen "Mailer" within the
current form folder.
"""
to = formataddr((fullname, toemail))
else:
to = to_addr or '%s %s' % (recip_name, recip_email)
headerinfo = OrderedDict()
headerinfo['To'] = self.secure_header_line(to)
headerinfo['From'] = self.secure_header_line(from_addr)
if reply_addr:
headerinfo['Reply-To'] = self.secure_header_line(reply_addr)
# transform subject into mail header encoded string
email_charset = portal.getProperty('email_charset', 'utf-8')
if not isinstance(subject, unicode):
site_charset = utils.getSiteEncoding()
subject = unicode(subject, site_charset, 'replace')
msgSubject = self.secure_header_line(subject).encode(
email_charset, 'replace')
msgSubject = str(Header(msgSubject, email_charset))
headerinfo['Subject'] = msgSubject
# CC
cc_recips = filter(None, self.cc_recipients)
if shasattr(self, 'ccOverride') and self.getRawCcOverride():
cc_recips = self.getCcOverride()
if cc_recips:
headerinfo['Cc'] = self._destFormat(cc_recips)
# BCC
bcc_recips = filter(None, self.bcc_recipients)
if shasattr(self, 'bccOverride') and self.getRawBccOverride():
bcc_recips = self.getBccOverride()
if bcc_recips:
headerinfo['Bcc'] = self._destFormat(bcc_recips)
for key in getattr(self, 'xinfo_headers', []):
headerinfo['X-%s' % key] = self.secure_header_line(
request.get(key, 'MISSING'))
# return 3-Tuple
return (headerinfo, self.additional_headers, body)
def _getTranslatedVocabularyDict(self, lang):
vdict = OrderedDict()
for obj in self.contentValues():
vdict[obj.getTermKey()] = obj.getTermValue(lang)
return vdict
def getOrder(self, original):
neworder = OrderedDict()
for schemata in original.keys():
neworder[schemata] = original[schemata]
return neworder
