def setUpZope(self, app, configurationContext):
# Patch effectiveDate, so our FtwCalendarwidget is used
from ftw.calendarwidget.browser.widgets import FtwCalendarWidget
from Products.ATContentTypes.content.base import registerATCT
from Products.ATContentTypes.content.document import ATDocument
from Products.ATContentTypes.content.document import PROJECTNAME
ATDocument.schema['effectiveDate'].widget = FtwCalendarWidget(
label='MyDate'
)
registerATCT(ATDocument, PROJECTNAME)
# Load ZCML
xmlconfig.file('configure.zcml',
ftw.calendarwidget,
context=configurationContext)
xmlconfig.file('configure.zcml',
collective.js.jqueryui,
context=configurationContext)
# installProduct() is *only* necessary for packages outside
# the Products.* namespace which are also declared as Zope 2 products,
# using <five:registerPackage /> in ZCML.
z2.installProduct(app, 'ftw.calendarwidget')
z2.installProduct(app, 'collective.js.jqueryui')
def registerATCTLogged(klass):
klassName = str(klass)
for c in ["<class 'Products.%s." % config.PROJECTNAME, "'>"]:
klassName = klassName.replace(c, '')
try:
registerATCT(klass, config.PROJECTNAME)
log('Done: registerATCT(%s)' %klassName)
except Exception, e:
log('Failed: registerATCT(%s): %s' %(klassName, str(e)))
raise e
def registerATCTLogged(klass):
klassName = str(klass)
for c in ["<class 'Products.%s." % PROJECTNAME, "'>"]:
klassName = klassName.replace(c, "")
try:
registerATCT(klass, PROJECTNAME)
log("Worked: registerType(%s)\n" % klassName)
except Exception, e:
log("Failed: registerType(%s): %s\n" % (klassName, str(e)))
raise e
def registerATCTLogged(klass):
klassName = str(klass)
for c in ["<class 'Products.%s." % config.PROJECTNAME, "'>"]:
klassName = klassName.replace(c, '')
try:
registerATCT(klass, config.PROJECTNAME)
log('Done: registerATCT(%s)' %klassName)
except Exception, e:
log('Failed: registerATCT(%s): %s' %(klassName, str(e)))
raise e
def registerATCTLogged(klass):
klassName = str(klass)
for c in ["<class 'Products.%s." % PROJECTNAME, "'>"]:
klassName = klassName.replace(c, '')
try:
registerATCT(klass, PROJECTNAME)
log('Worked: registerType(%s)\n' % klassName)
except Exception, e:
log('Failed: registerType(%s): %s\n' % (klassName, str(e)))
raise e
def test_checkinObjectLinkedInParentsRichTextField(self):
"""Checnking-in an object that is linked in it's
parent's rich text field. See: https://dev.plone.org/ticket/13462
"""
# register a folderish content type with a rich text field
from plone.app.folder.folder import ATFolder, ATFolderSchema
from Products.ATContentTypes.content.base import registerATCT
from Products.Archetypes import atapi
rich_text_folder_type = type('RichFolder', (ATFolder,), {})
rich_text_folder_type.schema = ATFolderSchema.copy() + atapi.Schema((
atapi.TextField('text',
default_output_type = 'text/x-html-safe',
widget = atapi.RichWidget(),
),
),
)
registerATCT(rich_text_folder_type, 'plone.app.iterate')
# create a folderish object with a rich text field
self.portal.invokeFactory('Folder', 'rich_text_folder')
rich_text_folder = self.portal.rich_text_folder
# create the subobject
rich_text_folder.invokeFactory('Document', 'subobject')
subobject = rich_text_folder.subobject
subobject_uid = subobject.UID()
# link (by uid) the subobject in it's parent's rich text field
link_html = '<a class="internal-link" href="resolveuid/%s">Link to subobject</a>'
rich_text_folder.setText(link_html % subobject_uid)
# try to checkout and checkin the subobject
wc = ICheckinCheckoutPolicy(subobject).checkout(rich_text_folder)
ICheckinCheckoutPolicy(wc).checkin("updated")
# everything went right and the working copy is checked in
self.assertEqual(subobject_uid, wc.UID())
# find the right question
# TODO: this assumes that no questions exist with a duplicate id
if required_question in parent.objectIds():
question = parent[required_question]
else:
pages = parent.getFolderContents(contentFilter={'portal_type':'SubSurvey',}, full_objects=True)
for page in pages:
if required_question in page.objectIds():
question = page[required_question]
break
# TODO: this assumes the question actually exists
required_answer = self.getRequiredAnswer()
required_positive = self.getRequiredAnswerYesNo()
answer = question.getAnswerFor(userid)
if hasattr(answer, 'lower'):
if required_positive and answer == required_answer:
return True
elif answer != required_answer and not required_positive:
return True
return False
elif hasattr(answer, 'append'): # it's a list
if required_positive and required_answer in answer :
return True
elif required_answer not in answer and not required_positive:
return True
return False
else: # question not answered, so don't display
return False
registerATCT(SubSurvey, PROJECTNAME)
if 'title' not in kwargs:
kwargs['title'] = self.getImageCaption()
return self.getField('image').tag(self, **kwargs)
security.declarePrivate('cmf_edit')
def cmf_edit(self, text, description=None, text_format=None, **kwargs):
if description is not None:
self.setDescription(description)
self.setText(text, mimetype=translateMimetypeAlias(text_format))
self.update(**kwargs)
def __bobo_traverse__(self, REQUEST, name):
"""Transparent access to image scales
"""
if name.startswith('image'):
field = self.getField('image')
image = None
if name == 'image':
image = field.getScale(self)
else:
scalename = name[len('image_'):]
if scalename in field.getAvailableSizes(self):
image = field.getScale(self, scale=scalename)
if image is not None and not isinstance(image, basestring):
# image might be None or '' for empty images
return image
return ATDocumentBase.__bobo_traverse__(self, REQUEST, name)
registerATCT(ATNewsItem, PROJECTNAME)
('dt',
self.translate( msgid='vocabulary_postingdt_text',
domain='ploneformgen',
default='Posting Date/Time')
),
('HTTP_X_FORWARDED_FOR','HTTP_X_FORWARDED_FOR',),
('REMOTE_ADDR','REMOTE_ADDR',),
('HTTP_USER_AGENT','HTTP_USER_AGENT',),
) )
def vocabFormatDL(self):
""" returns vocabulary for format """
return DisplayList( (
('tsv',
self.translate( msgid='vocabulary_tsv_text',
domain='ploneformgen',
default='Tab-Separated Values')
),
('csv',
self.translate( msgid='vocabulary_csv_text',
domain='ploneformgen',
default='Comma-Separated Values')
),
) )
registerATCT(FormSaveDataAdapter, PROJECTNAME)
super(BaseFormField, self).__init__(oid, **kwargs)
# set a preconfigured field as an instance attribute
self.fgField = MyLocationField('fg_location_field',
languageIndependent = 1,
default_method="getDefaultLocation",
required=True,
write_permission = View,
validators=('isGeoLocation',),
tmp_value = None,
widget=LocationWidget(
label='Location',
),
)
def fgPrimeDefaults(self, request, contextObject=None):
""" primes request with default value"""
BaseFormField.fgPrimeDefaults(self, request, contextObject)
form_val = request.get(self.fgField.__name__, None)
if form_val:
self.fgField.tmp_value = form_val
else:
config = getMultiAdapter((self, request), name="maps_configuration")
self.fgField.tmp_value = config.default_location
request.form.setdefault(self.fgField.__name__, self.fgField.tmp_value)
registerATCT(FGLocationField, PROJECTNAME)
'form',
'form_submit',
'fieldset',
'last_referer',
'add_reference',
)
if value in badIds:
raise BadRequest, 'The id "%s" is reserved.' % value
ATFolder.setId(self, value)
self.fsStartField.__name__ = self.getId()
def manage_afterAdd(self, item, container):
# XXX TODO: when we're done with 2.1.x, implement this via event subscription
ATFolder.manage_afterAdd(self, item, container)
id = self.getId()
if self.fsStartField.__name__ != id:
self.fsStartField.__name__ = id
# security is inherited
def checkIdAvailable(self, id):
""" Checks for good id by asking form folder """
return self.formFolderObject().checkIdAvailable(id)
registerATCT(FieldsetFolder, PROJECTNAME)
))
def vocabFormatDL(self):
# """ returns vocabulary for format """
formats = [
('tsv',
self.translate(msgid='vocabulary_tsv_text',
domain='ploneformgen',
default='Tab-Separated Values')
),
('csv',
self.translate(msgid='vocabulary_csv_text',
domain='ploneformgen',
default='Comma-Separated Values')
),
]
if has_xls:
formats.append(
('xls',
self.translate(msgid='vocabulary_xls_doc',
domain='ploneformgen',
default='Excel document')
),
)
return DisplayList(formats)
registerATCT(FormSaveDataAdapter, PROJECTNAME)
def register():
""" Register custom content-types
"""
registerATCT(Fiche, PROJECTNAME)
aggregate_answers = self.getAggregateAnswers()
for k, v in aggregate_answers.items():
if v > max:
max = v
pct_aggregate_answers = {}
for k, v in aggregate_answers.items():
if v == 0:
value = 0
else:
value = v / float(max)
pct_aggregate_answers[k] = int(value * 100)
return pct_aggregate_answers
@security.protected(View)
def getPercentages(self):
"""Return a mapping of percentages for each answer"""
total = 0
aggregate_answers = self.getAggregateAnswers()
for k, v in aggregate_answers.items():
total = v + total
pct_answers = {}
for k, v in aggregate_answers.items():
if v == 0:
value = 0
else:
value = v / float(total)
pct_answers[k] = int(value * 100)
return pct_answers
registerATCT(SurveyMatrixQuestion, PROJECTNAME)
raise NotImplementedError('FileField Not Yet Done')
value = REQUEST.form.get(field_name, '')
if iid:
if data.attrs.get(field_name, None) == value:
continue
modified_fields.append(field_name)
data.attrs[field_name] = value
sm = getSecurityManager()
if iid:
if modified_fields:
data.attrs['_auto_last_modified'] = now
log = {}
log['user'] = sm.getUser().getId()
log['date'] = now
log['fields'] = modified_fields
if '_auto_log' not in data.attrs:
data.attrs['_auto_log'] = PersistentList()
data.attrs['_auto_log'].append(log)
self.REQUEST.response.expireCookie('PFGSOUP_POST', path='/')
# XXX redirect to table
# self.REQUEST.response.redirect(...)
return
data.attrs['_auto_created'] = now
data.attrs['_auto_last_modified'] = now
data.attrs['_auto_userid'] = sm.getUser().getId()
data.attrs['_auto_log'] = PersistentList()
soup.add(data)
registerATCT(SoupAdapter, PROJECTNAME)
#item.setInfos_element(dico)
item.setInfosElement(dico)
def majCatalogueBU(self, recordid):
portal_primo = getToolByName(self, "portal_primo")
resultat = portal_primo.rechercherRecordById(recordid)
dico = {
"Title": resultat["title"],
"TypeRessourceExterne": "Catalogue BU",
"SousTitre": "",
"Description": "",
"Auteurs": (resultat["creator"]),
"Volume": resultat["format"],
"Lieu": "Lieu",
"Editeur": resultat["publisher"],
"Annee": 0,
"Pagination": "Pagination",
"Collection": resultat["creationdate"],
"Isbn": recordid,
"Urlbiblio": "Urlbiblio",
"Lecteur": ""
}
try:
dico["Lecteur"] = "\n".join(resultat["image"])
except:
pass
self.setProperties(dico)
registerATCT(JalonRessourceExterne, PROJECTNAME)
# Hook into mxTidy and replace the value with the tidied value.
field = self.getField('text')
# When an object is initialized the first time we have to
# set the filename and mimetype.
if not value and not field.getRaw(self):
if 'mimetype' in kwargs and kwargs['mimetype']:
field.setContentType(self, kwargs['mimetype'])
if 'filename' in kwargs and kwargs['filename']:
field.setFilename(self, kwargs['filename'])
# hook for mxTidy / isTidyHtmlWithCleanup validator
tidyOutput = self.getTidyOutput(field)
if tidyOutput:
value = tidyOutput
field.set(self, value, **kwargs) # set is ok
security.declarePrivate('getTidyOutput')
def getTidyOutput(self, field):
# Get the tidied output for a specific field from the request
# if available.
request = getattr(self, 'REQUEST', None)
if request is not None and isinstance(request, HTTPRequest):
tidyAttribute = '%s_tidier_data' % field.getName()
return request.get(tidyAttribute, None)
registerATCT(ATTopic, PROJECTNAME)
for k, v in aggregate_answers.items():
if v > max:
max = v
pct_aggregate_answers = {}
for k, v in aggregate_answers.items():
if v == 0:
value = 0
else:
value = v / float(max)
pct_aggregate_answers[k] = int(value * 100)
return pct_aggregate_answers
@security.protected(View)
def getPercentages(self):
"""Return a mapping of percentages for each answer"""
total = 0
aggregate_answers = self.getAggregateAnswers()
for k, v in aggregate_answers.items():
total = v + total
pct_answers = {}
for k, v in aggregate_answers.items():
if v == 0:
value = 0
else:
value = v / float(total)
pct_answers[k] = int(value * 100)
return pct_answers
registerATCT(SurveySelectQuestion, PROJECTNAME)
schema = JalonTermeGlossaireSchema
schema['description'].required = True
schema['description'].widget.label = "Définition"
schema['text'].required = False
schema['text'].mode = "r"
def ajouterTag(self, tag):
return jalon_utils.setTag(self, tag)
def getAttributsType(self):
return ["title", "description"]
def getAttributsTypeMod(self):
return {"title": "Title", "description": "Description"}
def setProperties(self, dico):
for key in dico.keys():
self.__getattribute__("set%s" % key)(dico[key])
self.reindexObject()
items = self.getRelatedItems()
#modification dans le cours
for item in items:
if item.portal_type in ["JalonCours"]:
#modification du titre dans le cours
element_cours = copy.deepcopy(item.getElementCours())
if self.getId() in element_cours:
element_cours[self.getId()]["titreElement"] = self.Title()
item.setElementsCours(element_cours)
registerATCT(JalonTermeGlossaire, PROJECTNAME)
#Dheeraj Sagar, Malad(W)
#Mumbai-400064, India
###############################################################################
from Products.Archetypes.atapi import *
from Products.ATContentTypes.content.folder \
import ATFolder as BaseClass
from Products.ATContentTypes.content.folder \
import ATFolderSchema as DefaultSchema
from Products.ATContentTypes.content.base import registerATCT
from ubify.coretypes.config import PROJECTNAME
schema = DefaultSchema.copy()
class GenericContainer(BaseClass):
__doc__ = BaseClass.__doc__ + "(customizable version)"
# portal_type = BaseClass.portal_type
# archetype_name = BaseClass.archetype_name
schema = schema
_at_rename_after_creation = True
# enable FTP/WebDAV and friends
PUT = BaseClass.PUT
registerATCT(GenericContainer, PROJECTNAME)
name='fg_selection_field',
searchable=0,
required=0,
widget=SelectionStringWidget(),
vocabulary='_get_selection_vocab',
enforceVocabulary=1,
write_permission=View)
def htmlValue(self, REQUEST):
""" Return value instead of key """
utils = getToolByName(self, 'plone_utils')
charset = utils.getSiteEncoding()
value = REQUEST.form.get(self.__name__, '')
vu = value.decode(charset)
vocabulary = self.fgField.Vocabulary(self)
item = dict(vocabulary).get(vu)
if self.fgFormat == 'radio' or (self.fgFormat == 'flex' and len(vocabulary) <= 4):
name = '{}_{}'.format(self.__name__, vu)
else:
name = '{}_SELECT'.format(self.__name__)
desc = REQUEST.form.get(name, None)
if item is None:
return vu
elif desc is None:
return safe_unicode(cgi.escape(item[0].encode(charset)))
else:
return '{}<br />{}'.format(safe_unicode(cgi.escape(item[0].encode(charset))), safe_unicode(cgi.escape(desc.decode(charset))))
registerATCT(PFGSelectionStringField, PROJECTNAME)
answertoolong = self.translate(
default='Answer too long, must have less characters than: ',
msgid='answer-too-long',
domain='plonesurvey')
state.setError(self.getId(),
answertoolong + str(self.getMaxLength()))
else:
self.addAnswer(value)
security.declareProtected(permissions.View, 'getValidators')
def getValidators(self):
"""Return a list of validators"""
validator_list = [
'None',
]
validator_list.extend(TEXT_VALIDATORS)
return validator_list
security.declareProtected(permissions.View, 'validateQuestion')
def validateQuestion(self, value):
"""Return a list of validators"""
validator = self.getValidation()
v = validation.validatorFor(validator)
return v(value)
registerATCT(SurveyTextQuestion, PROJECTNAME)
'variable', 'variableLabel', 'fixedPrice', 'stripePublishableKey',
'stripePanelLabel', 'stripeLabel', 'stripeCurrency'
]:
upper = fieldName[0].upper() + fieldName[1:]
exec('''
security.declareProtected(View, 'get%(upper)s')
def get%(upper)s(self):
return getattr(self.fgField, '%(name)s', '')
security.declareProtected(ModifyPortalContent, 'set%(upper)s')
def set%(upper)s(self, value, **kw):
self.fgField.%(name)s = value
''' % {
'name': fieldName,
'upper': upper
})
def htmlValue(self, REQUEST):
value = REQUEST.form.get(self.__name__, 'No Input')
if type(value) != dict:
return 'Invalid'
if 'error' in value:
return 'Error charging'
if 'charge_data' not in value:
return 'Card not charged for some reason'
return 'Charged to %s for $%s' % (value['charge_data']['email'],
value['original-amount'])
registerATCT(FGStripeField, PROJECTNAME)
# edit accessor uses getToolByName, which ends up in
# five.localsitemanager looking for a parent using a comparison
# on this object -> infinite recursion.
if IATEvent.providedBy(other):
return cmp((self.start_date, self.duration, self.title),
(other.start_date, other.duration, other.title))
elif isinstance(other, DateTime):
return cmp(self.start(), other)
else:
# TODO come up with a nice cmp for types
return cmp(self.title, other)
def __hash__(self):
return hash((self.start_date, self.duration, self.title))
security.declareProtected(ModifyPortalContent, 'update')
def update(self, event=None, **kwargs):
# Clashes with BaseObject.update, so
# we handle gracefully
info = {}
if event is not None:
for field in event.Schema().fields():
info[field.getName()] = event[field.getName()]
elif kwargs:
info = kwargs
ATCTContent.update(self, **info)
registerATCT(ATEvent, PROJECTNAME)
""" a folder suitable for holding a very large number of items """
implements(IATUnifiedFolder, IATBTreeFolder, IArchivable, IPhotoAlbumAble)
__implements__ = folder_implements
schema = ATFolderSchema
security = ClassSecurityInfo()
portal_type = 'Folder'
archetype_name = 'Folder'
assocMimetypes = ()
assocFileExt = ()
cmf_edit_kws = ()
# Enable marshalling via WebDAV/FTP/ExternalEditor.
__dav_marshall__ = True
security.declareProtected(View, 'getNextPreviousParentValue')
def getNextPreviousParentValue(self):
""" If the parent node is also an IATFolder and has next/previous
navigation enabled, then let this folder have it enabled by
default as well """
parent = self.getParentNode()
if IATFolder.providedBy(parent):
return parent.getNextPreviousEnabled()
else:
return False
registerATCT(ATFolder, packageName)
#You can also contact Cynapse at:
#802, Building No. 1,
#Dheeraj Sagar, Malad(W)
#Mumbai-400064, India
###############################################################################
from Products.Archetypes.atapi import *
from Products.ATContentTypes.content.newsitem \
import ATNewsItem as BaseClass
from Products.ATContentTypes.content.newsitem \
import ATNewsItemSchema as DefaultSchema
from Products.ATContentTypes.content.base import registerATCT
from ubify.coretypes.config import PROJECTNAME
schema = DefaultSchema.copy()
class ATNewsItem(BaseClass):
__doc__ = BaseClass.__doc__ + "(customizable version)"
portal_type = BaseClass.portal_type
archetype_name = BaseClass.archetype_name
schema = schema
registerATCT(ATNewsItem, PROJECTNAME)
""" set simple validator """
fgt = getToolByName(self, 'formgen_tool')
if value and (value != 'vocabulary_none_text'):
fgtid = fgt.stringValidators[value].get('id')
if fgtid:
self.fgField.validators = ('isNotTooLong', fgtid)
else:
self.fgField.validators = ('isNotTooLong',)
self.fgField._validationLayer()
self.fgStringValidator = value
registerATCT(FGStringField, PROJECTNAME)
class FGPasswordField(FGStringField):
""" Password entry field (input is masked) """
schema = BaseFieldSchemaStringDefault.copy() + Schema((
maxlengthField,
sizeField,
))
# attributes that are not really useful for Password field.
del schema['hidden']
del schema['serverSide']
del schema['placeholder']
# five.localsitemanager looking for a parent using a comparison
# on this object -> infinite recursion.
if IATEvent.providedBy(other):
return cmp((self.start_date, self.duration, self.title),
(other.start_date, other.duration, other.title))
elif isinstance(other, DateTime):
return cmp(self.start(), other)
else:
# TODO come up with a nice cmp for types
return cmp(self.title, other)
def __hash__(self):
return hash((self.start_date, self.duration, self.title))
registerATCT(ATEvent, packageName)
class StartEndDateValidator(object):
"""Checks whether startDate is before endDate. In case the event is
openEnded this check is skipped.
"""
implements(IObjectPostValidation)
adapts(IATEvent)
def __init__(self, context):
self.context = context
def __call__(self, request):
rstartDate = request.form.get('startDate', None)
rendDate = request.form.get('endDate', None)
""" sample ordered btree-based folder (needing the interface) """
@implementer(IATFolder, IOrderedContainer)
class NonBTreeFolder(ATCTOrderedFolder):
""" an old-style folder much like `ATFolder` before Plone 4; this is
a reduced version of `ATContentTypes.content.folder.ATFolder` """
schema = ATFolderSchema
portal_type = 'NonBTreeFolder'
archetype_name = 'NonBTreeFolder'
security = ClassSecurityInfo()
permissions['NonBTreeFolder'] = PROJECTNAME + ': ATFolder'
registerATCT(NonBTreeFolder, PROJECTNAME)
def addNonBTreeFolder(container, id, **kwargs):
""" at-constructor copied from ClassGen.py """
obj = NonBTreeFolder(id)
notify(ObjectCreatedEvent(obj))
container._setObject(id, obj)
obj = container._getOb(id)
obj.initializeArchetype(**kwargs)
notify(ObjectModifiedEvent(obj))
return obj
def _createObjectByType(type_name, container, cid, *args, **kw):
"""Create an object without performing security checks
# portal_type = BaseClass.portal_type
# archetype_name = BaseClass.archetype_name
schema = schema
_at_rename_after_creation = True
# enable FTP/WebDAV and friends
PUT = BaseClass.PUT
def manage_afterAdd(self, item, container):
if container.portal_type <> 'TempFolder' and item.portal_type == 'Wiki':
new_id = wikiid
new_title = wikititle
new_desc = wikidescription
try:
sattr = getattr(item,new_id)
except AttributeError:
sattr = item.invokeFactory(id=new_id,type_name="Document",title=new_title,description=new_desc,text=wikibody)
if type(sattr) == type("str"):
obj = getattr(item,sattr)
else:
obj = sattr
if obj <> None and obj.portal_type == "Document":
if obj.id in item.objectIds():
item.setDefaultPage(obj.id)
registerATCT(Wiki, PROJECTNAME)
@security.protected(ModifyPortalContent)
def setRemoteUrl(self, value, **kwargs):
# Remute url mutator.
# Use urlparse to sanify the url
# Also see http://dev.plone.org/plone/ticket/3296
if value:
value = urlparse.urlunparse(urlparse.urlparse(value))
self.getField('remoteUrl').set(self, value, **kwargs)
@security.protected(View)
def remote_url(self):
# CMF compatibility method.
return self.getRemoteUrl()
@security.private
def cmf_edit(self, remote_url=None, **kwargs):
if not remote_url:
remote_url = kwargs.get('remote_url', None)
self.update(remoteUrl=remote_url, **kwargs)
@security.protected(View)
def getRemoteUrl(self):
# Sanitize output.
value = self.Schema()['remoteUrl'].get(self)
if not value:
value = '' # ensure we have a string
return quote(value, safe='?$#@/:=+;$,&%')
registerATCT(ATLink, PROJECTNAME)
from Products.CMFPlone import PloneMessageFactory as _
from Products.CMFCore.permissions import View
from Products.validation import V_REQUIRED
from interfaces import IMaterial
from ..config import PROJECTNAME
MaterialSchema = ATCTContent.schema.copy() + Schema((
FloatField('price',
required = True,
searchable = True,
default = 0.0,
validators = ('isDecimal',),
widget = DecimalWidget(
description = '',
label = _(u'', default=u'Price'),
size = 40)
),
), marshall=RFC822Marshaller()
)
class Material(ATCTContent):
implements(IMaterial)
portal_type = "Material"
archetype_name = ATCTContent.archetype_name
schema = MaterialSchema
registerATCT(Material, PROJECTNAME)
return self.fgFieldsDisplayList()
def fieldsDisplayList(self):
""" returns display list of fields with simple values """
return self.fgFieldsDisplayList(
withNone=True,
noneValue='#NONE#',
objTypes=(
'FormSelectionField',
'FormStringField',
)
)
security.declareProtected(ModifyPortalContent, 'setShowFields')
def setShowFields(self, value, **kw):
""" Reorder form input to match field order """
# This wouldn't be desirable if the PickWidget
# retained order.
self.showFields = []
for field in self.fgFields(excludeServerSide=False):
id = field.getName()
if id in value:
self.showFields.append(id)
registerATCT(FormMailerAdapter, PROJECTNAME)
# -*- coding: utf-8 -*-
from plone.app.folder.folder import ATFolder, ATFolderSchema
from Products.ATContentTypes.content.base import registerATCT
from Products.Archetypes import atapi
RichFolderSchema = ATFolderSchema.copy() + atapi.Schema((
atapi.TextField('text',
default_output_type='text/x-html-safe',
widget=atapi.RichWidget(),
),
))
class RichFolder(ATFolder):
""" sample content type for testing purposes """
schema = RichFolderSchema
portal_type = 'RichFolder'
registerATCT(RichFolder, 'plone.app.iterate')
def addRichFolder(container, id, **kwargs):
""" at-constructor copied from ClassGen.py """
obj = RichFolder(id)
container._setObject(id, obj, suppress_events=True)
obj = container._getOb(id)
obj.manage_afterAdd(obj, container)
obj.initializeArchetype(**kwargs)
return obj.getId()
def defaultWidth(self):
return self.getConfig().default_map_size[1]
def defaultHeight(self):
return self.getConfig().default_map_size[0]
def defaultCatBoxHeight(self):
mapHeight = int(self.defaultHeight())
return (mapHeight * 35 / 100) # 35% total map height
def defaultMarkerBoxHeight(self):
mapHeight = int(self.defaultHeight())
return (mapHeight * 55 / 100) # 55% total map height
def getMarkersVocabulary(self):
vocabulary = atapi.DisplayList()
vocabulary.add('','-')
for cat in self.getFolderContents(contentFilter={'portal_type':('TTGoogleMapCategory','TTGoogleMapCategoryCT'),'path':{'depth':3, 'query':'/'.join(self.getPhysicalPath()) }}):
category = cat.getObject()
markers = category.getMarkers()
for item in markers:
marker = item.getObject()
if not marker.isDisabled():
vocabulary.add( str(item.UID), item.pretty_title_or_id())
return vocabulary
base.registerATCT(TTGoogleMap, PROJECTNAME)
if int(startingYear) > int(endingYear):
errors['endingYear'] = u'End year can not be before start year.'
if futureYears:
try:
futureYears = int(futureYears)
except ValueError:
errors['futureYears'] = u'Future years must be an integer.'
return errors
security.declareProtected(permissions.View, 'getInputType')
def getInputType(self):
"""Return a hard coded input type"""
return 'date'
security.declareProtected(permissions.View, 'validateAnswer')
def validateAnswer(self, form, question_id, state):
"""Validate the question"""
"""Construct the deadline from the form"""
year = form.get(question_id + '_year', '0')
month = form.get(question_id + '_month', '0')
day = form.get(question_id + '_day', '0')
hour = form.get(question_id + '_hour', '0')
minute = form.get(question_id + '_minute', '00')
minute = form.get(question_id + '_minute', '00')
# TODO this is not going to work outside GMT
# XXX could do with some validation as well
value = year + '/' + month + '/' + day + ' ' + hour + ':' + minute + ':00 GMT'
self.addAnswer(value)
registerATCT(SurveyDateQuestion, PROJECTNAME)
field = self[item_id].fgField
field.required = not field.required
return "<done />"
security.declareProtected(ModifyPortalContent, 'toggleRequired')
def removeFieldFromForm(self, item_id, **kw):
""" remove field on the fly from the form"""
self.manage_delObjects([item_id])
return "<done />"
security.declareProtected(ModifyPortalContent, 'lastFieldIdFromForm')
def lastFieldIdFromForm(self, **kw):
""" Retrieve the last field id in the current form"""
lastField = ''
myFields = []
for field in self.objectValues():
if shasattr(field, 'fgField') or shasattr(field, 'fieldsetFields'):
myFields.append(field)
if myFields:
lastField = myFields[-1].id
return lastField
registerATCT(FormFolder, PROJECTNAME)
# set a preconfigured field as an instance attribute
self.fgField = MyLocationField(
'fg_location_field',
languageIndependent=1,
default_method="getDefaultLocation",
required=True,
write_permission=View,
validators=('isGeoLocation', ),
tmp_value=None,
widget=LocationWidget(label='Location', ),
)
def fgPrimeDefaults(self, request, contextObject=None):
""" primes request with default value"""
BaseFormField.fgPrimeDefaults(self, request, contextObject)
form_val = request.get(self.fgField.__name__, None)
if form_val:
self.fgField.tmp_value = form_val
else:
config = getMultiAdapter((self, request),
name="maps_configuration")
self.fgField.tmp_value = config.default_location
request.form.setdefault(self.fgField.__name__,
self.fgField.tmp_value)
registerATCT(FGLocationField, PROJECTNAME)
width = ComputedAttribute(getWidth, 1)
height = ComputedAttribute(getHeight, 1)
security.declarePrivate('cmf_edit')
def cmf_edit(self, precondition='', file=None, title=None):
if file is not None:
self.setImage(file)
if title is not None:
self.setTitle(title)
self.reindexObject()
def __bobo_traverse__(self, REQUEST, name):
"""Transparent access to image scales
"""
if name.startswith('image'):
field = self.getField('image')
image = None
if name == 'image':
image = field.getScale(self)
else:
scalename = name[len('image_'):]
if scalename in field.getAvailableSizes(self):
image = field.getScale(self, scale=scalename)
if image is not None and not isinstance(image, basestring):
# image might be None or '' for empty images
return image
return ATCTFileContent.__bobo_traverse__(self, REQUEST, name)
registerATCT(ATImage, PROJECTNAME)
field.required = not field.required
return "<done />"
security.declareProtected(ModifyPortalContent, 'toggleRequired')
def removeFieldFromForm(self, item_id, **kw):
""" remove field on the fly from the form"""
self.manage_delObjects([item_id])
return "<done />"
security.declareProtected(ModifyPortalContent, 'lastFieldIdFromForm')
def lastFieldIdFromForm(self, **kw):
""" Retrieve the last field id in the current form"""
lastField = ''
myFields = []
for field in self.objectValues():
if shasattr(field, 'fgField') or shasattr(field, 'fieldsetFields'):
myFields.append(field)
if myFields:
lastField = myFields[-1].id
return lastField
registerATCT(FormFolder, PROJECTNAME)
#802, Building No. 1,
#Dheeraj Sagar, Malad(W)
#Mumbai-400064, India
###############################################################################
from Products.Archetypes.atapi import *
from Products.ATContentTypes.content.folder \
import ATFolder as BaseClass
from Products.ATContentTypes.content.folder \
import ATFolderSchema as DefaultSchema
from Products.ATContentTypes.content.base import registerATCT
from ubify.coretypes.config import PROJECTNAME
schema = DefaultSchema.copy()
class Gallery(BaseClass):
__doc__ = BaseClass.__doc__ + "(customizable version)"
# portal_type = BaseClass.portal_type
# archetype_name = BaseClass.archetype_name
schema = schema
_at_rename_after_creation = True
# enable FTP/WebDAV and friends
PUT = BaseClass.PUT
registerATCT(Gallery, PROJECTNAME)
else:
form_value = x.htmlValue(REQUEST)
if form_value:
cols[sharepoint_column.name] = form_value
response = target_list.createItem(fields=cols)
if not response.ok:
logger.error("Error submitting sharepoint form: %s", response.text)
return {FORM_ERROR_MARKER: 'An error occured while trying to submit your form. Please try to submit again..'}
if response.ok and upload_field:
form_value = form.get(upload_field)
drive = Drive(id=drive, client=sharepoint.client)
for f in form_value:
upload_instance = f.get('file')
body = upload_instance.read()
if (not body) or (not upload_instance.filename):
continue
now = datetime.now().strftime('%y-%m-%d-%H-%M-%S-%f')
filename = upload_instance.filename
# IE has the entire path instead of just the filename
# This should get just the filename
filename = filename[filename.rfind('\\')+1:].strip()
filename = response.json().get('id') + '-' + filename
ct = upload_instance.headers.getheader('Content-Type')
upload_response = drive.upload(filename, body, ct)
if not upload_response.ok:
logger.error("Error uploading attachments: %s", upload_response.text)
return {FORM_ERROR_MARKER: 'Something went wrong with the file upload. You will need to try to submit again or correct any errors below.'}
registerATCT(SharePointAdapter, PROJECTNAME)
height = ComputedAttribute(getHeight, 1)
@security.private
def cmf_edit(self, precondition='', file=None, title=None):
if file is not None:
self.setImage(file)
if title is not None:
self.setTitle(title)
self.reindexObject()
def __bobo_traverse__(self, REQUEST, name):
"""Transparent access to image scales
"""
if name.startswith('image'):
field = self.getField('image')
image = None
if name == 'image':
image = field.getScale(self)
else:
scalename = name[len('image_'):]
if scalename in field.getAvailableSizes(self):
image = field.getScale(self, scale=scalename)
if image is not None and not isinstance(image, basestring):
# image might be None or '' for empty images
return image
return ATCTFileContent.__bobo_traverse__(self, REQUEST, name)
registerATCT(ATImage, PROJECTNAME)
file.seek(0)
content = file.read(65536)
else:
content = data
if -1 != content.lower().find("<html"):
parser = etree.HTMLParser()
tree = etree.fromstring(content, parser=parser)
titletag = tree.xpath("//title")
if titletag:
self.setTitle(titletag[0].text)
return
ATCTContent.manage_afterPUT(self, data, marshall_data, file, context, mimetype, filename, REQUEST, RESPONSE)
@implementer(IATDocument, IDAVAware)
class ATDocument(ATDocumentBase):
"""A page in the site. Can contain rich text."""
schema = ATDocumentSchema
portal_type = "Document"
archetype_name = "Page"
_atct_newTypeFor = {"portal_type": "CMF Document", "meta_type": "Document"}
assocMimetypes = ("application/xhtml+xml", "message/rfc822", "text/*")
assocFileExt = ("txt", "stx", "rst", "rest", "py")
registerATCT(ATDocument, PROJECTNAME)
def getEntries(self,num_of_entries):
"""Getter for syndacation support
"""
syn_tool = getToolByName(self, 'portal_syndication')
if num_of_entries is None:
num_of_entries = int(syn_tool.getMaxItems(self))
portal = self.portal_url.getPortalObject()
portal_path = "/".join(portal.getPhysicalPath())
mid = self.getId()
return self.queryfolderbytype(currentpath= portal_path,modifiers = (mid,))[0][:num_of_entries]
def synContentValues(self):
"""Getter for syndacation support
"""
syn_tool = getToolByName(self, 'portal_syndication')
num_of_entries = int(syn_tool.getMaxItems(self))
brains = self.getEntries(num_of_entries)
objs = [brain.getObject() for brain in brains]
return [obj for obj in objs if obj is not None]
def listApplications(self):
apps = []
apps.extend(applications)
apps.remove(apps[1])
return apps
registerATCT(MemberSpace, PROJECTNAME)
ATCTContent.manage_afterPUT(self, data, marshall_data, file, context,
mimetype, filename, REQUEST, RESPONSE)
class ATDocument(ATDocumentBase):
"""A page in the site. Can contain rich text."""
schema = ATDocumentSchema
portal_type = 'Document'
archetype_name = 'Page'
_atct_newTypeFor = {'portal_type': 'CMF Document', 'meta_type': 'Document'}
assocMimetypes = (
'application/xhtml+xml',
'message/rfc822',
'text/*',
)
assocFileExt = (
'txt',
'stx',
'rst',
'rest',
'py',
)
implements(IATDocument, IDAVAware)
registerATCT(ATDocument, PROJECTNAME)
#Dheeraj Sagar, Malad(W)
#Mumbai-400064, India
###############################################################################
from Products.Archetypes.atapi import *
from Products.ATContentTypes.content.folder \
import ATFolder as BaseClass
from Products.ATContentTypes.content.folder \
import ATFolderSchema as DefaultSchema
from Products.ATContentTypes.content.base import registerATCT
from ubify.coretypes.config import PROJECTNAME
schema = DefaultSchema.copy()
class LinkDirectory(BaseClass):
__doc__ = BaseClass.__doc__ + "(customizable version)"
# portal_type = BaseClass.portal_type
# archetype_name = BaseClass.archetype_name
schema = schema
_at_rename_after_creation = True
# enable FTP/WebDAV and friends
PUT = BaseClass.PUT
registerATCT(LinkDirectory, PROJECTNAME)
items = []
for i in range(len(value)):
label = field.fgField.questionSet[i]
items.append('%s: %s' % (label, value.get(str(i + 1), '')))
value = items
# Convert list values
if isinstance(value, list):
# Store lines newline-separated?
value = DELIMITER.join(value)
return value
def _unmassageValue(self, value, field):
""" Reverse the storage massaging
"""
if field.meta_type in [
'FormMultiSelectionField',
]:
value = value and value.split(DELIMITER)
elif field.meta_type == 'FormLikertField':
# convert back to likert-style dict
items = value.split(DELIMITER)
value_dict = {}
for i, item in enumerate(items):
question, answer = item.split(': ', 1)
value_dict[str(i + 1)] = answer
value = value_dict
return value
registerATCT(SQLPFGAdapter, PROJECTNAME)
security.declareProtected(View, 'getProjectRoom')
def getProjectRoom(self):
"""Return the closest project room"""
return self
security.declareProtected(View, 'getProjectRoomState')
def getProjectRoomState(self):
"""Return if the project room is private or public"""
wftool = getToolByName(self, 'portal_workflow')
return wftool.getInfoFor(self, "review_state")
registerATCT(ProjectRoom, PROJECTNAME)
@indexer(IProjectRoom)
def participants(context):
return context.participants
class ProjectRoomParticipantRoles(object):
"""Gives participants of a ProjectRoom appropriate roles in context"""
implements(ILocalRoleProvider)
adapts(IProjectRoom)
def __init__(self, context):
self.context = context
# five.localsitemanager looking for a parent using a comparison
# on this object -> infinite recursion.
if IATEvent.providedBy(other):
return cmp((self.start_date, self.duration, self.title),
(other.start_date, other.duration, other.title))
elif isinstance(other, DateTime):
return cmp(self.start(), other)
else:
# TODO come up with a nice cmp for types
return cmp(self.title, other)
def __hash__(self):
return hash((self.start_date, self.duration, self.title))
registerATCT(ATEvent, packageName)
class StartEndDateValidator(object):
"""Checks whether startDate is before endDate. In case the event is
openEnded this check is skipped.
"""
implements(IObjectPostValidation)
adapts(IATEvent)
def __init__(self, context):
self.context = context
def __call__(self, request):
rstartDate = request.form.get('startDate', None)
rendDate = request.form.get('endDate', None)
schema = FormNorobotsFieldSchema
def __init__(self, oid, **kwargs):
""" initialize class """
BaseFormField.__init__(self, oid, **kwargs)
# set a preconfigured field as an instance attribute
self.fgField = StringField('fg_string_field',
searchable=0,
required=1,
write_permission=View,
#validators=('isNorobotsCorrect',),
widget=NorobotsWidget(),
)
def specialValidator(self, value, field, REQUEST, errors):
""" validate our answer using the collective.z3cform.norobots validator
"""
field_name = field.getName()
question_id = REQUEST.get('%s_question_id' % field_name)
id_check = REQUEST.get('%s_id_check' % field_name)
norobots = getMultiAdapter((self, REQUEST), name='norobots')
if not norobots.verify(value, question_id, id_check):
return str('Wrong answer')
return 0
registerATCT(FormNorobotsField, PROJECTNAME)
LOG.error('MimeTypeException for %s. Error is: %s' %
(self.absolute_url(), str(msg)))
if not mimetypeitem:
return BaseContent.getIcon(self, relative_to_portal)
icon = mimetypeitem[0].icon_path
if relative_to_portal:
return icon
else:
# Relative to REQUEST['BASEPATH1']
res = utool(relative=1) + '/' + icon
while res[:1] == '/':
res = res[1:]
return res
security.declareProtected(View, 'icon')
def icon(self):
"""for ZMI
"""
return self.getIcon()
security.declarePrivate('cmf_edit')
def cmf_edit(self, precondition='', file=None):
if file is not None:
self.setFile(file)
registerATCT(ATFile, PROJECTNAME)
mimetypeitem = None
try:
mimetypeitem = mtr.lookup(contenttype)
except MimeTypeException, msg:
LOG.error('MimeTypeException for %s. Error is: %s' % (self.absolute_url(), str(msg)))
if not mimetypeitem:
return BaseContent.getIcon(self, relative_to_portal)
icon = mimetypeitem[0].icon_path
if relative_to_portal:
return icon
else:
# Relative to REQUEST['BASEPATH1']
res = utool(relative=1) + '/' + icon
while res[:1] == '/':
res = res[1:]
return res
security.declareProtected(View, 'icon')
def icon(self):
"""for ZMI
"""
return self.getIcon()
security.declarePrivate('cmf_edit')
def cmf_edit(self, precondition='', file=None):
if file is not None:
self.setFile(file)
registerATCT(ATFile, PROJECTNAME)
""" set simple validator """
fgt = getToolByName(self, 'formgen_tool')
if value and (value != 'vocabulary_none_text'):
fgtid = fgt.stringValidators[value].get('id')
if fgtid:
self.fgField.validators = ('isNotTooLong', fgtid)
else:
self.fgField.validators = ('isNotTooLong',)
self.fgField._validationLayer()
self.fgStringValidator = value
registerATCT(FGStringField, PROJECTNAME)
class FGPasswordField(FGStringField):
""" Password entry field (input is masked) """
schema = BaseFieldSchemaStringDefault.copy() + Schema((
maxlengthField,
sizeField,
))
# 'hidden' isn't really useful for this field.
del schema['hidden']
# 'serverSide' is not really useful for this field.
del schema['serverSide']
class Audio(BaseClass):
implements(IAudio)
__doc__ = BaseClass.__doc__ + "(customizable version)"
portal_type = "Audio"
archetype_name = BaseClass.archetype_name
assocFileExt = ('mp3', 'wav', )
if schema['file'] <> None:
schema['file'].widget.label = 'Audio'
schema['file'].widget.description = 'Select a .mp3 or .wav audio file.'
schema = schema
def manage_afterPUT(self, data, marshall_data, file, context, mimetype,filename, REQUEST, RESPONSE):
is_new = False
title = self.Title()
if not title:
is_new = True
BaseClass.manage_afterPUT(self, data, marshall_data, file, context, mimetype, filename, REQUEST, RESPONSE)
if is_new:
notify(ObjectInitializedEvent(self))
else:
notify(ObjectEditedEvent(self))
registerATCT(Audio, PROJECTNAME)
"""remute url mutator
Use urlparse to sanify the url
Also see http://dev.plone.org/plone/ticket/3296
"""
if value:
value = urlparse.urlunparse(urlparse.urlparse(value))
self.getField('remoteUrl').set(self, value, **kwargs)
security.declareProtected(View, 'remote_url')
def remote_url(self):
"""CMF compatibility method
"""
return self.getRemoteUrl()
security.declarePrivate('cmf_edit')
def cmf_edit(self, remote_url=None, **kwargs):
if not remote_url:
remote_url = kwargs.get('remote_url', None)
self.update(remoteUrl=remote_url, **kwargs)
security.declareProtected(View, 'getRemoteUrl')
def getRemoteUrl(self):
"""Sanitize output
"""
value = self.Schema()['remoteUrl'].get(self)
if not value: value = '' # ensure we have a string
return quote(value, safe='?$#@/:=+;$,&%')
registerATCT(ATLink, PROJECTNAME)
def getThanksPrologue(self):
""" get expanded prologue """
return self._dreplace( self.getRawThanksPrologue() )
security.declarePublic('getThanksEpilogue')
def getThanksEpilogue(self):
""" get expanded epilogue """
return self._dreplace( self.getRawThanksEpilogue() )
def processForm(self, data=1, metadata=0, REQUEST=None, values=None):
# override base so that we can selectively redirect back to the form
# rather than to the thanks page view.
# base processing
ATCTContent.processForm(self, data, metadata, REQUEST, values)
# if the referer is the item itself, let nature take its course;
# if not, redirect to form after a commit.
referer = self.REQUEST.form.get('last_referer', None)
if referer is not None and referer.split('/')[-1] != self.getId():
transaction.commit()
raise zExceptions.Redirect, "%s#qedit" % self.formFolderObject().absolute_url()
registerATCT(FormThanksPage, PROJECTNAME)
ClustererIcon = atapi.ATFieldProperty('ClustererIcon')
CategoryIcon = atapi.ATFieldProperty('CategoryIcon')
DefaultActive = atapi.ATFieldProperty('DefaultActive')
def markerIconVocab(self):
config = getMultiAdapter((self, self.REQUEST), name="ttgooglemap_config")
return config.marker_icons
def getParentMap(self, context = None):
if not context:
context = self.aq_inner
if ITTGoogleMap.providedBy(context):
return context
elif ISiteRoot.providedBy(context):
return None
else:
return self.getParentMap(context.aq_parent)
@ram.cache(markers_cachekey)
def getMarkers(self, **args):
log('Query the catalog to get markers for TTGoogleMapCategory. Category: "%s"' % self.Title())
filter={'portal_type':'TTGoogleMapMarker', 'review_state':'published'}
if args:
filter = dict(filter.items() + args.items())
return self.getFolderContents(contentFilter=filter);
base.registerATCT(TTGoogleMapCategory, PROJECTNAME)
atapi.StringField('testReadonlyField', mode='r'),
atapi.StringField('testWriteonlyField', mode='w'),
atapi.StringField('testReadPermissionField',
read_permission=permissions.ManagePortal),
atapi.StringField('testWritePermissionField',
write_permission=permissions.ManagePortal),
atapi.StringField('testURLField', validators=('isURL',)),
))
class ATTestDocument(ATDocumentBase):
"""A test type containing a set of standard Archetypes fields."""
schema = ATTestDocumentSchema
portal_type = 'ATTestDocument'
registerATCT(ATTestDocument, PROJECTNAME)
class ATTestFolder(ATFolder):
"""A test folderish Archetypes test type."""
schema = ATFolderSchema
portal_type = 'ATTestFolder'
registerATCT(ATTestFolder, PROJECTNAME)
