def get(self, instance, **kwargs): value = LinesField.get(self, instance, **kwargs) or () columns = [] for column in value: try: columns.append(loads(column)) except: # BBB try: columns.append(parseColumn(column)) except: pass return columns
def update_meetingconfig_schema(baseSchema): specificSchema = Schema((LinesField( name='transitionsReinitializingTakenOverBy', default=[], widget=InAndOutWidget( label='TransitionsReinitializingTakenOverBy', label_msgid= 'MeetingSeraing_label_transitions_reinitializing_taken_over_by', i18n_domain='PloneMeeting', ), write_permission=WriteRiskyConfig, vocabulary='listEveryItemTransitions', ), ), ) completeSchema = baseSchema + specificSchema.copy() return completeSchema
# 'type': 'identifiertypeattributes', # 'subfields': ('title', 'description'), # 'required_subfields': ('title',), # 'subfield_labels': {'title': _('Attribute Title'), # 'description': _('Description')}, # 'subfield_sizes': {'title': 20, # 'description': 35}, # 'subfield_validators': {'title': 'identifiertypeattributesvalidator'}, # }) # security = ClassSecurityInfo() PortalTypes = LinesField( 'PortalTypes', vocabulary='getPortalTypes', widget=PicklistWidget( label=_("Portal Types"), description=_("Select the types that this ID is used to identify."), ), ) # Attributes = IdentifierTypeAttributesField( # 'Attributes', # widget=BikaRecordsWidget( # label=_("Identifier attributes"), # description=_("Each item identified with this IdentifierType can " # "contain additional information. The allowed # attributes " # "can be specified here."), # ), # )
class FGStripeField(FGStringField): """ A string entry field """ implements(IStripeField) security = ClassSecurityInfo() schema = FGStringField.schema.copy() + Schema( (LinesField( 'amounts', required=False, accessor="getAmounts", mutator="setAmounts", searchable=False, widget=LinesWidget( label='Available amounts', description='You can also provide a description of value ' 'using the | operator. Example: 10.00|$10 small')), BooleanField('variable', required=False, default=True, searchable=False, widget=BooleanWidget(label='Allow variable amount')), StringField('variableLabel', required=True, default='Amount: $', searchable=False, widget=StringWidget( label='Label used for variable amount field')), FixedPointField( 'fixedPrice', required=False, default='0.00', searchable=False, widget=DecimalWidget( label='Fixed amount', description='If filled in, ignore previous 2 fields.')), StringField('stripeSecretKey', require=True, searchable=False, view_permission=ModifyPortalContent, widget=StringWidget(label='Stripe Secret Key')), StringField('stripePublishableKey', require=True, searchable=False, widget=StringWidget(label='Stripe Publishable Key')), StringField('stripePanelLabel', required=True, searchable=False, default='More info about this', widget=StringWidget( label='The label of the payment button in the ' 'Checkout form')), StringField( 'stripeLabel', required=True, searchable=False, default='Authorize Donation', widget=StringWidget(label='Specify the text to be shown on the ' 'default blue button')), StringField('stripeCurrency', required=True, searchable=False, default='USD', widget=StringWidget(label='3 letter ISO currency code')), LinesField( 'stripeMetadata', required=False, default=[], vocabulary='getPFGFields', multiValued=True, widget=MultiSelectionWidget( label='Metadata Fields', description= 'Select the fields that should be included as metadata. ' 'You can only include 10 fields. Extras will be striped.')))) schema['required'].default = True schema['required'].widget.visible['edit'] = 'hidden' schema['hidden'].widget.visible['edit'] = 'hidden' schema['fgDefault'].widget.visible['edit'] = 'hidden' schema['fgmaxlength'].widget.visible['edit'] = 'hidden' schema['fgsize'].widget.visible['edit'] = 'hidden' schema['fgStringValidator'].widget.visible['edit'] = 'hidden' finalizeFieldSchema(schema, folderish=True, moveDiscussion=False) # Standard content type setup portal_type = meta_type = 'FormStripeField' archetype_name = 'StripeField' def __init__(self, oid, **kwargs): """ initialize class """ super(FGStripeField, self).__init__(oid, **kwargs) # set a preconfigured field as an instance attribute self.fgField = StripeField('fg_stripe_field', searchable=0, required=0, write_permission=View, widget=StripeWidget(), amounts=('10.00', '25.00', '50.00', '100.00'), variable=True, variableLabel='Amount: $', fixedPrice='0.00', stripeSecretKey='', stripePublishableKey='', stripePanelLabel='More info about this', stripeLabel='Authorize Donation', stripeCurrency='USD') def getPFGFields(self): form = aq_parent(aq_inner(self)) if form.portal_type == 'TempFolder': form = aq_parent(form) values = [] for field in form.values(): if (IPloneFormGenField.providedBy(field) and not IStripeField.providedBy(field)): values.append((field.getId(), field.Title())) return DisplayList(values) security.declareProtected(ModifyPortalContent, 'getStripeSecretKey') def getStripeSecretKey(self): # noqa return self.fgField.stripeSecretKey security.declareProtected(ModifyPortalContent, 'setStripeSecretKey') def setStripeSecretKey(self, value, **kw): # noqa self.fgField.stripeSecretKey = value security.declareProtected(View, 'getAmounts') def getAmounts(self): # noqa return self.fgField.amounts security.declareProtected(ModifyPortalContent, 'setAmounts') def setAmounts(self, value, **kw): # noqa self.fgField.amounts = value self.amounts = value # yikes, I'm lazy for fieldName in [ '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'])
# The total capacity and utilization of this container is the sum of values of # the capacity and utilization of the objects this container stores. PositionsLayout = RecordsField(name="PositionsLayout", subfields=("row", "column", "uid", "samples_capacity", "samples_utilization"), subfield_types={ "row": "int", "column": "int", "samples_capacity": "int", "samples_utilization": "int" }, widget=RecordsWidget(visible=False)) AvailablePositions = LinesField(name="AvailablePositions", required=0, subfields=("row", "column"), widget=LinesWidget(visible=False)) schema = BikaFolderSchema.copy() + Schema(( Rows, Columns, PositionsLayout, AvailablePositions, )) class StorageLayoutContainer(ATFolder): """Base class for storage containers """ implements(IStorageLayoutContainer) _at_rename_after_creation = True
def set(self, instance, value, **kwargs): value = [dumps(column.copy()) for column in value if column['name'].strip() and not column.get('delete', 0)] LinesField.set(self, instance, value, **kwargs)
class ExtensibleMetadata(Persistence.Persistent): """ A DC metadata implementation for Plone Archetypes """ implements(IExtensibleMetadata) security = ClassSecurityInfo() schema = type = MetadataSchema(( BooleanField( 'allowDiscussion', accessor="isDiscussable", mutator="allowDiscussion", edit_accessor="editIsDiscussable", default=None, enforceVocabulary=1, widget=BooleanWidget( label=_(u'label_allow_comments', default=u'Allow comments'), description=_(u'help_allow_comments', default=u'If selected, users can add comments ' 'to this item.')), ), LinesField( 'subject', multiValued=1, accessor="Subject", searchable=True, widget=TagsWidget( label=_(u'label_tags', default=u'Tags'), description=_(u'help_tags', default=u'Tags are commonly used for ad-hoc ' 'organization of content.'), ), ), TextField( 'description', default='', searchable=1, accessor="Description", default_content_type='text/plain', allowable_content_types=('text/plain', ), widget=TextAreaWidget( label=_(u'label_description', default=u'Description'), description=_( u'help_description', default=u'Used in item listings and search results.'), ), ), # Location, also known as Coverage in the DC metadata standard, but we # keep the term Location here for historical reasons. StringField( 'location', # why no accessor? http://dev.plone.org/plone/ticket/6424 searchable=True, widget=StringWidget( label=_(u'label_location', default=u'Location'), description=_( u'help_location_dc', default= u'The geographical location associated with the item, if applicable.' ), ), ), LinesField( 'contributors', accessor="Contributors", widget=AjaxSelectWidget( label=_(u'label_contributors', u'Contributors'), description=_( u'help_contributors', default=u"The names of people that have contributed " "to this item. Each contributor should " "be on a separate line."), vocabulary="plone.app.vocabularies.Users"), ), LinesField( 'creators', accessor="Creators", widget=AjaxSelectWidget( label=_(u'label_creators', u'Creators'), description=_( u'help_creators', default=u"Persons responsible for creating the content of " "this item. Please enter a list of user names, one " "per line. The principal creator should come first."), vocabulary="plone.app.vocabularies.Users"), ), DateTimeField( 'effectiveDate', mutator='setEffectiveDate', languageIndependent=True, widget=DatetimeWidget( label=_(u'label_effective_date', u'Publishing Date'), description=_( u'help_effective_date', default=u"The date when the item will be published. If no " "date is selected the item will be published immediately." ), ), ), DateTimeField( 'expirationDate', mutator='setExpirationDate', languageIndependent=True, widget=DatetimeWidget( label=_(u'label_expiration_date', u'Expiration Date'), description=_( u'help_expiration_date', default= u"The date when the item expires. This will automatically " "make the item invisible for others at the given date. " "If no date is chosen, it will never expire."), ), ), StringField( 'language', accessor="Language", default=config.LANGUAGE_DEFAULT, default_method='defaultLanguage', vocabulary='languages', widget=SelectWidget(label=_(u'label_language', default=u'Language'), ), ), TextField( 'rights', accessor="Rights", default_method='defaultRights', allowable_content_types=('text/plain', ), widget=TextAreaWidget( label=_(u'label_copyrights', default=u'Rights'), description=_( u'help_copyrights', default= u'Copyright statement or other rights information on this item.' ), )), )) + Schema(( # XXX change this to MetadataSchema in AT 1.4 # Currently we want to stay backward compatible without migration # between beta versions so creation and modification date are using the # standard schema which leads to AttributeStorage DateTimeField( 'creation_date', accessor='created', mutator='setCreationDate', default_method=DateTime, languageIndependent=True, isMetadata=True, schemata='metadata', generateMode='mVc', widget=DatetimeWidget( label=_(u'label_creation_date', default=u'Creation Date'), description=_(u'help_creation_date', default=u'Date this object was created'), visible={ 'edit': 'invisible', 'view': 'invisible' }), ), DateTimeField( 'modification_date', accessor='modified', mutator='setModificationDate', default_method=DateTime, languageIndependent=True, isMetadata=True, schemata='metadata', generateMode='mVc', widget=DatetimeWidget( label=_(u'label_modification_date', default=u'Modification Date'), description=_(u'help_modification_date', default=u'Date this content was modified last'), visible={ 'edit': 'invisible', 'view': 'invisible' }), ), )) def __init__(self): pass security.declarePrivate('defaultLanguage') def defaultLanguage(self): """Retrieve the default language""" tool = getToolByName(self, 'portal_languages', None) if tool is not None: return tool.getDefaultLanguage() return config.LANGUAGE_DEFAULT security.declarePrivate('defaultRights') def defaultRights(self): """Retrieve the default rights""" mdtool = getToolByName(self, 'portal_metadata', None) if mdtool is None: return '' for sid, schema in mdtool.listSchemas(): if not hasattr(schema, 'listPolicies'): # Broken class from CMFDefault. continue for pid, policy in schema.listPolicies(typ=self.Type()): if pid != 'Rights' and not policy.supply_default: continue return policy.default_value return '' security.declareProtected(permissions.View, 'isDiscussable') def isDiscussable(self, encoding=None): log_deprecated( "The isDiscussable method from the ExtensibleMetadata in " "Products.ATContentTypes has been deprecated and will be removed " "in Plone 5. This method belongs to the old discussion " "infrastructure that already has been replaced by " "plone.app.discussion in Plone 4.1.") if not 'portal_discussion' in self.objectIds(): return # Returns either True or False dtool = getToolByName(self, 'portal_discussion') return dtool.isDiscussionAllowedFor(self) security.declareProtected(permissions.View, 'editIsDiscussable') def editIsDiscussable(self, encoding=None): log_deprecated( "The editIsDiscussable method from the ExtensibleMetadata in " "Products.ATContentTypes has been deprecated and will be removed " "in Plone 5. This method belongs to the old discussion " "infrastructure that already has been replaced by " "plone.app.discussion in Plone 4.1.") if not 'portal_discussion' in self.objectIds(): return # Returns True, False or if None the default value result = self.rawIsDiscussable() if result is not None: return result default = self.defaultIsDiscussable() return default security.declareProtected(permissions.View, 'rawIsDiscussable') def rawIsDiscussable(self): log_deprecated( "The rawIsDiscussable method from the ExtensibleMetadata in " "Products.ATContentTypes has been deprecated and will be removed " "in Plone 5. This method belongs to the old discussion " "infrastructure that already has been replaced by " "plone.app.discussion in Plone 4.1.") if not 'portal_discussion' in self.objectIds(): return # Returns True, False or None where None means use the default result = getattr(aq_base(self), 'allow_discussion', None) if result is not None: result = bool(result) return result security.declareProtected(permissions.View, 'defaultIsDiscussable') def defaultIsDiscussable(self): log_deprecated( "The defaultIsDiscussable method from the ExtensibleMetadata in " "Products.ATContentTypes has been deprecated and will be removed " "in Plone 5. This method belongs to the old discussion " "infrastructure that already has been replaced by " "plone.app.discussion in Plone 4.1.") if not 'portal_discussion' in self.objectIds(): return # Returns the default value, either True or False default = None typeInfo = self.getTypeInfo() if typeInfo: default = typeInfo.allowDiscussion() return default security.declareProtected(permissions.ModifyPortalContent, 'allowDiscussion') def allowDiscussion(self, allowDiscussion=None, **kw): pass # Vocabulary methods ###################################################### security.declareProtected(permissions.View, 'languages') def languages(self): """Vocabulary method for the language field """ util = None use_combined = False # Respect the combined language code setting from PloneLanguageTool lt = getToolByName(self, 'portal_languages', None) if lt is not None: use_combined = lt.use_combined_language_codes # Try the utility first if HAS_PLONE_I18N: util = queryUtility(IMetadataLanguageAvailability) # Fall back to acquiring availableLanguages if util is None: languages = getattr(self, 'availableLanguages', None) if callable(languages): languages = languages() # Fall back to static definition if languages is None: return DisplayList( (('en', 'English'), ('fr', 'French'), ('es', 'Spanish'), ('pt', 'Portuguese'), ('ru', 'Russian'))) else: languages = util.getLanguageListing(combined=use_combined) languages.sort(key=lambda x: x[1]) # Put language neutral at the top. languages.insert(0, (u'', _(u'Language neutral'))) return DisplayList(languages) # DublinCore interface query methods ##################################### security.declareProtected(permissions.View, 'CreationDate') def CreationDate(self, zone=None): """ Dublin Core element - date resource created. """ if zone is None: zone = _zone creation = self.getField('creation_date').get(self) # return unknown if never set properly return creation is None and 'Unknown' or creation.toZone( zone).ISO8601() security.declareProtected(permissions.View, 'EffectiveDate') def EffectiveDate(self, zone=None): """ Dublin Core element - date resource becomes effective. """ if zone is None: zone = _zone effective = self.getField('effectiveDate').get(self) return effective is None and 'None' or effective.toZone(zone).ISO8601() def _effective_date(self): """Computed attribute accessor """ return self.getField('effectiveDate').get(self) security.declareProtected(permissions.View, 'effective_date') effective_date = ComputedAttribute(_effective_date, 1) security.declareProtected(permissions.View, 'ExpirationDate') def ExpirationDate(self, zone=None): """Dublin Core element - date resource expires. """ if zone is None: zone = _zone expires = self.getField('expirationDate').get(self) return expires is None and 'None' or expires.toZone(zone).ISO8601() def _expiration_date(self): """Computed attribute accessor """ return self.getField('expirationDate').get(self) security.declareProtected(permissions.View, 'expiration_date') expiration_date = ComputedAttribute(_expiration_date, 1) security.declareProtected(permissions.View, 'Date') def Date(self, zone=None): """ Dublin Core element - default date """ # Return effective_date if specifically set, modification date # otherwise if zone is None: zone = _zone effective = self.getField('effectiveDate').get(self) if effective is None: effective = self.modified() return (effective is None and DateTime().toZone(zone) or effective.toZone(zone).ISO8601()) security.declareProtected(permissions.View, 'Format') def Format(self): """cmf/backward compat Dublin Core element - resource format """ # FIXME: get content type from marshaller return self.getContentType() security.declareProtected(permissions.ModifyPortalContent, 'setFormat') def setFormat(self, value): """cmf/backward compat: ignore setFormat""" self.setContentType(value) def Identifer(self): """ dublin core getId method""" return self.getId() # DublinCore utility methods ############################################# security.declareProtected(permissions.View, 'contentEffective') def contentEffective(self, date): """Is the date within the resource's effective range? """ effective = self.getField('effectiveDate').get(self) expires = self.getField('expirationDate').get(self) pastEffective = (effective is None or effective <= date) beforeExpiration = (expires is None or expires >= date) return pastEffective and beforeExpiration security.declareProtected(permissions.View, 'contentExpired') def contentExpired(self, date=None): """ Is the date after resource's expiration """ if not date: date = DateTime() expires = self.getField('expirationDate').get(self) if not expires: expires = CEILING_DATE return expires <= date # CatalogableDublinCore methods ########################################## security.declareProtected(permissions.View, 'created') def created(self): """Dublin Core element - date resource created, returned as DateTime. """ # allow for non-existent creation_date, existed always created = self.getField('creation_date').get(self) return created is None and FLOOR_DATE or created security.declareProtected(permissions.View, 'modified') def modified(self): """Dublin Core element - date resource last modified, returned as DateTime. """ modified = self.getField('modification_date').get(self) # TODO may return None return modified security.declareProtected(permissions.View, 'effective') def effective(self): """Dublin Core element - date resource becomes effective, returned as DateTime. """ effective = self.getField('effectiveDate').get(self) return effective is None and FLOOR_DATE or effective security.declareProtected(permissions.View, 'expires') def expires(self): """Dublin Core element - date resource expires, returned as DateTime. """ expires = self.getField('expirationDate').get(self) return expires is None and CEILING_DATE or expires ## code below come from CMFDefault.DublinCore.DefaultDublinCoreImpl ####### ########################################################################### # # Copyright (c) 2001 Zope Corporation and Contributors. All Rights Reserved # # This software is subject to the provisions of the Zope Public License, # Version 2.0 (ZPL). A copy of the ZPL should accompany this distribution. # THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED # WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED # WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS # FOR A PARTICULAR PURPOSE # ########################################################################### # # Set-modification-date-related methods. # In DefaultDublinCoreImpl for lack of a better place. # security.declareProtected(permissions.ModifyPortalContent, 'notifyModified') def notifyModified(self): """ Take appropriate action after the resource has been modified. For now, change the modification_date. """ self.setModificationDate(DateTime()) if shasattr(self, 'http__refreshEtag'): self.http__refreshEtag() security.declareProtected(permissions.ManagePortal, 'setModificationDate') def setModificationDate(self, modification_date=None): """Set the date when the resource was last modified. When called without an argument, sets the date to now. """ if modification_date is None: modified = DateTime() else: modified = self._datify(modification_date) self.getField('modification_date').set(self, modified) security.declareProtected(permissions.ManagePortal, 'setCreationDate') def setCreationDate(self, creation_date=None): """Set the date when the resource was created. When called without an argument, sets the date to now. """ if creation_date is None: created = DateTime() else: created = self._datify(creation_date) self.getField('creation_date').set(self, created) security.declarePrivate('_datify') def _datify(self, date): """Try to convert something into a DateTime instance or None """ # stupid web if date == 'None': date = None if not isinstance(date, DateTime): if date is not None: date = DateTime(date) return date # # DublinCore interface query methods # security.declareProtected(permissions.View, 'Publisher') def Publisher(self): """Dublin Core element - resource publisher """ # XXX: fixme using 'portal_metadata' return 'No publisher' security.declareProtected(permissions.View, 'ModificationDate') def ModificationDate(self, zone=None): """ Dublin Core element - date resource last modified. """ if zone is None: zone = _zone modified = self.modified() return (modified is None and DateTime().toZone(zone) or modified.toZone(zone).ISO8601()) security.declareProtected(permissions.View, 'Type') def Type(self): """Dublin Core element - Object type""" if hasattr(aq_base(self), 'getTypeInfo'): ti = self.getTypeInfo() if ti is not None: return ti.Title() return self.meta_type security.declareProtected(permissions.View, 'Identifier') def Identifier(self): """Dublin Core element - Object ID""" # XXX: fixme using 'portal_metadata' (we need to prepend the # right prefix to self.getPhysicalPath(). return self.absolute_url() security.declareProtected(permissions.View, 'listContributors') def listContributors(self): """Dublin Core element - Contributors""" return self.Contributors() security.declareProtected(permissions.ModifyPortalContent, 'addCreator') def addCreator(self, creator=None): """ Add creator to Dublin Core creators. """ if creator is None: mtool = getToolByName(self, 'portal_membership', None) if mtool is None: return creator = mtool.getAuthenticatedMember().getId() # call self.listCreators() to make sure self.creators exists curr_creators = self.listCreators() if creator and not creator in curr_creators: self.setCreators(curr_creators + (creator, )) security.declareProtected(permissions.View, 'listCreators') def listCreators(self): """ List Dublin Core Creator elements - resource authors. """ creators = self.Schema()['creators'] if not creators.get(self): # for content created with CMF versions before 1.5 owner_tuple = self.getOwnerTuple() owner_id = owner_tuple and owner_tuple[1] if owner_id: creators.set(self, (owner_id, )) else: creators.set(self, ()) return creators.get(self) security.declareProtected(permissions.View, 'Creator') def Creator(self): """ Dublin Core Creator element - resource author. """ creators = self.listCreators() return creators and creators[0] or '' # # DublinCore utility methods # # Deliberately *not* protected by a security declaration # See https://dev.plone.org/archetypes/ticket/712 def content_type(self): """ WebDAV needs this to do the Right Thing (TM). """ return self.Format() # # CatalogableDublinCore methods # security.declareProtected(permissions.View, 'getMetadataHeaders') def getMetadataHeaders(self): """ Return RFC-822-style headers. """ hdrlist = [] hdrlist.append(('Title', self.Title())) hdrlist.append(('Subject', string.join(self.Subject(), ', '))) hdrlist.append(('Publisher', self.Publisher())) hdrlist.append(('Description', self.Description())) hdrlist.append(('Contributors', string.join(self.Contributors(), '; '))) hdrlist.append(('Creators', string.join(self.Creators(), '; '))) hdrlist.append(('Effective_date', self.EffectiveDate())) hdrlist.append(('Expiration_date', self.ExpirationDate())) hdrlist.append(('Type', self.Type())) hdrlist.append(('Format', self.Format())) hdrlist.append(('Language', self.Language())) hdrlist.append(('Rights', self.Rights())) return hdrlist # # Management tab methods # security.declarePrivate('_editMetadata') def _editMetadata( self, title=_marker, subject=_marker, description=_marker, contributors=_marker, effective_date=_marker, expiration_date=_marker, format=_marker, language=_marker, rights=_marker, ): """ Update the editable metadata for this resource. """ if title is not _marker: self.setTitle(title) if subject is not _marker: self.setSubject(subject) if description is not _marker: self.setDescription(description) if contributors is not _marker: self.setContributors(contributors) if effective_date is not _marker: self.setEffectiveDate(effective_date) if expiration_date is not _marker: self.setExpirationDate(expiration_date) if format is not _marker: self.setFormat(format) if language is not _marker: self.setLanguage(language) if rights is not _marker: self.setRights(rights) security.declareProtected(permissions.ModifyPortalContent, 'manage_metadata') manage_metadata = DTMLFile('zmi_metadata', config._www) security.declareProtected(permissions.ModifyPortalContent, 'manage_editMetadata') def manage_editMetadata( self, title, subject, description, contributors, effective_date, expiration_date, format, language, rights, REQUEST, ): """ Update metadata from the ZMI. """ self._editMetadata( title, subject, description, contributors, effective_date, expiration_date, format, language, rights, ) REQUEST['RESPONSE'].redirect(self.absolute_url() + '/manage_metadata' + '?manage_tabs_message=Metadata+updated.') security.declareProtected(permissions.ModifyPortalContent, 'editMetadata') def editMetadata( self, title='', subject=(), description='', contributors=(), effective_date=None, expiration_date=None, format='text/html', language='en-US', rights='', ): """ used to be: editMetadata = WorkflowAction(_editMetadata) Need to add check for webDAV locked resource for TTW methods. """ self.failIfLocked() self._editMetadata( title=title, subject=subject, description=description, contributors=contributors, effective_date=effective_date, expiration_date=expiration_date, format=format, language=language, rights=rights, ) self.reindexObject()
def __init__(self, name, **kwargs): """Make sure we get a tree name.""" LinesField.__init__(self, name, **kwargs) if not self.tree: raise KeyError('Arboreal fields need a tree argument')