def gen_class(klass, schema=None): """generats and registers the klass """ if schema is not None: klass.schema = schema.copy() registerType(klass, 'AttachmentFieldTest') content_types, constructors, ftis = process_types(listTypes(), PKG_NAME)
def registerTypeLogged(klass): klassName = str(klass) for c in ["<class 'Products.%s." % PROJECTNAME, "'>"]: klassName = klassName.replace(c, "") try: registerType(klass) log("Worked: registerType(%s)\n" % klassName) except Exception, e: log("Failed: registerType(%s): %s\n" % (klassName, str(e))) raise e
def registerTypeLogged(klass): klassName = str(klass) for c in ["<class 'Products.%s." % PROJECTNAME, "'>"]: klassName = klassName.replace(c, '') try: registerType(klass) log('Worked: registerType(%s)\n' % klassName) except Exception, e: log('Failed: registerType(%s): %s\n' % (klassName, str(e))) raise e
def registerTypeLogged(klass): klassName = str(klass) for c in ["<class 'Products.%s." % config.PROJECTNAME, "'>"]: klassName = klassName.replace(c, '') try: registerType(klass, config.PROJECTNAME) log('Done: registerType(%s)' %klassName) except Exception, e: log('Failed: registerType(%s): %s' %(klassName, str(e))) raise e
from Products.Archetypes.public import ReferenceWidget, Schema, registerType from archetypes.z3crelationfield.field import ZCRelationField from Products.ATContentTypes.content.base import ATCTContent from Products.ATContentTypes.content.schemata import ATContentTypeBaseSchema class ZCRelationFieldDemoContent(ATCTContent): """ A demo content type using ZCRelationField. """ meta_type = 'ZCRelationFieldDemoContent' portal_type = 'ZCRelationFieldDemoContent' schema = ATContentTypeBaseSchema.copy() + Schema(( ZCRelationField( 'zcrelations', role='Owner', relationship='foo', allowed_types=('Document', 'example.ttwpage'), enforceVocabulary=True, widget=ReferenceWidget( label='ZC Relations', macro_view='zcrelations_widget/index', ), ), )) registerType(ZCRelationFieldDemoContent, 'archetypes.z3crelationfield')
from Products.SimpleAttachment.config import PROJECTNAME from Products.SimpleAttachment.interfaces import IImageAttachment class ImageAttachment(ATImage): """An image attachment""" implements(IImageAttachment) portal_type = meta_type = 'ImageAttachment' def index_html(self, REQUEST, RESPONSE): """ download the file inline or as an attachment """ field = self.getPrimaryField() if isinstance(field.get(self), File): return field.get(self).index_html(REQUEST, RESPONSE) return field.index_html(self, REQUEST, RESPONSE) def getFilename(self, key=None): """Returns the filename from a field. """ if key is None: return self.getId() else: field = self.getField(key) or getattr(self, key, None) if field and shasattr(field, 'getFilename'): return field.getFilename(self) registerType(ImageAttachment, PROJECTNAME)
is_active=True, sort_on="sortable_title"): pairs.append((contact.UID, contact.Title)) return DisplayList(pairs) @security.public def getSupervisor(self): """Returns the assigned supervisor :returns: Supervisor object """ return self.getField("Supervisor").get(self) @security.public def getSupervisorUID(self): """Returns the UID of the assigned Supervisor NOTE: This is the default accessor of the `Supervisor` schema field and needed for the selection widget to render the selected value properly in _view_ mode. :returns: Supervisor UID """ supervisor = self.getSupervisor() if not supervisor: return None return api.get_uid(supervisor) registerType(Laboratory, PROJECTNAME)
limit = int(syn_tool.getMaxItems(self)) brains = self.getEntryInCategory(\ category_ids = [self.getInternal_id()], batch=True, sort_order='reverse', b_size=limit,b_start= 0,full_objects=False) objs = [brain.getObject() for brain in brains] return [obj for obj in objs if obj is not None] security.declarePrivate('manage_afterAdd') def manage_afterAdd(self, item, container): # Do internal ID management # Find out max category ID if not self.getInternal_id(): a_id = 0 for cat in container.objectValues([self.meta_type]): try: a_id = max(cat.getInternal_id(),a_id) except: pass self.setInternal_id(a_id + 1) #Call base class initialize method ATCTFolder.manage_afterAdd(self, item, container) registerType(COREBlogCategory, PROJECTNAME)
# details. # # You should have received a copy of the GNU General Public License along with # this program; if not, write to the Free Software Foundation, Inc., 51 # Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. # # Copyright 2018-2020 by it's authors. # Some rights reserved, see README and LICENSE. from AccessControl import ClassSecurityInfo from Products.Archetypes.public import BaseContent from Products.Archetypes.public import registerType from bika.lims.content.bikaschema import BikaSchema from bika.health.config import PROJECTNAME schema = BikaSchema.copy() schema['description'].widget.visible = True schema['description'].schemata = 'default' class CaseOutcome(BaseContent): security = ClassSecurityInfo() displayContentsTab = False schema = schema _at_rename_after_creation = True def _renameAfterCreation(self, check_auto_id=False): from bika.lims.idserver import renameAfterCreation renameAfterCreation(self) registerType(CaseOutcome, PROJECTNAME)
schema['description'].schemata = 'default' schema['description'].widget.visible = True class LabHost(BaseContent): security = ClassSecurityInfo() implements(ILabHost, IConstrainTypes) displayContentsTab = False schema = schema _at_rename_after_creation = True def _renameAfterCreation(self, check_auto_id=False): from bika.lims.idserver import renameAfterCreation renameAfterCreation(self) # # def Title(self): # return safe_unicode(self.getField('SampleDonorID').get(self)).encode('utf-8') # # def Description(self): # return "Gender %s : Age %s %s" % (self.getSex(), self.getAge(), self.getAgeUnit()) # # def getSexes(self): # return ['Male', 'Female', 'Unknown', 'Undifferentiated'] # # def getAgeUnits(self): # return ['Years', 'Months', 'Weeks', 'Days', 'Hours', 'Minutes'] registerType(LabHost, config.PROJECTNAME)
""" RejectAnalysis """ from Products.Archetypes.public import registerType from bika.lims.content.analysis import Analysis from bika.lims.config import PROJECTNAME from bika.lims import bikaMessageFactory as _ class RejectAnalysis(Analysis): archetype_name = 'RejectAnalysis' registerType(RejectAnalysis, PROJECTNAME)
# details. # # You should have received a copy of the GNU General Public License along with # this program; if not, write to the Free Software Foundation, Inc., 51 # Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. # # Copyright 2018-2019 by it's authors. # Some rights reserved, see README and LICENSE. from AccessControl import ClassSecurityInfo from Products.Archetypes.public import BaseContent from Products.Archetypes.public import registerType from bika.lims.content.bikaschema import BikaSchema from bika.health.config import PROJECTNAME schema = BikaSchema.copy() schema['description'].widget.visible = True schema['description'].schemata = 'default' class CaseStatus(BaseContent): security = ClassSecurityInfo() displayContentsTab = False schema = schema _at_rename_after_creation = True def _renameAfterCreation(self, check_auto_id=False): from bika.lims.idserver import renameAfterCreation renameAfterCreation(self) registerType(CaseStatus, PROJECTNAME)
except WorkflowException: state = wf_tool.getInfoFor(self, 'review_state') workflow = wf_tool.getWorkflowsFor(self)[0].id objectPath = "/".join(self.getPhysicalPath()) log("WeblogEntry.retract failed, most probable because the current " "state '%s' of workflow '%s' of entry '%s' does not define a " "transition 'retract'. To solve this either use another workflow, " "adapt the workflow, or restrain from using this method for now. " "Sorry." % (state, workflow, objectPath)) raise self.setPublicationDate(None) self.reindexObject() security.declareProtected(perms.EditContent, 'isPublished') def isPublished(self): """See IWorkflowedWeblogEntry. """ wf_tool = getToolByName(self, 'portal_workflow') review_state = wf_tool.getInfoFor(self, 'review_state') weblog_config = IWeblogEnhancedConfiguration(self.getWeblog()) return review_state in weblog_config.published_states security.declareProtected(perms.View, 'getWeblogEntryContentObject') def getWeblogEntryContentObject(self): """See IWeblogEntry. """ return self registerType(WeblogEntry, PROJECTNAME)
ImageField( name = 'hmm', sizes = {'tiny': (42, 42)}, widget = ImageWidget(label='Image', description='an image')), )) class SampleType(BaseContent): portal_type = 'SampleType' schema = SampleSchema permissions['SampleType'] = packageName + ': SampleType' registerType(SampleType, packageName) class BaseFieldTests(ReplacementTestCase): def create(self, id='foo', **kw): container = self.folder obj = SampleType(id) obj = container[container._setObject(id, obj)] obj.initializeArchetype(**kw) return obj def testFileField(self): foo = self.create(foo=getFile('test.pdf')) self.assertEqual(str(foo.getFoo()), getFile('test.pdf').read())
@security.protected(MergeConversation) def manage_pasteObjects(self, cp): """ merge another conversation """ try: op, mdatas = _cb_decode(cp) except Exception: raise CopyError("Invalid content") if op == 0: raise ValueError('Not allowed to copy content into conversation') if op != 1: raise ValueError("Invalid operation of content") obj = self.unrestrictedTraverse(mdatas[0]) if IConversation.providedBy(obj): if obj.getParentNode() != self.getParentNode(): raise ValueError("Invalid parent of content") forum = obj.getForum() obj_id = obj.getId() o_list = obj.objectValues() oblist = [Moniker(o1).dump() for o1 in o_list] cp = (1, oblist) cp = _cb_encode(cp) CopyContainer.manage_pasteObjects(self, cp) forum.manage_delObjects([obj_id]) elif IComment.providedBy(obj): return CopyContainer.manage_pasteObjects(self, cp) else: raise ValueError('Invalid type of content') registerType(PloneboardConversation, PROJECTNAME)
for member in portal_membership.listMembers(): login = member.getId() password = member.getPassword() properties={'username':member.getId(),'fullname':member.getProperty('fullname'),'email':member.getProperty('email')} logger.info( "%s|%s|%s|%s" % (login, properties['fullname'], properties['email'], password)) print >> out, "%s|%s|%s|%s" % (login, member.getProperty('fullname'), member.getProperty('email'), password) # membrane breaks this: portal_membership.deleteMembers([login,]) if password is None: password = '******' newmember = self.addMember(login, password, properties=properties) newmember.setPasswordDigested(password) return out.getvalue() def test_createUsers(self): """ Create some users to make testing easier """ out = StringIO.StringIO() for login in ('author1', 'author2', 'author3', 'ebmember1', 'ebmember2', 'ebmember3'): properties={'username': login,'fullname': "John %s" % login,'email': "*****@*****.**" % login} print >> out, "%s|%s|%s|%s" % (login, properties['fullname'], properties['email'], password) newmember = self.addMember(login, '12345', properties=properties) return out.getvalue() atapi.registerType(gcUserContainer, PROJECTNAME) InitializeClass(gcUserContainer)
if report.getId() == reportName: return report return None def setReportList(self,reportList): """ set reports list as -> [str:reportName]""" self._reportList = reportList _defaultReport = None def setDefaultReport(self,reportName): """ the report reportName is displayed at View action """ self._defaultReport = self.getReport(reportName) for report in self.getReportList(): if not report.getId() == reportName: report.unsetDefault() def getDefaultReport(self,): """ gets the default report """ if not self._defaultReport: if not self.getReportList(): return None self._defaultReport = self._reportList[0] return self._defaultReport registerType(ProjectViewModelsManager)
if RESPONSE is None: RESPONSE = REQUEST.RESPONSE field = self.getPrimaryField() accessor = field.getAccessor(self) data = accessor() if not isinstance(data, Image): return '' return data.index_html(REQUEST, RESPONSE) security.declareProtected(CCP.View, 'tag') def tag(self, **kwargs): """Use proxy title for img tags: title and alt""" # Scale image patool = getToolByName(self, PLONEARTICLE_TOOL) return patool.getThumbnailTag(self, 'image', **kwargs) def setAttachedImage(self, value, **kwargs): """ Rename proxy according to file name """ field = self.getField('attachedImage') field.set(self, value, **kwargs) self.renameFromFileName(field) registerType(ImageInnerContentProxy)
portal_membership.deleteMembers([ login, ]) if password is None: password = '******' newmember = self.addMember(login, password, properties=properties) newmember.setPasswordDigested(password) return out.getvalue() def test_createUsers(self): """ Create some users to make testing easier """ out = StringIO.StringIO() for login in ('author1', 'author2', 'author3', 'ebmember1', 'ebmember2', 'ebmember3'): properties = { 'username': login, 'fullname': "John %s" % login, 'email': "*****@*****.**" % login } print >> out, "%s|%s|%s|%s" % (login, properties['fullname'], properties['email'], password) newmember = self.addMember(login, '12345', properties=properties) return out.getvalue() atapi.registerType(gcUserContainer, PROJECTNAME) InitializeClass(gcUserContainer)
archetype_name = 'UserImage' immediate_view = 'userimage_view' default_view = 'userimage_view' suppl_views = () typeDescription= 'An user addable image type.' typeDescMsgId = 'userimage_description' assocMimetypes = () assocFileExt = () cmf_edit_kws = () global_allow = True filter_content_types = False allow_discussion = False allowed_content_types = () _at_rename_after_creation = True __implements__ = (ATImage.__implements__, INonStructuralFolder, ) security = ClassSecurityInfo() def canSetDefaultPage(self): """Can this content set default page for folder?""" return False registerType(UserImage, PROJECTNAME)
# we don't need descrpiton field for a memo. XPointMemoSchema['description'].widget.visible = False # XPointMemo class. class XPointMemo(XPointDocument): """ XPointMemo defines the note for a XPoint Project. """ schema = XPointMemoSchema # type, name. meta_type = 'XPointMemo' portal_type = 'XPointMemo' archetype_name = 'XP Memo' _at_rename_after_creation = True security = ClassSecurityInfo() def modify_fti(fti): # Hide unnecessary tabs (usability enhancement) for a in fti['actions']: if a['id'] in ['metadata']: a['visible'] = 0 return fti # register this type to plone add-on product. registerType(XPointMemo, PROJECTNAME)
def getCategories(self): value = [] board = self.getBoard() if board is not None and hasattr(board, 'getCategories'): categories = board.getCategories() if categories is not None: value = [(c,c) for c in categories] value.sort() return DisplayList(value) security.declareProtected(ViewBoard, 'getAttachmentSizes') def getAttachmentSizes(self): voc = DisplayList() voc.add('10', '10 kilobyte') voc.add('100', '100 kilobyte') voc.add('1000', '1 megabyte') voc.add('10000', '10 megabyte') voc.add('-1', 'unlimited') return voc ############################################################################ # Folder methods, indexes and such def __nonzero__(self): return 1 registerType(PloneboardForum, PROJECTNAME)
# Copyright 2018-2020 by it's authors. # Some rights reserved, see README and LICENSE. from AccessControl import ClassSecurityInfo from Products.Archetypes.public import BaseContent from Products.Archetypes.public import registerType from bika.lims.content.bikaschema import BikaSchema from bika.lims.config import PROJECTNAME from bika.lims.interfaces import IDeactivable from zope.interface import implements schema = BikaSchema.copy() schema['description'].widget.visible = False schema['description'].schemata = 'default' class BatchLabel(BaseContent): implements(IDeactivable) security = ClassSecurityInfo() displayContentsTab = False schema = schema _at_rename_after_creation = True def _renameAfterCreation(self, check_auto_id=False): from bika.lims.idserver import renameAfterCreation renameAfterCreation(self) registerType(BatchLabel, PROJECTNAME)
finalizeATCTSchema(PSCWorklogSchema) # set the title to read only. #PSCWorklogSchema['title'].mode = 'r' class PSCWorklog(ATCTContent): """ the ATContentType for a work log, we should never edit it. """ schema = PSCWorklogSchema meta_type = 'PSCWorklog' portal_type = 'PSCWorklog' archetype_name = 'PSCWorklog' _at_rename_after_creation = True __implements__ = ( ATCTContent.__implements__, IATDocument, ) log = logging.getLogger("PloneShellConsole PSCWorklog") security = ClassSecurityInfo() registerType(PSCWorklog, PROJECTNAME) # End of class PSCWorklog
:param service: the service to be removed from this AR Template :type service: AnalysisService :return: True if the AnalysisService has been removed successfully """ uid = api.get_uid(service) # Remove the service from the referenced services services = self.getAnalyses() num_services = len(services) services = [ item for item in services if item.get("service_uid", "") != uid ] removed = len(services) < num_services self.setAnalyses(services) # Remove the service from the settings map settings = self.getAnalysisServicesSettings() settings = [item for item in settings if item.get('uid', '') != uid] self.setAnalysisServicesSettings(settings) return removed def getSamplingRequiredDefaultValue(self): """Returns the default value for field SamplingRequired, that is the value for setting SamplingWorkflowEnabled from setup """ return self.bika_setup.getSamplingWorkflowEnabled() registerType(ARTemplate, PROJECTNAME)
catalog = getToolByName(self, TOOLNAME) results = catalog( object_implements=(user_ifaces.IMembraneUserAuth.__identifier__)) value = [] for r in results: key = r.getUserName is not None and r.getUserName.strip() \ or r.getUserId value.append((key.lower(), (r.UID, key))) value.sort() value = [r for throwaway, r in value] value.insert(0, ('', '<no reference>')) return DisplayList(value) registerType(TestGroup, PROJECTNAME) user = BaseSchema + Schema(( StringField( 'userName', languageIndependent=1, ), StringField( 'password', languageIndependent=1, ), StringField('title', languageIndependent=1, user_property='fullname', accessor='Title'), StringField(
pu = getToolByName(self, 'plone_utils') # A service cannot be activated if it's calculation is inactive calc = self.getCalculation() if calc and \ workflow.getInfoFor(calc, "inactive_state") == "inactive": message = _("This Analysis Service cannot be activated " "because it's calculation is inactive.") pu.addPortalMessage(message, 'error') transaction.get().abort() raise WorkflowException def workflow_scipt_deactivate(self): bsc = getToolByName(self, 'bika_setup_catalog') pu = getToolByName(self, 'plone_utils') # A service cannot be deactivated if "active" calculations list it # as a dependency. active_calcs = bsc(portal_type='Calculation', inactive_state="active") calculations = (c.getObject() for c in active_calcs) for calc in calculations: deps = [dep.UID() for dep in calc.getDependentServices()] if self.UID() in deps: message = _("This Analysis Service cannot be deactivated " "because one or more active calculations list " "it as a dependency") pu.addPortalMessage(message, 'error') transaction.get().abort() raise WorkflowException registerType(AnalysisService, PROJECTNAME)
for st in added: st.setSamplePoints(list(st.getSamplePoints()) + [ self, ]) return ret def getSampleTypes(self, **kw): return self.Schema()['SampleTypes'].get(self) def getClientUID(self): return self.aq_parent.UID() registerType(SamplePoint, PROJECTNAME) @deprecated( "bika.lims.content.samplepoint.SamplePoints function will be removed in senaite.core 1.2.0" ) def SamplePoints(self, instance=None, allow_blank=True, lab_only=True): instance = instance or self bsc = getToolByName(instance, 'bika_setup_catalog') items = [] contentFilter = { 'portal_type': 'SamplePoint', 'is_active': True, 'sort_on': 'sortable_title' } if lab_only:
security.declareProtected(View, 'imagetag') def imagetag(self, **kwargs): """Generate image tag using the api of the ImageField this method is needed because one must not access ImageField.tag in pagetemplates """ if 'title' not in kwargs: kwargs['title'] = self.Title() return self.getField('image').tag(self, **kwargs) # uncommant lines below when you need factory_type_information = { 'allowed_content_types': [], 'global_allow': 0, 'content_icon': 'NewsletterReference.gif', 'immediate_view': 'newsletterreference_view', 'filter_content_types': 0 } actions = ({ 'id': 'view', 'name': 'View', 'category': 'object', 'action': 'string:${object_url}/NewsletterRichReference_view', 'permissions': ('View',) },) registerType(NewsletterRichReference, PROJECTNAME)
from Products.ATContentTypes.content.link import ATLink from Products.Archetypes.public import registerType class LinkAttachment(ATLink): """A link attachment""" portal_type = meta_type = 'LinkAttachment' registerType(LinkAttachment)
from AccessControl import ClassSecurityInfo from Products.Archetypes.public import registerType from bhp.lims.config import PRODUCT_NAME from bhp.lims.interfaces import ICourier from bika.lims.content.person import Person from zope.interface import implements schema = Person.schema.copy() # Don't make title required - it will be computed from the Person's Fullname schema['title'].required = 0 schema['title'].widget.visible = False class ClientCourier(Person): """Defines a Courier for a particular Client for Shipment """ implements(ICourier) security = ClassSecurityInfo() displayContentsTab = False schema = schema _at_rename_after_creation = True def _renameAfterCreation(self, check_auto_id=False): from bika.lims.idserver import renameAfterCreation renameAfterCreation(self) registerType(ClientCourier, PRODUCT_NAME)
{'id': 'view', 'title': 'View', 'action': 'feature_view', 'permissions': (CMFCorePermissions.View,) }, {'id': 'edit', 'title': 'Edit', 'action': 'base_edit', 'permissions': (CMFCorePermissions.ModifyPortalContent,) }, {'id': 'metadata', 'title': 'Properties', 'action': 'base_metadata', 'permissions': (CMFCorePermissions.ModifyPortalContent,) }, {'id': 'references', 'title': 'References', 'action': 'reference_edit', 'permissions': (CMFCorePermissions.ModifyPortalContent,) }, ) security.declareProtected(CMFCorePermissions.View, 'CookedBody') def CookedBody(self, stx_level='ignored'): """CMF compatibility method """ return self.getText() registerType(FeatureArticle)
catalog = getToolByName(self, TOOLNAME) results = catalog( object_implements=( user_ifaces.IMembraneUserAuth.__identifier__)) value = [] for r in results: key = r.getUserName is not None and r.getUserName.strip() \ or r.getUserId value.append((key.lower(), (r.UID, key))) value.sort() value = [r for throwaway, r in value] value.insert(0, ('', '<no reference>')) return DisplayList(value) registerType(TestGroup, PROJECTNAME) user = BaseSchema + Schema(( StringField('userName', languageIndependent=1,), StringField('password', languageIndependent=1,), StringField('title', languageIndependent=1, user_property='fullname', accessor='Title'), StringField('mobilePhone', languageIndependent=1, user_property=True,), StringField('homePhone',
usr = mt.unrestrictedSearchResults for m in usr( object_implements=( user_ifaces.IMembraneUserAuthAvail.__identifier__), path='/'.join(self.getPhysicalPath())): members[m.getUserId] = 1 return tuple(members.keys()) def listUsers(self): """ Return a DisplayList of users """ catalog = getToolByName(self, TOOLNAME) results = catalog(object_implements=( user_ifaces.IMembraneUserAuthAvail.__identifier__)) value = [] for r in results: key = r.getUserName is not None and \ r.getUserName.strip() or r.getUserId value.append((key.lower(), (r.UID, key))) value.sort() value = [r for throwaway, r in value] value.insert(0, ('', '<no reference>')) return DisplayList(value) getRoleSet = getFilteredValidRolesForPortal registerType(SimpleGroup, PROJECTNAME)
"Status for this issue." # the class. class XPointIssue(XPointDocument): """ XPointIssue records a issue for a XPoint Project. """ schema = XPointIssueSchema # type and name meta_type = 'XPointIssue' portal_type = 'XPointIssue' archetype_name = "XP Issue" _at_rename_after_creation = True security = ClassSecurityInfo() def vocabulary_documentStatus(self): """ return a list of tuple (status, status desc) for the document status select. """ return DisplayList([('open', 'Open'), ('pending', 'Pending'), ('close', 'Close'), ] ) # register this type to plone add-on product. registerType(XPointIssue, PROJECTNAME)
def delete(self): """Delete this comment and make sure all comment replies to this comment are also cleaned up. """ parent_comment = self.inReplyTo() for reply in self.getReplies(): reply.setInReplyTo(parent_comment) reply.reindexObject() conversation = self.getConversation() conversation._delObject(self.getId()) conversation.reindexObject() def __nonzero__(self): return 1 def __str__(self): return "<PloneboardComment: title=%r;>" % self.Title() __repr__ = __str__ security.declareProtected(DeleteComment, "object_delete") def object_delete(self): """Delete the comment the 'proper' way. """ return self.restrictedTraverse('@@delete_view')() registerType(PloneboardComment, PROJECTNAME)
suppl_views = () security = ClassSecurityInfo() security.declareObjectProtected(View) implements(IATBTreeFolder) aliases = updateAliases(base_aliases, { 'view': 'cbcommentfolder_view', }) def canSetDefaultPage(self): return False registerType(COREBlogCommentFolder, PROJECTNAME) class COREBlogCategoryFolder(ATFolder): """ This is a COREBlogCategoryFolder class """ archetype_name = "COREBlog Category Folder" meta_type = 'COREBlogCategoryFolder' exclude_from_nav = True suppl_views = () security = ClassSecurityInfo() security.declareObjectProtected(View)
from Products.ATContentTypes.content.schemata import ATContentTypeBaseSchema from iw.fss.FileSystemStorage import FileSystemStorage from collective.flowplayerstreaming import config from collective.flowplayerstreaming.interfaces import IVideo VideoSchema = ATContentTypeBaseSchema.copy() + atapi.Schema(( atapi.FileField('video_file', storage=FileSystemStorage(), widget=atapi.FileWidget( label = 'Video', ) ), )) class Video(ATCTContent): """ Video content type """ implements(IVideo) portal_type = 'Video' schema = VideoSchema _at_rename_after_creation = True atapi.registerType(Video, config.PROJECTNAME)
IGroupAwareRolesProvider, IUserRoles ) class SimpleMember(BaseContent): """A simple member archetype""" schema = SimpleSchema _at_rename_after_creation = True security = ClassSecurityInfo() getRoleSet = getFilteredValidRolesForPortal # # IUserAuthentication implementation # 'getUserName' is auto-generated # def verifyCredentials(self, credentials): login = credentials.get('login') password = credentials.get('password') if login == self.getUserName() and password == self.getPassword(): return True else: return False # # IUserRoles implementation # 'getRoles' is autogenerated registerType(SimpleMember, PROJECTNAME)
lc.complete(activity.title_or_id()) security.declareProtected(config.WORK_WITH_PROCESS, 'getStatusInfo') def getStatusInfo(self): """Return current status of workitem as a text.""" controller = gocept.alphaflow.interfaces.ILifeCycleController(self) if controller.state == 'active': return "deadline not yet reached" elif controller.state == 'ended': return "deadline exceeded" return "Error Status" InitializeClass(AlarmWorkItem) registerType(AlarmWorkItem, config.PROJECTNAME) @zope.component.adapter(gocept.alphaflow.interfaces.ICronPing) def receive_cron_ping(event): wc = Products.CMFCore.utils.getToolByName(event.process_manager, "workflow_catalog") workitems = wc(activity_type="alarm", state="active") workitems = [x.getObject() for x in workitems] workitems = [x for x in workitems if x is not None] for item in workitems: try: item.trigger_workitem() except Exception, m:
activity_type = "switch" security.declarePrivate('onStart') def onStart(self): "Trigger that gets called after the workitem has been started." super(SwitchWorkItem, self).onStart() activity = self.getActivity() first = activity.mode == "first" for case in activity.getExits(): try: case_result = utils.evaluateTales(case.condition, workitem=self) except Exception, m: ILifeCycleController(self).fail( "Evaluating condition on case %s of activity %s raised an " " exception." % (case.id, activity.title_or_id()), m) return if case_result: self.passCheckpoint(case.id) if first: break ILifeCycleController(self).complete(activity.title_or_id()) InitializeClass(SwitchWorkItem) registerType(SwitchWorkItem, config.PROJECTNAME)
if not request: return [] siblings = [] retracted_states = [STATE_RETRACTED, STATE_REJECTED] ans = request.getAnalyses(full_objects=True) for sibling in ans: if sibling.UID() == self.UID(): # Exclude me from the list continue if retracted is False and in_state(sibling, retracted_states): # Exclude retracted analyses continue siblings.append(sibling) return siblings def workflow_script_publish(self): """ If this is not here, acquisition causes recursion into AR workflow_script_publish method and, if there are enough analyses, it will result in "RuntimeError: maximum recursion depth exceeded" """ pass registerType(Analysis, PROJECTNAME)
def getPrintAddress(self): """Get an address for printing """ address_lines = [] addresses = [ self.getPostalAddress(), self.getPhysicalAddress(), self.getBillingAddress(), ] for address in addresses: city = address.get("city", "") zip = address.get("zip", "") state = address.get("state", "") country = address.get("country", "") if city: address_lines = [ address["address"].strip(), "{} {}".format(city, zip).strip(), "{} {}".format(state, country).strip(), ] break return address_lines registerType(Organisation, PROJECTNAME)
schema["JobTitle"].schemata = "default" schema["Department"].schemata = "default" schema["id"].schemata = "default" schema["id"].widget.visible = False # Don"t make title required - it will be computed from the Person"s # Fullname schema["title"].schemata = "default" schema["title"].required = 0 schema["title"].widget.visible = False class SupplierContact(Person): """Supplier Contact content """ implements(IDeactivable) _at_rename_after_creation = True displayContentsTab = False isPrincipiaFolderish = 0 schema = schema security = ClassSecurityInfo() def _renameAfterCreation(self, check_auto_id=False): from bika.lims.idserver import renameAfterCreation renameAfterCreation(self) registerType(SupplierContact, PROJECTNAME)
try: svs = self.getPing_servers().split('\n') except: svs = self.getPing_servers() indexlist = range(0,len(svs)) if idx != -1: indexlist = [index] rl = [] for i in indexlist: if svs[i].find('http:') == 0: r = cbtool.sendPing(svs[i],self.title,blogurl, __product_version__) rl.append(r) return rl # # Misc methods # security.declareProtected(View, 'getEntryFieldOrder') def getEntryFieldOrder(self): # #Returns edit field order for entry # return ['id','title','subtitle','entry_categories','body','extend', 'allow_comment','receive_trackback','relatedItems', 'media_position','media_size'] registerType(COREBlog2,PROJECTNAME)
result = analysis.getResult() if not api.is_floatable(result): return specs specs.min = specs.max = result result = api.to_float(result) dup_variation = analysis.getDuplicateVariation() dup_variation = api.to_float(dup_variation) if not dup_variation: return specs margin = abs(result) * (dup_variation / 100.0) specs.min = str(result - margin) specs.max = str(result + margin) return specs def workflow_script_attach(self): events.after_attach(self) @security.public def workflow_script_retract(self): events.after_retract(self) @security.public def workflow_script_verify(self): events.after_verify(self) registerType(DuplicateAnalysis, PROJECTNAME)
return self.start_date.strftime(self.longDayFormat()) def short_end_date(self): return self.end_date.strftime(self.shortDayFormat()) def long_end_date(self): return self.end_date.strftime(self.longDayFormat()) def start_hour(self): return self.start_date.strftime(self.hourFormat()) def end_hour(self): return self.end_date.strftime(self.hourFormat()) def getDefaultMessageToRegistrant(self): return '\n'.join(getPropSheet(self).message_to_registrant) def getDefaultRegistryContact(self): return getPropSheet(self).default_registry_contact security = ClassSecurityInfo() security.declareProtected(CMFCorePermissions.View, 'getEventTypes') def getEventTypes(self): """fetch a list of the available event types from the vocabulary """ return self.portal_catalog.uniqueValuesFor('Subject') schema = RegisterableEventSchema registerType(RegisterableEvent, config.PROJECTNAME)
zope.interface.classProvides(IActivityClass) meta_type = "AlphaFlow Termination Activity" activity_type = "termination" icon = "misc_/AlphaFlow/expression" #XXX InitializeClass(TerminationActivity) class TerminationWorkItem(BaseAutomaticWorkItem): zope.interface.implements(ITerminationWorkItem) zope.interface.classProvides(IWorkItemClass) activity_type = "termination" def run(self): """Performs the actual automatic activity""" instance = self.getInstance() workitems = instance.getWorkItems() for wi in workitems: if wi is self: continue ILifeCycleController(wi).terminate( "Terminated by %s." % self.getActivity().title_or_id()) InitializeClass(TerminationWorkItem) registerType(TerminationWorkItem, config.PROJECTNAME)
tags = self.listTags() newEntries = [v for v in value if not v in tags] if not newEntries: return newTagsList = list(tags)+ list(newEntries) parent = self.aq_parent portal = self.portal_url.getPortalObject() while parent != portal: if parent.portal_type == 'Blog': break parent = parent.aq_parent parent.setTags(newTagsList, **kwargs) def listTags(self): """ Get the list of Tags from parent Blog """ tags = [] parent = self.aq_parent portal = self.portal_url.getPortalObject() while parent != portal: if parent.portal_type == 'Blog': tags = parent.getTags() break parent = parent.aq_parent return tuple(tags) def getBody(self): return self.getField('body').get(self) registerType(BlogEntry)
from AccessControl import ClassSecurityInfo from Products.Archetypes.public import BaseContent from Products.Archetypes.public import registerType from bika.lims.content.bikaschema import BikaSchema from bika.health.config import PROJECTNAME schema = BikaSchema.copy() schema['description'].widget.visible = True schema['description'].schemata = 'default' class CaseStatus(BaseContent): security = ClassSecurityInfo() displayContentsTab = False schema = schema _at_rename_after_creation = True def _renameAfterCreation(self, check_auto_id=False): from bika.lims.idserver import renameAfterCreation renameAfterCreation(self) registerType(CaseStatus, PROJECTNAME)
from Products.Archetypes.public import StringField from Products.Archetypes.public import BaseContent, registerType from Products.CMFCore import CMFCorePermissions #from Products.ATCountryWidget.config import PROJECTNAME from Products.ATCountryWidget.Widget import CountryWidget schema = BaseSchema + Schema (( StringField( 'country', required=1, widget=CountryWidget(label='Country', description='Select a country.') ), )) class TestCountryWidget(BaseContent): """blah """ schema = schema archetypes_name = portal_type = meta_type='TestCountryWidget' registerType(TestCountryWidget)
item['Description'] = obj.Description() item["replace"]["Title"] = get_link(url, value=title) # Icons after_icons = "" if obj.getBlank(): after_icons += get_image("blank.png", title=t(_("Blank"))) if obj.getHazardous(): after_icons += get_image("hazardous.png", title=t(_("Hazardous"))) if after_icons: item["after"]["Title"] = after_icons return item schema = ATFolderSchema.copy() class ReferenceDefinitions(ATFolder): """Reference definition content """ implements(IReferenceDefinitions) displayContentsTab = False schema = schema schemata.finalizeATCTSchema(schema, folderish=True, moveDiscussion=False) registerType(ReferenceDefinitions, PROJECTNAME)
RESPONSE = REQUEST.RESPONSE field = self.getPrimaryField() accessor = field.getAccessor(self) data = accessor() #if not isinstance(data, File): # return '' mime_type = data.getContentType() if mime_type.startswith('text/'): return data if mime_type in INLINE_MIME_TYPES: content_dispo = 'inline' else: content_dispo = 'attachment' RESPONSE.setHeader( 'Content-Disposition', '%s; filename="%s"' % (content_dispo, data.filename or self.getId())) return data.index_html(REQUEST, RESPONSE) def setAttachedFile(self, value, **kwargs): """ Rename proxy according to file name """ field = self.getField('attachedFile') field.set(self, value, **kwargs) self.renameFromFileName(field) registerType(FileInnerContentProxy, PROJECTNAME)
# this program; if not, write to the Free Software Foundation, Inc., 51 # Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. # # Copyright 2018-2019 by it's authors. # Some rights reserved, see README and LICENSE. from bika.lims.config import PROJECTNAME from bika.lims.interfaces import IHaveNoBreadCrumbs from bika.lims.interfaces import IMethods from plone.app.folder.folder import ATFolder from plone.app.folder.folder import ATFolderSchema from Products.Archetypes.public import registerType from Products.ATContentTypes.content import schemata from zope.interface.declarations import implements schema = ATFolderSchema.copy() class Methods(ATFolder): """Root folder for Reference Samples """ implements(IMethods, IHaveNoBreadCrumbs) displayContentsTab = False schema = schema schemata.finalizeATCTSchema(schema, folderish=True, moveDiscussion=False) registerType(Methods, PROJECTNAME)
}, { 'id': 'edit', 'title': 'Edit', 'action': 'base_edit', 'permissions': (CMFCorePermissions.ModifyPortalContent, ) }, { 'id': 'metadata', 'title': 'Properties', 'action': 'base_metadata', 'permissions': (CMFCorePermissions.ModifyPortalContent, ) }, { 'id': 'references', 'title': 'References', 'action': 'reference_edit', 'permissions': (CMFCorePermissions.ModifyPortalContent, ) }, ) security.declareProtected(CMFCorePermissions.View, 'CookedBody') def CookedBody(self, stx_level='ignored'): """CMF compatibility method """ return self.getText() registerType(UserFeedback)
from Products.Faq import config from Products.Faq import faqMessageFactory as _ schema = ATFolderSchema.copy() + Schema(( IntegerField('delay', widget=IntegerWidget(description=_(u"desc_delay", default=u"Delay for a new item."), label=_(u"label_delay", default=u"Delay") ), default=7, required=1, searchable=0, validators=('isInt',)), )) schema['description'].widget.label = _(u"label_folder", default=u"Description") schema['description'].widget.description = _(u"desc_folder", default=u"The description of the FAQ category.") class FaqFolder(ATFolder): """ FAQ Folder """ implements(IFaqFolder) schema = schema registerType(FaqFolder, config.PROJECTNAME)
"""Do the configuration of the other activities.""" if self.state != "active": raise ValueError("Can't configure when not active.") self.passCheckpoint("complete") ILifeCycleController(self).complete(self.getComment()) self.notifyAssigneesChange() self._update_ui_after_action('Configuration complete.', REQUEST) ######### # private security.declarePrivate('_group_schema') def _group_schema(self, schema): groups = {} instance = self.getInstance() for x in schema.fields(): if not hasattr(x, 'group'): continue group = x.group if not groups.has_key(group): groups[group] = [] groups[group].append(x) groups = [Group(instance, *item) for item in groups.items()] groups.sort() return groups InitializeClass(ConfigurationWorkItem) registerType(ConfigurationWorkItem, config.PROJECTNAME)