'SortKey', schemata="Description", validators=('SortKeyValidator', ), widget=DecimalWidget( label=_("Sort Key"), description=_( "Float value from 0.0 - 1000.0 indicating the sort order. " "Duplicate values are ordered alphabetically."), )) # Is the title of the analysis a proper Scientific Name? ScientificName = BooleanField( 'ScientificName', schemata="Description", default=False, widget=BooleanWidget( label=_("Scientific name"), description=_( "If enabled, the name of the analysis will be written in italics." ), )) # The units of measurement used for representing results in reports and in # manage_results screen. Unit = StringField( 'Unit', schemata="Description", widget=StringWidget( label=_("Unit"), description=_( "The measurement units for this analysis service' results, e.g. " "mg/l, ppm, dB, mV, etc."),
# populate catalog values, however the workflow review_history can be # used to get all dates of result capture ResultCaptureDate = DateTimeField( 'ResultCaptureDate' ) # If ReportDryMatter is True in the AnalysisService, the adjusted result # is stored here. ResultDM = StringField( 'ResultDM' ) # If the analysis has previously been retracted, this flag is set True # to indicate that this is a re-test. Retested = BooleanField( 'Retested', default=False ) # When the AR is published, the date of publication is recorded here. # It's used to populate catalog values. DateAnalysisPublished = DateTimeField( 'DateAnalysisPublished', widget=DateTimeWidget( label=_("Date Published") ) ) # If the result is outside of the detection limits of the method or instrument, # the operand (< or >) is stored here. For routine analyses this is taken # from the Result, if the result entered explicitly startswith "<" or ">" DetectionLimitOperand = StringField(
from bika.lims.browser.widgets import DecimalWidget from bika.lims.catalog.indexers.baseanalysis import sortable_title from bika.lims.content.abstractanalysis import AbstractAnalysis from bika.lims.content.abstractanalysis import schema from bika.lims.content.clientawaremixin import ClientAwareMixin from bika.lims.content.reflexrule import doReflexRuleAction from bika.lims.interfaces import IAnalysis from bika.lims.interfaces import ICancellable from bika.lims.interfaces import IDynamicResultsRange from bika.lims.interfaces import IInternalUse from bika.lims.interfaces import IRoutineAnalysis from bika.lims.interfaces.analysis import IRequestAnalysis from bika.lims.workflow import getTransitionDate # True if the analysis is created by a reflex rule IsReflexAnalysis = BooleanField('IsReflexAnalysis', default=False, required=0) # This field contains the original analysis which was reflected OriginalReflexedAnalysis = UIDReferenceField('OriginalReflexedAnalysis', required=0, allowed_types=('Analysis', )) # This field contains the analysis which has been reflected following # a reflex rule ReflexAnalysisOf = UIDReferenceField('ReflexAnalysisOf', required=0, allowed_types=('Analysis', )) # Which is the Reflex Rule action that has created this analysis ReflexRuleAction = StringField('ReflexRuleAction', required=0, default=0)
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'])
description=_(u'Default string to search for'), i18n_domain="eea")), StringField( 'autocomplete_view', schemata="default", required=True, vocabulary_factory='eea.faceted.vocabularies.AutocompleteViews', widget=SelectionWidget( label=_(u"Autocomplete"), description=_( u'Select the source of the autocomplete suggestions'), )), BooleanField('onlyallelements', schemata="default", widget=BooleanWidget( label=_(u'Search in all elements only'), description=_( u'If this checkbox is checked, hides the choice to ' 'filter in all items or in current items only'), i18n_domain="eea")), BooleanField('multivalued', schemata="default", default=True, widget=BooleanWidget( label=_(u'Can select several elements'), )), )) class Widget(AbstractWidget): """ Widget """ # Widget properties
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()
) ), StringField('default', schemata="default", widget=StringWidget( size=25, label=_(u'Default value'), description=_(u'Default string to search for'), i18n_domain="eea" ) ), BooleanField('onlyallelements', schemata="default", widget=BooleanWidget( label=_(u'Search in all elements only'), description=_(u'If this checkbox is checked, hides the choice to ' u'filter in all items or in current items only'), i18n_domain="eea" ) ), BooleanField('wildcard', schemata="default", widget=BooleanWidget( label=_(u'Wildcard search'), description=_(u"If this checkbox is checked, the system will " u"automatically do a wildcard search by appending " u"a '*' to the search term so " u"searching for 'budget' will also return elements " u"containing 'budgetary'."), i18n_domain="eea" )
from imio.dashboard.interfaces import ICustomViewFieldsVocabulary from imio.dashboard.interfaces import IDashboardCollection from imio.dashboard import ImioDashboardMessageFactory as _ ################################################################################ # # # DEPRECATED, THIS CONTENT WAS MOVED TO COLLECTIVE.EEAFACETED.DASHBOARD !!! # # # # STILL EXISTS FOR MIGRATION PURPOSE !!! # # # ################################################################################ DashboardCollectionSchema = CollectionSchema.copy() + atapi.Schema( (BooleanField( name="showNumberOfItems", required=False, widget=BooleanWidget(label=_(u'Show number of items in filter'), ), schemata="default", ), )) # hide these fields to avoid conflict with eea.facetednavigation parameters DashboardCollectionSchema['limit'].default = 0 DashboardCollectionSchema['b_size'].widget.visible = -1 DashboardCollectionSchema['limit'].widget.visible = -1 class DashboardCollection(Collection): """A Collection used in our dashboards""" implements(IDashboardCollection) meta_type = "DashboardCollection" schema = DashboardCollectionSchema security = ClassSecurityInfo()
from Products.Archetypes.Field import BooleanField from Products.Archetypes.Widget import BooleanWidget from Products.ATContentTypes.content.folder import ATFolder from Products.PloneArticle.interfaces import IPloneArticleMultiPage from Products.PloneArticle.config import PROJECTNAME schema = ATFolder.schema.copy() \ + Schema(( BooleanField( 'viewTOCFirst', default=False, widget=BooleanWidget( label='View table of contents first', label_msgid='label_view_toc_first', i18n_domain='plonearticle', visible={'view' : 'invisible'}, ) ), BooleanField( 'viewTOC', default=True, widget=BooleanWidget( label='Display table of contents in dropdown list', label_msgid='label_display_toc_dropdown', description='If you have checked properties to view TOC first, this property will not be applied.', description_msgid='description_display_toc_dropdown', i18n_domain='plonearticle', visible={'view' : 'invisible'}, )