rem stringlengths 0 322k | add stringlengths 0 2.05M | context stringlengths 8 228k |
|---|---|---|
self._policy = PersistentMapping() | self._policies = PersistentMapping() | def __init__(self): self._mtmap = PersistentMapping() self._policy = PersistentMapping() |
transform = Transform(name, module) | transform = Transform(name, module, transform) | def registerTransform(self, name, transform): """ register a new transform """ __traceback_info__ = (name, transform) if not name in self.objectIds(): # needed when call from transform.transforms.initialize which # register non zope transform module = "%s" % transform.__module__ transform = Transform(name, module) self... |
if l.__name__ == l[i].__name__: | if transform.id == l[i].id: | def _unmapTransform(self, transform): SEQ = (ListType, TupleType) registry = getToolByName(self, 'mimetypes_registry') for i in transform.inputs(): mts = registry.lookup(i) if type(mts) not in SEQ: mts = (mts,) |
def __init__(self, id, module): | def __init__(self, id, module, transform=None): | def __init__(self, id, module): self.id = id self.module = module self._config = PersistentMapping() self._tr_init(1) |
self._tr_init(1) | self._tr_init(1, transform) | def __init__(self, id, module): self.id = id self.module = module self._config = PersistentMapping() self._tr_init(1) |
def _tr_init(self, set_conf=0): | def _tr_init(self, set_conf=0, transform=None): | def _tr_init(self, set_conf=0): """ initialize the zope transform by loading the wrapped transform """ __traceback_info__ = (self.module, ) m = import_from_name(self.module) if not hasattr(m, 'register'): raise TransformException('Unvalid transform module %s: no register function defined' % module) |
m = import_from_name(self.module) if not hasattr(m, 'register'): raise TransformException('Unvalid transform module %s: no register function defined' % module) transform = m.register() | if transform is None: m = import_from_name(self.module) if not hasattr(m, 'register'): msg = 'Unvalid transform module %s: no register function defined' % module raise TransformException(msg) transform = m.register() | def _tr_init(self, set_conf=0): """ initialize the zope transform by loading the wrapped transform """ __traceback_info__ = (self.module, ) m = import_from_name(self.module) if not hasattr(m, 'register'): raise TransformException('Unvalid transform module %s: no register function defined' % module) |
tr_tool._unmapTransform(transform) tr_tool._mapTransform(transform) if REQUEST is not None: REQUEST['RESPONSE'].redirect(tr_tool.absolute_url()+'/manage') | tr_tool._unmapTransform(self) tr_tool._mapTransform(self) if REQUEST is not None: REQUEST['RESPONSE'].redirect(tr_tool.absolute_url()+'/manage_main') | def set_parameters(self, REQUEST=None, **kwargs): """ set transform's parameters """ if not kwargs: kwargs = REQUEST.form |
security.declareProtected(CMFCorePermissions.View, 'isDiscussable') | security.declareProtected(permissions.View, 'isDiscussable') | def defaultLanguage(self): """Retrieve the default language""" # XXX This method is kept around for backward compatibility only return config.LANGUAGE_DEFAULT |
security.declareProtected(CMFCorePermissions.View, 'editIsDiscussable') | security.declareProtected(permissions.View, 'editIsDiscussable') | def isDiscussable(self, encoding=None): dtool = getToolByName(self, 'portal_discussion') return dtool.isDiscussionAllowedFor(self) |
security.declareProtected(CMFCorePermissions.ModifyPortalContent, | security.declareProtected(permissions.ModifyPortalContent, | def editIsDiscussable(self, encoding=None): # XXX this method highly depends on the current implementation # it's a quick hacky fix result = getattr(aq_base(self), 'allow_discussion', None) if result is not None: try: # deal with booleans result = int(result) except (TypeError, ValueError): pass return str(result) |
log(msg, level=BLATHER) | log(msg, level=DEBUG) | def allowDiscussion(self, allowDiscussion=None, **kw): if allowDiscussion is not None: try: allowDiscussion = int(allowDiscussion) except (TypeError, ValueError): allowDiscussion = allowDiscussion.lower().strip() d = {'on' : 1, 'off': 0, 'none':None, '':None, 'None':None} allowDiscussion = d.get(allowDiscussion, None) ... |
log_exc('Catched Unauthorized on discussiontool.' \ 'overrideDiscussionFor(%s)' % self.absolute_url(1), level=BLATHER) | log('Catched Unauthorized on discussiontool.' \ 'overrideDiscussionFor(%s)' % self.absolute_url(1), level=DEBUG) | def allowDiscussion(self, allowDiscussion=None, **kw): if allowDiscussion is not None: try: allowDiscussion = int(allowDiscussion) except (TypeError, ValueError): allowDiscussion = allowDiscussion.lower().strip() d = {'on' : 1, 'off': 0, 'none':None, '':None, 'None':None} allowDiscussion = d.get(allowDiscussion, None) ... |
security.declareProtected(CMFCorePermissions.View, 'languages') | security.declareProtected(permissions.View, 'languages') | def allowDiscussion(self, allowDiscussion=None, **kw): if allowDiscussion is not None: try: allowDiscussion = int(allowDiscussion) except (TypeError, ValueError): allowDiscussion = allowDiscussion.lower().strip() d = {'on' : 1, 'off': 0, 'none':None, '':None, 'None':None} allowDiscussion = d.get(allowDiscussion, None) ... |
security.declareProtected(CMFCorePermissions.View, 'CreationDate') | security.declareProtected(permissions.View, 'CreationDate') | def languages(self): """Vocabulary method for the language field """ # XXX document me # use a list of languages from PLT? available_langs = getattr(self, 'availableLanguages', None) if available_langs is None: return DisplayList( (('en','English'), ('fr','French'), ('es','Spanish'), ('pt','Portuguese'), ('ru','Russian... |
security.declarePublic( CMFCorePermissions.View, 'EffectiveDate') | security.declarePublic( permissions.View, 'EffectiveDate') | def CreationDate(self): """ Dublin Core element - date resource created. """ creation = self.getField('creation_date').get(self) # XXX return unknown if never set properly return creation is None and 'Unknown' or creation.ISO() |
security.declarePublic(CMFCorePermissions.View, 'effective_date') | security.declarePublic(permissions.View, 'effective_date') | def _effective_date(self): """Computed attribute accessor """ return self.getField('effectiveDate').get(self) |
security.declarePublic( CMFCorePermissions.View, 'ExpirationDate') | security.declarePublic( permissions.View, 'ExpirationDate') | def _effective_date(self): """Computed attribute accessor """ return self.getField('effectiveDate').get(self) |
security.declarePublic(CMFCorePermissions.View, 'expiration_date') | security.declarePublic(permissions.View, 'expiration_date') | def _expiration_date(self): """Computed attribute accessor """ return self.getField('expirationDate').get(self) |
security.declareProtected(CMFCorePermissions.View, 'Date') | security.declareProtected(permissions.View, 'Date') | def _expiration_date(self): """Computed attribute accessor """ return self.getField('expirationDate').get(self) |
security.declareProtected(CMFCorePermissions.View, 'Format') | security.declareProtected(permissions.View, 'Format') | def Date(self): """ Dublin Core element - default date """ # Return effective_date if specifically set, modification date # otherwise effective = self.getField('effectiveDate').get(self) if effective is None: effective = self.modified() return effective is None and DateTime() or effective.ISO() |
security.declareProtected(CMFCorePermissions.ModifyPortalContent, | security.declareProtected(permissions.ModifyPortalContent, | def Format(self): """cmf/backward compat Dublin Core element - resource format """ # FIXME: get content type from marshaller return self.getContentType() |
security.declareProtected(CMFCorePermissions.View, 'contentEffective') | security.declareProtected(permissions.View, 'contentEffective') | def Identifer(self): """ dublin core getId method""" return self.getId() |
security.declareProtected(CMFCorePermissions.View, 'contentExpired') | security.declareProtected(permissions.View, 'contentExpired') | 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... |
security.declareProtected(CMFCorePermissions.View, 'created') | security.declareProtected(permissions.View, 'created') | def contentExpired(self, date=None): """ Is the date after resource's expiration """ if not date: # XXX we need some unittesting for this date = DateTime() expires = self.getField('expirationDate').get(self) if not expires: expires = CEILING_DATE return expires <= date |
security.declareProtected(CMFCorePermissions.View, 'modified') | security.declareProtected(permissions.View, 'modified') | 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(CMFCorePermissions.View, 'effective') | security.declareProtected(permissions.View, 'effective') | def modified(self): """Dublin Core element - date resource last modified, returned as DateTime. """ modified = self.getField('modification_date').get(self) # XXX may return None return modified |
security.declareProtected(CMFCorePermissions.View, 'expires') | security.declareProtected(permissions.View, 'expires') | 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(CMFCorePermissions.ModifyPortalContent, | security.declareProtected(permissions.ModifyPortalContent, | 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 |
security.declareProtected(CMFCorePermissions.ManagePortal, | security.declareProtected(permissions.ManagePortal, | def notifyModified(self): """ Take appropriate action after the resource has been modified. For now, change the modification_date. """ # XXX This could also store the id of the user doing modifications. self.setModificationDate(DateTime()) if shasattr(self, 'http__refreshEtag'): self.http__refreshEtag() |
security.declareProtected(CMFCorePermissions.ManagePortal, | security.declareProtected(permissions.ManagePortal, | 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, modifie... |
security.declareProtected(CMFCorePermissions.View, 'Publisher') | security.declareProtected(permissions.View, 'Publisher') | 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 |
security.declareProtected(CMFCorePermissions.View, 'ModificationDate') | security.declareProtected(permissions.View, 'ModificationDate') | def Publisher(self): """Dublin Core element - resource publisher """ # XXX: fixme using 'portal_metadata' return 'No publisher' |
security.declareProtected(CMFCorePermissions.View, 'Type') | security.declareProtected(permissions.View, 'Type') | def ModificationDate(self): """ Dublin Core element - date resource last modified. """ modified = self.modified() return modified is None and DateTime() or modified.ISO() |
security.declareProtected(CMFCorePermissions.View, 'Identifier') | security.declareProtected(permissions.View, 'Identifier') | 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(CMFCorePermissions.View, 'listContributors') | security.declareProtected(permissions.View, 'listContributors') | 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(CMFCorePermissions.ModifyPortalContent, | security.declareProtected(permissions.ModifyPortalContent, | def listContributors(self): """Dublin Core element - Contributors""" return self.Contributors() |
if creator and not creator in self.listCreators(): self.setCreators(self.creators + (creator, )) security.declareProtected(CMFCorePermissions.View, 'listCreators') | curr_creators = self.listCreators() if creator and not creator in curr_creators: self.setCreators(curr_creators + (creator, )) security.declareProtected(permissions.View, 'listCreators') | def addCreator(self, creator=None): """ Add creator to Dublin Core creators. """ if creator is None: mtool = getToolByName(self, 'portal_membership') creator = mtool.getAuthenticatedMember().getId() |
security.declareProtected(CMFCorePermissions.View, 'Creator') | security.declareProtected(permissions.View, 'Creator') | 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_id = self.getOwnerTuple()[1] if owner_id: creators.set(self, (owner_id,)) else: creators.set(self, ()) |
security.declareProtected(CMFCorePermissions.View, 'content_type') | security.declareProtected(permissions.View, 'content_type') | def Creator(self): """ Dublin Core Creator element - resource author. """ creators = self.listCreators() return creators and creators[0] or '' |
security.declareProtected(CMFCorePermissions.View, 'getMetadataHeaders') | security.declareProtected(permissions.View, 'getMetadataHeaders') | def content_type(self): """ WebDAV needs this to do the Right Thing (TM). """ return self.Format() |
security.declareProtected(CMFCorePermissions.ModifyPortalContent, | security.declareProtected(permissions.ModifyPortalContent, | 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 subj... |
security.declareProtected(CMFCorePermissions.ModifyPortalContent, | security.declareProtected(permissions.ModifyPortalContent, | 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 ) REQ... |
attrib = None elif not isinstance( attrib, DateTime ) and attrib is not None: | attrib = '' elif not isinstance( attrib, DateTime ): | def _datify( self, attrib ): """FIXME: overriden from DublinCore to deal with blank value...""" if attrib == 'None' or not attrib: attrib = None elif not isinstance( attrib, DateTime ) and attrib is not None: attrib = DateTime( attrib ) return attrib |
instance = instance.portal_type | fti = instance.getTypeInfo() instance = getattr(self.getTypeInfo(), 'portal_type', None) | def lookupTemplates(self, instance=None): """Lookup templates by giving an instance or a portal_type. |
keys.insert(pos, name) | if oldpos >= pos: keys.insert(pos, name) else: keys.insert(pos - 1, name) | def _moveFieldToPosition(self, name, pos): """Moves a field with the name 'name' to the position 'pos' |
args = (default,) kw = {} if hasattr(field, 'default_content_type'): m = mutator if hasattr(m,'im_func'): m = m.im_func code = m.func_code callargs = code.co_argcount fn_args = code.co_varnames[:callargs] if 'mimetype' in fn_args: kw['mimetype'] = field.default_content_type mutator(*args, **kw) | mutator(default) | def setDefaults(self, instance): """Only call during object initialization. Sets fields to schema defaults """ ## XXX think about layout/vs dyn defaults for field in self.values(): if field.getName().lower() != 'id': # always set defaults on writable fields mutator = field.getMutator(instance) if mutator is None: conti... |
method = field.getMutator(instance) | method = getattr(instance, field.mutator, None) | def updateAll(self, instance, **kwargs): """This method mutates fields in the given instance. |
from Archetypes.examples import ComplexType from Archetypes.ClassGen import generateCtor | from Products.Archetypes.examples import ComplexType from Products.Archetypes.ClassGen import generateCtor | def test_addComplexTypeCtor(self): from Archetypes.examples import ComplexType from Archetypes.ClassGen import generateCtor addComplexType = generateCtor('ComplexType', ComplexType) site = self.getPortal() id = addComplexType(site, id='complex_type', textfield='Bla', integerfield=1, stringfield='A String') obj = getatt... |
if len(sample) != 2: | if sample and len(sample[0]) != 2: | def Vocabulary(self, content_instance=None): """ returns a DisplayList |
value, format = self.scale(data,w,h) | fvalue, format = self.scale(data,w,h) value = fvalue.read() | def rescaleOriginal(self, value, **kwargs): """rescales the original image and sets the data |
for value in values: error = 1 | for val in values: error = 1 | def validate(self, instance, REQUEST=None, errors=None, data=None, metadata=None): """Validate the state of the entire object""" fieldset = REQUEST.form.get('fieldset', None) fields = [] |
if value == valid or str(value) == str(valid): | if val == valid or str(val) == str(valid): | def validate(self, instance, REQUEST=None, errors=None, data=None, metadata=None): """Validate the state of the entire object""" fieldset = REQUEST.form.get('fieldset', None) fields = [] |
"of element: %s" %(value, capitalize(name)) | "of element: %s" %(val, capitalize(name)) | def validate(self, instance, REQUEST=None, errors=None, data=None, metadata=None): """Validate the state of the entire object""" fieldset = REQUEST.form.get('fieldset', None) fields = [] |
self.failUnless(v('abcd')) self.failUnless(v('a_123456')) self.failIf(v('123')) self.failIf(v('ab.c')) self.failIf(v('ab,c')) self.failIf(v('aaaaaaaab')) | self.failUnlessEqual(v('abcd'), 1) self.failUnlessEqual(v('a_123456'), 1) self.failIfEqual(v('123'), 1) self.failIfEqual(v('ab.c'), 1) self.failIfEqual(v('ab,c'),1 ) self.failIfEqual(v('aaaaaaaab'), 1) | def test_isUnixLikeName(self): v = validationService.validatorFor('isUnixLikeName') self.failUnless(v('abcd')) self.failUnless(v('a_123456')) self.failIf(v('123')) self.failIf(v('ab.c')) self.failIf(v('ab,c')) self.failIf(v('aaaaaaaab')) # too long |
'widht="%(width)s" height="%(height)s"' % values | 'width="%(width)s" height="%(height)s"' % values | def tag(self, instance, scale=None, height=None, width=None, alt=None, css_class=None, title=None, **kwargs): """Create a tag including scale """ image = self.getScale(instance, scale=scale) if image: img_height=image.height img_width=image.width else: img_height=0 img_width=0 |
'visible' : 0, | def getCMFVersion(): from os.path import join from Globals import package_home from Products.CMFCore import cmfcore_globals | |
if hasattr(portal_type,'aliases'): | if hasattr(portal_type,'aliases') and hasattr(typeInfo, 'setMethodAliases'): | def fixActionsForType(portal_type, typesTool): if 'actions' in portal_type.installMode: typeInfo = getattr(typesTool, portal_type.__name__) if hasattr(portal_type,'actions'): # Look for each action we define in portal_type.actions # in typeInfo.action replacing it if its there and # just adding it if not if getattr(por... |
SQLStorageConfig, Folder): | SQLStorageConfig, Folder, ReferenceEngine): | def __call__(self): __traceback_info__ = self._args return renderer.render(**self._args) |
for t in self._types.keys(): if self._types[t]['update']: list.append(t) | keys = self._types.keys() keys.sort() for t in keys: list.append((t, self._types[t]['update'])) | def getChangedSchema(self): """Get a list of schema that have changed""" list = [] for t in self._types.keys(): if self._types[t]['update']: list.append(t) return list |
def manage_updateSchema(self): | def manage_updateSchema(self, REQUEST=None): | def manage_updateSchema(self): """Make sure all objects' schema are up to date""" out = StringIO() print >> out, 'Updating schema...' |
for t in self._types.keys(): if not self._types[t]['update']: continue catalog = getToolByName(self, UID_CATALOG) result = catalog._catalog.searchResults({'meta_type' : t}) classes = {} for r in result: try: o = r.getObject() if hasattr(o, '_updateSchema'): if not o._isSchemaCurrent(): o._updateSchema(out=out) except ... | update_types = [] if REQUEST is None: for t in self._types.keys(): if self._types[t]['update']: update_types.append(t) update_all = 0 else: for t in self._types.keys(): if REQUEST.form.get(t, 0): update_types.append(t) update_all = REQUEST.form.get('update_all', 0) catalog = getToolByName(self, 'portal_catalog') ... | def manage_updateSchema(self): """Make sure all objects' schema are up to date""" out = StringIO() print >> out, 'Updating schema...' |
def lookupObject(self,uid): import warnings warnings.warn('ArchetypeTool.lookupObject is dreprecated',DeprecationWarning) return self.reference_catalog.lookupObject(uid) getObject=lookupObject InitializeClass(ArchetypeTool) | InitializeClass(ArchetypeTool) | def lookupObject(self,uid): import warnings warnings.warn('ArchetypeTool.lookupObject is dreprecated',DeprecationWarning) return self.reference_catalog.lookupObject(uid) |
from Field import StringField | from Products.Archetypes.Field import StringField | def addSchemata(self, name): """Create a new schema by adding a new field with schemata 'name' """ from Field import StringField |
security.declareProtected(CMFCorePermissions.ModifyPortalContent, | security.declareProtected(CMFCorePermissions.DeleteObjects, | def manage_beforeDelete(self, item, container): BaseObject.manage_beforeDelete(self, item, container) CatalogMultiplex.manage_beforeDelete(self, item, container) SkinnedFolder.manage_beforeDelete(self, item, container) |
if not mt.checkPermission(CMFCorePermissions.ModifyPortalContent, item): | if not mt.checkPermission(CMFCorePermissions.DeleteObjects, item): | def manage_delObjects(self, ids=[], REQUEST=None): """ We need to enforce security. """ mt=getToolByName(self, 'portal_membership') if type(ids) is str: ids = [ids] for id in ids: item = self._getOb(id) if not mt.checkPermission(CMFCorePermissions.ModifyPortalContent, item): raise Unauthorized, ( "Do not have permissio... |
key = '/'.join(self.getPhysicalPath()) | key = getRelURL(self, self.getPhysicalPath()) | def addSubObjects(self, objects, REQUEST=None): """add a dictionary of objects to the session """ if objects: if REQUEST is None: REQUEST = self.REQUEST key = '/'.join(self.getPhysicalPath()) session = REQUEST.SESSION defined = session.get(key, {}) defined.update(objects) session[key] = defined |
data = REQUEST.SESSION[self.absolute_url()][name] | data = REQUEST.SESSION[getRelURL(self, self.getPhysicalPath())][name] | def getSubObject(self, name, REQUEST, RESPONSE=None): """Get a dictionary of objects from the session """ try: data = REQUEST.SESSION[self.absolute_url()][name] except AttributeError: return except KeyError: return mtr = self.mimetypes_registry mt = mtr.classify(data, filename=name) return Wrapper(data, name, mt or 'ap... |
portal_path = self.portal_url.getPortalObject().getPhysicalPath() | try: urlTool = aq_parent(self).portal_url except AttributeError: urlTool = self.portal_url portal_path = urlTool.getPortalObject().getPhysicalPath() | def getRelPath(self, ppath): """take something with context (self) and a physical path as a tuple, return the relative path for the portal""" portal_path = self.portal_url.getPortalObject().getPhysicalPath() ppath = ppath[len(portal_path):] return ppath |
if self.vocabulary_display_path_bound and \ len(brains) > self.vocabulary_display_path_bound: | if len(brains) > self.vocabulary_display_path_bound: | def _Vocabulary(self, content_instance): pairs = [] pc = getToolByName(content_instance, 'portal_catalog') uc = getToolByName(content_instance, config.UID_CATALOG) brains = pc.searchResults(portal_type=self.allowed_types) |
if not value: continue | if value is None: continue | def _processForm(self, data=1, metadata=None): request = self.REQUEST form = request.form fieldset = form.get('fieldset', None) schema = self.Schema() schemata = self.Schemata() fields = [] |
'reindex_sanity_plone21.txt', | def test_suite(): from unittest import TestSuite, makeSuite from Testing.ZopeTestCase import FunctionalDocFileSuite as FileSuite suite = TestSuite() suite.addTest(makeSuite(TestFunctionalObjectCreation)) files = ( 'traversal.txt', 'traversal_4981.txt', 'folder_marshall.txt', 'reindex_sanity_plone21.txt', 'webdav_operat... | |
return suite | return setAllLayers(suite, ATSiteLayer) | def test_suite(): from unittest import TestSuite, makeSuite from Testing.ZopeTestCase import FunctionalDocFileSuite as FileSuite suite = TestSuite() suite.addTest(makeSuite(TestFunctionalObjectCreation)) files = ( 'traversal.txt', 'traversal_4981.txt', 'folder_marshall.txt', 'reindex_sanity_plone21.txt', 'webdav_operat... |
class StrangeIdTest(ATSiteTestCase): def test_strangeUnallowedIds(self): """ Certain IDs used to give an error and are unusable They're set in zope's lib/python/App/Product.py. Examples: home, version. This test used to include 'icon', too, but that's apparently really an id that's already been taken (instead of a bug... | >>> nodes[0].setLinks([n.UID() for n in nodes[1:]]) >>> nodes[0].getLinks() [<Refnode...>, <Refnode...>] >>> nodes[0].setLinks(()) >>> nodes[0].getLinks() [] Setting multiple values for a non multivalued field will fail: >>> nodes[1].setLink(nodes) Traceback (most recent call last): ... ValueError: Multiple values ..... | def testSetFilenameOfLargeFile(self): """Test for https://dev.plone.org/archetypes/ticket/635 """ self.folder.invokeFactory('SimpleFile', 'sf') obj = self.folder.sf contents = StringIO('largest file, ' * 10000) obj.setBody(contents) self.assertEqual(obj.getBody().size, 140000) obj.getBody().setFilename('Spam.txt') self... |
visible, hidden, invisible""" vis_dic = getattr(aq_base(self), 'visible', None) | Return values are visible, hidden, invisible The value for the attribute on the field may either be a dict with a mapping for edit and view:: visible = { 'edit' :'hidden', 'view' : 'invisible' } Or a single value for all modes:: True/1: 'visible' False/0: 'invisible' -1: 'hidden' The default state is 'visibl... | def isVisible(self, instance, mode='view'): """decide if a field is visible in a given mode -> 'state' visible, hidden, invisible""" # example: visible = { 'edit' :'hidden', 'view' : 'invisible' } vis_dic = getattr(aq_base(self), 'visible', None) state = 'visible' if not vis_dic: return state # ugly hack ... if type(vi... |
if not vis_dic: | if vis_dic is _marker: | def isVisible(self, instance, mode='view'): """decide if a field is visible in a given mode -> 'state' visible, hidden, invisible""" # example: visible = { 'edit' :'hidden', 'view' : 'invisible' } vis_dic = getattr(aq_base(self), 'visible', None) state = 'visible' if not vis_dic: return state # ugly hack ... if type(vi... |
if type(vis_dic) == DictType: | if type(vis_dic) is DictType: | def isVisible(self, instance, mode='view'): """decide if a field is visible in a given mode -> 'state' visible, hidden, invisible""" # example: visible = { 'edit' :'hidden', 'view' : 'invisible' } vis_dic = getattr(aq_base(self), 'visible', None) state = 'visible' if not vis_dic: return state # ugly hack ... if type(vi... |
self.createScales(instance) | self.createScales(instance, value=imgdata) | def set(self, instance, value, **kwargs): if not value: return |
image = self._wrapValue(instance, value, **kwargs) | if value: image = self._wrapValue(instance, value, **kwargs) else: image = self.default | def createOriginal(self, instance, value, **kwargs): """create the original image (save it) """ image = self._wrapValue(instance, value, **kwargs) |
def createScales(self, instance): | def createScales(self, instance, value=_marker): | def createScales(self, instance): """creates the scales and save them """ sizes = self.getAvailableSizes(instance) if not HAS_PIL or not sizes: return img = self.getRaw(instance) if not img: return filename = self.getFilename(instance) #dot = filename.rfind('.') #filename, ext = filename[:dot], filename[dot:] data = st... |
img = self.getRaw(instance) if not img: | if value is _marker: img = self.getRaw(instance) if not img: return data = str(img.data) else: data = value if not data: | def createScales(self, instance): """creates the scales and save them """ sizes = self.getAvailableSizes(instance) if not HAS_PIL or not sizes: return img = self.getRaw(instance) if not img: return filename = self.getFilename(instance) #dot = filename.rfind('.') #filename, ext = filename[:dot], filename[dot:] data = st... |
data = str(img.data) | def createScales(self, instance): """creates the scales and save them """ sizes = self.getAvailableSizes(instance) if not HAS_PIL or not sizes: return img = self.getRaw(instance) if not img: return filename = self.getFilename(instance) #dot = filename.rfind('.') #filename, ext = filename[:dot], filename[dot:] data = st... | |
returns a DisplayList uses self.vocabulary as source 1) Dynamic vocabulary: precondition: a content_instance is given. has to return a: | Returns a DisplayList. Uses self.vocabulary as source. 1) Static vocabulary - is already a DisplayList - is a list of 2-tuples with strings (see above) - is a list of strings (in this case a DisplayList with key=value will be created) 2) Dynamic vocabulary: - precondition: a content_instance is given. - has to re... | def Vocabulary(self, content_instance=None): """ returns a DisplayList |
the output is postprocessed like a static vocabulary. vocabulary is a string: | - the output is postprocessed like a static vocabulary. - vocabulary is a string: | def Vocabulary(self, content_instance=None): """ returns a DisplayList |
vocabulary is a class implementing IVocabulary: | - vocabulary is a class implementing IVocabulary: | def Vocabulary(self, content_instance=None): """ returns a DisplayList |
2) Static vocabulary * is already a DisplayList * is a list of 2-tuples with strings (see above) * is a list of strings (in this case a DisplayList with key=value will be created) | def Vocabulary(self, content_instance=None): """ returns a DisplayList | |
if sample and len(sample[0]) != 2: | if sample and type(sample[0]) not in (TupleType, ListType): | def Vocabulary(self, content_instance=None): """ returns a DisplayList |
log("Unhandled type in Vocab") | log('Unhandled type in Vocab') | def Vocabulary(self, content_instance=None): """ returns a DisplayList |
if type(mtss) not in SEQ: mtss = (mtss,) | def _mapTransform(self, transform): SEQ = (ListType, TupleType) registry = getToolByName(self, 'mimetypes_registry') for i in transform.inputs(): mts = registry.lookup(i) if type(mts) not in SEQ: mts = (mts,) | |
mt_in.setdefault(mto, []).append(transform) | try: if not transform in mt_in[mto]: mt_in[mto].append(transform) except KeyError: mt_in[mto] = PersistentList([transform]) | def _mapTransform(self, transform): SEQ = (ListType, TupleType) registry = getToolByName(self, 'mimetypes_registry') for i in transform.inputs(): mts = registry.lookup(i) if type(mts) not in SEQ: mts = (mts,) |
if type(mtss) not in SEQ: mtss = (mtss,) | def _unmapTransform(self, transform): SEQ = (ListType, TupleType) registry = getToolByName(self, 'mimetypes_registry') for i in transform.inputs(): mts = registry.lookup(i) if type(mts) not in SEQ: mts = (mts,) | |
return self._transform.config.keys() | keys = self._transform.config.keys() keys.sort() return keys | def get_parameters(self): """ get transform's parameters names """ return self._transform.config.keys() |
return self._transform.config[key] | value = self._config[key] type = self.get_parameter_infos(key)[0] if type == 'dict': result = {} for key, val in value.items(): result[key] = val elif type == 'list': result = list(value) else: result = value return result security.declareProtected(CMFCorePermissions.ManagePortal, 'get_parameter_infos') def get_pa... | def get_parameter_value(self, key): """ get value of a transform's parameter """ return self._transform.config[key] |
transform = self._transform | self.preprocess_param(kwargs) | def set_parameters(self, REQUEST=None, **kwargs): """ set transform's parameters """ if not kwargs: kwargs = REQUEST.form |
if transform.config.has_key(param): transform.config[param] = value else: | try: self.get_parameter_value(param) except KeyError: | def set_parameters(self, REQUEST=None, **kwargs): """ set transform's parameters """ if not kwargs: kwargs = REQUEST.form |
m = import_from_name(self.module) reload(m) | def reload(self): """ reload the module where the transformation class is defined """ log('Reloading transform %s' % self.module) m = import_from_name(self.module) reload(m) self._tr_init() | |
try: f = self.Schema()[key] return f.get(self, raw=1) except: return self.Schema()[key].getAccessor(self)() | accessor = self.Schema()[key].getEditAccessor(self) if not accessor: accessor = self.Schema()[key].getAccessor(self) return accessor(maybe_baseunit=1) | def __getitem__(self, key): """play nice with externaleditor again""" if key not in self.Schema().keys() and key[:1] != "_": #XXX 2.2 return getattr(self, key, None) or getattr(aq_parent(aq_inner(self)), key, None) |
charset = self.portal_properties.site_properties.default_charset | def SearchableText(self): """full indexable text""" data = [] charset = self.portal_properties.site_properties.default_charset for field in self.Schema().fields(): if field.searchable != 1: continue method = getattr(self, field.accessor) try: datum = method(mimetype="text/plain") except TypeError: # retry in case type... | |
if type(datum) is type(u''): datum = datum.encode(charset) | def SearchableText(self): """full indexable text""" data = [] charset = self.portal_properties.site_properties.default_charset for field in self.Schema().fields(): if field.searchable != 1: continue method = getattr(self, field.accessor) try: datum = method(mimetype="text/plain") except TypeError: # retry in case type... | |
security.declarePublic("hasI18NContent") def hasI18NContent(self): """return true it the schema contains at least one I18N field""" return self.Schema().hasI18NContent() | security.declarePrivate( '_datify' ) def _datify( self, attrib ): """FIXME: overriden from DublinCore to deal with blank value...""" if attrib == 'None' or not attrib: attrib = None elif not isinstance( attrib, DateTime ): attrib = DateTime( attrib ) return attrib security.declarePublic( 'Date' ) def Date( self ): """... | def Schemata(self): from Products.Archetypes.Schema import getSchemata return getSchemata(self) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.