# Search the Catalog for login and return a list of person objects # login can be a string or a list of strings # (no docstring to prevent publishing) if not login: return [] if isinstance(login, list): login = tuple(login) elif not isinstance(login, tuple): login = str(login) try: return getUserByLogin(self.getPortalObject(), login, exact_match) except ConflictError: raise except: LOG('ERP5Security', PROBLEM, 'getUserByLogin failed', error=sys.exc_info()) # Here we must raise an exception to prevent callers from caching # a result of a degraded situation. # The kind of exception does not matter as long as it's catched by # PAS and causes a lookup using another plugin or user folder. # As PAS does not define explicitely such exception, we must use # the _SWALLOWABLE_PLUGIN_EXCEPTIONS list. raise _SWALLOWABLE_PLUGIN_EXCEPTIONS[0] classImplements( ERP5UserManager , IAuthenticationPlugin , IUserEnumerationPlugin ) InitializeClass(ERP5UserManager)
if REQUEST is None: REQUEST = get_request() if self.getWebSiteValue(): site_url = self.getWebSiteValue().absolute_url() elif REQUEST and 'came_from' in REQUEST: site_url = REQUEST.came_from else: site_url = self.getPortalObject().absolute_url() try: register_user_login, expiration_date = self._password_request_dict[ password_key] except KeyError: # XXX: incorrect grammar and not descriptive enough return error('Key not known. Please ask reset password.') if user_login is not None and register_user_login != user_login: # XXX: not descriptive enough return error("Bad login provided.") if DateTime() > expiration_date: # XXX: incorrect grammar return error("Date has expire.") del self._password_request_dict[password_key] persons = self.getPortalObject().acl_users.erp5_users.getUserByLogin( register_user_login) person = persons[0] person._forceSetPassword(password) person.reindexObject() return redirect(REQUEST, site_url, translateString("Password changed.")) InitializeClass(PasswordTool)
return "Subscribed to Timer Service" return "TimerService not available" security.declareProtected(Permissions.ManageProperties, 'unsubscribe') def unsubscribe(self): """Unsubscribe from the global Timer Service""" service = getTimerService(self) if service: service.unsubscribe(self) return "Usubscribed from Timer Service" return "TimerService not available" security.declarePrivate('manage_beforeDelete') def manage_beforeDelete(self, *args, **kw): self.unsubscribe() super(TimerServiceMixin, self).manage_beforeDelete(*args, **kw) security.declarePrivate('manage_afterAdd') def manage_afterAdd(self, *args, **kw): self.subscribe() super(TimerServiceMixin, self).manage_afterAdd(*args, **kw) security.declarePublic('getCurrentNode') getCurrentNode = ActivityTool.getCurrentNode.im_func security.declarePublic('getServerAddress') getServerAddress = ActivityTool.getServerAddress.im_func _isValidNodeName = ActivityTool._isValidNodeName.im_func InitializeClass(TimerServiceMixin)
# Prepare definition dict once only category_definition_dict = {} for c in self.getRoleCategoryList(): bc, value = c.split('/', 1) category_definition_dict.setdefault(bc, []).append(value) # category_result is a list of dicts that represents the resolved # categories we create a category_value_dict from each of these # dicts aggregated with category_order and statically defined # categories for category_dict in category_result: category_value_dict = {'category_order': category_order_list} category_value_dict.update(category_dict) category_value_dict.update(category_definition_dict) group_id_list = group_id_generator(**category_value_dict) if group_id_list: if isinstance(group_id_list, str): # Single group is defined (this is usually for group membership) # DEPRECATED due to cartesian product requirement group_id_list = group_id_list, # Multiple groups are defined (list of users # or list of group IDs resulting from a cartesian product) for group_id in group_id_list: group_id_role_dict[group_id] = role_list return group_id_role_dict InitializeClass(RoleInformation)
def setDescription(self, value): """ Sets the description by invoking the Accessor based method rather than the one inherited from CMF. This is require to make sure that value is casted """ self._setDescription(value) self.reindexObject() security.declareProtected(Permissions.ModifyPortalContent, 'XUpdateDocument') def XUpdateDocument(self, xupdate): """ Update a document by providing an xupdate XML file """ pass security.declareProtected(Permissions.ModifyPortalContent, 'fromXML') def fromXML(self, xml): """ Replace the content of this object by providing an xml content """ from erp5.component.module.ERP5Conduit import ERP5Conduit conduit = ERP5Conduit() conduit.addNode(object=self, xml=xml) InitializeClass(XMLObject)
def getObject(module, name, reload=0): # Modified version that ignore errors as long as the module can be be # imported, which is enough to use a ZODB Extension as a brain. try: m = __import__('erp5.component.extension.%s' % module, globals(), {}, 'erp5.component.extension') o = getattr(m, name, None) if o is None: raise ImportError( "Cannot get %s from erp5.component.extension.%s" % (name, module)) return o except ImportError: return original_function(module, name, reload=reload) return getObject # This get Object exists both in App.Extensions.getObject and Shared.DC.ZRDB.DA # for some versions of Zope/Products.ZSQLMethods, so we try to patch both if # they exist import Shared.DC.ZRDB.DA if hasattr(Shared.DC.ZRDB.DA, 'getObject'): Shared.DC.ZRDB.DA.getObject = getObjectMeta(Shared.DC.ZRDB.DA.getObject) import App.Extensions App.Extensions.getObject = getObjectMeta(App.Extensions.getObject) InitializeClass(DA)
security.declarePublic('getReportTreeMode') def getReportTreeMode(self): return getattr(self, 'report_tree_mode', 0) security.declarePublic('getAnonymousSelectionKey') def getAnonymousSelectionKey(self): return md5( repr({k: v for k, v in self.__dict__.iteritems() if k != 'index'})).hexdigest() InitializeClass(Selection) allow_class(Selection) class DomainSelection(Acquisition.Implicit, Traversable, Persistent): """ A class to store a selection of domains which defines a report section. There are different ways to use DomainSelection in SQL methods. As a general principle, SQL methods are passed DomainSelection instances as a parameter. Example 1: (hand coded) The domain is accessed directly from the selection and a list of uids is gathered from the ZODB to feed the SQL request. This approach is only suitable for categories and relations. It is
security.declarePublic('searchAndActivate') def searchAndActivate(self, *args, **kw): """Restricted version of _searchAndActivate""" return self._searchAndActivate(restricted=True, *args, **kw) security.declareProtected(Permissions.ManagePortal, 'upgradeSchema') def upgradeSchema(self, sql_catalog_id=None, src__=0): catalog = self.getSQLCatalog(sql_catalog_id) connection_id = catalog.z_create_catalog.connection_id src = [] for clear_method in catalog.sql_clear_catalog: clear_method = catalog[clear_method] try: r = clear_method._upgradeSchema(connection_id, src__=1) except ProgrammingError, e: if e[0] != NO_SUCH_TABLE: raise r = clear_method(src__=1) if r: src.append(r) if src and not src__: query = self.getPortalObject()[connection_id]().query for r in src: query(r) return src InitializeClass(CatalogTool)
context, rounding=rounding, movement_generator=movement_generator) # Apply Diff for movement in movement_diff.getDeletableMovementList(): movement.getParentValue().deleteContent(movement.getId()) for movement, kw in movement_diff.getUpdatableMovementList(): movement.edit(**kw) for property_id in kw: movement.clearRecordedProperty(property_id) for movement in movement_diff.getNewMovementList(): d = movement.__dict__ assert movement.isTempObject() if '_original' in d: # slow but safe way (required for compensated movements) context.newContent(portal_type=self.movement_type, **_getPropertyAndCategoryList(movement)) continue # fast way (we had to make sure such optimization # does not touch existing persistent data) del movement.__dict__ movement = context.newContent(portal_type=self.movement_type) d.update(movement.__dict__) categories = d.pop('categories') movement.__dict__ = d # Force update of local indexes on linked objects # (important for 'delivery'). movement._setCategoryList(categories) InitializeClass(MovementCollectionUpdaterMixin)
# self.wfile.write(token.to_string()) except OAuthError, err: self.send_oauth_error(err, REQUEST) return # protected resources if path.startswith(RESOURCE_URL): try: # verify the request has been oauth authorized consumer, token, params = self.verify_request(oauth_request) # send okay response # self.send_response(200, 'OK') # self.end_headers() # # return the extra parameters - just for something to return # self.wfile.write(str(params)) return str(params) except OAuthError, err: self.send_oauth_error(err, REQUEST) return # alias method request_token_ready = call request_token = call authorize = call access_token = call photos = call authorizationVerified = call InitializeClass(OAuthTool)
self._renameCellRange(*new_cell_range, **kwd) class TempXMLMatrix(XMLMatrix): """Temporary XMLMatrix. If we need Base services (categories, edit, etc) in temporary objects we shoud used TempBase """ isIndexable = ConstantGetter('isIndexable', value=False) def newCellContent(self, id): """ Creates a new content in a cell. """ new_temp_object = TempBase(id) self._setObject(id, new_temp_object) return self.get(id) def reindexObject(self, *args, **kw): pass def unindexObject(self, *args, **kw): pass def activate(self): return self InitializeClass(XMLMatrix)
for c in child_value_list: if include_if_child: value_list.append(c) else: if len(c.objectIds(self.allowed_types))==0: value_list.append(c) if checked_permission is not None: checkPermission = self.portal_membership.checkPermission def permissionFilter(obj): return checkPermission(checked_permission, obj) value_list = filter(permissionFilter, value_list) return sortValueList(value_list, sort_on, sort_order, **kw) # Alias for compatibility security.declareProtected(Permissions.AccessContentsInformation, 'getBaseCategory') getBaseCategory = getBaseCategoryValue # Hardcode these getters as they are used when generating # accessors getReadPermission = BaseGetter('getReadPermission', 'read_permission', 'string') getWritePermission = BaseGetter('getWritePermission', 'write_permission', 'string') InitializeClass( Category ) InitializeClass( BaseCategory )
else: source_code_line_list = [] for line in f: for (filesystem_module, zodb_module) in filesystem_zodb_module_mapping_set: if line.startswith("from " + filesystem_module + " "): line = line.replace(filesystem_module, zodb_module, 1) break source_code_line_list.append(line) source_code = ''.join(source_code_line_list) # Checking that the source code is syntactically correct is not # needed when importing from filesystem, moreover errors may occur # if in the same transaction a Component is created and another # one depending upon the former... object_id = '%s.%s.%s' % (cls.getIdPrefix(), version, reference) new_component = context.newContent(id=object_id, reference=reference, source_reference=source_reference, version=version, text_content=source_code, portal_type=cls.portal_type) return new_component InitializeClass(ComponentMixin)
def getConfigurationPropertyIdList(self): """ """ return self._getConfigurationPropertyDict().keys() security.declareProtected(Permissions.AccessContentsInformation, 'getConfigurationPropertyDict') def getConfigurationPropertyDict(self): """ """ return dict(self._getConfigurationPropertyDict()) security.declareProtected(Permissions.ModifyPortalContent, 'updateConfiguration') def updateConfiguration(self, **kw): """ """ self._getConfigurationPropertyDict().update(kw) def _getConfigurationPropertyDict(self): if getattr(aq_base(self), '_configuration_property_dict', None) is None: self._configuration_property_dict = PersistentMapping() return self._configuration_property_dict InitializeClass(ConfigurableMixin)
security.declareProtected(Permissions.AccessContentsInformation, 'getTargetFormatTitleList') def getTargetFormatTitleList(self): """ Returns a list of acceptable formats for conversion """ return [x[0] for x in self.getTargetFormatItemList()] security.declareProtected(Permissions.AccessContentsInformation, 'getTargetFormatList') def getTargetFormatList(self): """ Returns a list of acceptable formats for conversion """ return [x[1] for x in self.getTargetFormatItemList()] security.declareProtected(Permissions.ModifyPortalContent, 'isTargetFormatAllowed') def isTargetFormatAllowed(self, format): # pylint: disable=redefined-builtin """ Checks if the current document can be converted into the specified target format. """ return format in self.getTargetFormatList() InitializeClass(CachedConvertableMixin)
def isAuthenticationPolicyEnabled(self): """ Return True if authentication policy is enabled. This method exists here due to bootstrap issues. It should work even if erp5_authentication_policy bt5 is not installed. """ # XXX: define an interface def _isAuthenticationPolicyEnabled(): portal_preferences = self.getPortalObject().portal_preferences method_id = 'isPreferredAuthenticationPolicyEnabled' method = getattr(self, method_id, None) if method is not None and method(): return True return False tv = getTransactionalVariable() tv_key = 'PreferenceTool._isAuthenticationPolicyEnabled.%s' % getSecurityManager( ).getUser().getId() if tv.get(tv_key, None) is None: _isAuthenticationPolicyEnabled = CachingMethod( _isAuthenticationPolicyEnabled, id='PortalPreferences_isAuthenticationPolicyEnabled', cache_factory='erp5_content_short') tv[tv_key] = _isAuthenticationPolicyEnabled() return tv[tv_key] InitializeClass(PreferenceTool)
if pass_if_exist: pass security.declareProtected(Permissions.ManagePortal, 'getTrashBinObjectsList') def getTrashBinObjectsList(self, trashbin): """ Return a list of trash objects for a given trash bin """ def getChildObjects(obj): object_list = [] if hasattr(aq_base(obj), 'objectValues'): childObjects = obj.objectValues() if hasattr(aq_base(obj), 'isHidden'): if not obj.isHidden: object_list.append(obj) if len(childObjects) > 0: for o in childObjects: object_list.extend(getChildObjects(o)) else: object_list.append(obj) return object_list list = getChildObjects(trashbin) list.sort() return list InitializeClass(TrashTool)
security.declareProtected(Permissions.ModifyPortalContent, 'notifyAfterUpdateRelatedContent') def notifyAfterUpdateRelatedContent(self, previous_category_url, new_category_url): """Hook called when a category is renamed. We must do some matrix range update in the event matrix range is defined by a category """ LOG('XMLMatrix notifyAfterUpdateRelatedContent', 0, str(new_category_url)) update_method = self.portal_categories.updateRelatedCategory for base_id in self.getMatrixList(): cell_range = self.getCellRange(base_id=base_id) new_cell_range = [] for range_item_list in cell_range: new_range_item_list = map( lambda c: update_method(c, previous_category_url, new_category_url), range_item_list) new_cell_range.append(new_range_item_list) kwd = {'base_id': base_id} LOG('XMLMatrix notifyAfterUpdateRelatedContent matrix', 0, str(base_id)) LOG('XMLMatrix notifyAfterUpdateRelatedContent _renameCellRange', 0, str(new_cell_range)) self._renameCellRange(*new_cell_range, **kwd) InitializeClass(Matrix)
# have called it (= rule would have been excluded before, depending # on other criterions). Or there may be a bug. # We don't know why it failed so let Predicate.test() do the work. if rule.test(movement, tested_base_category_list=tested_base_category_list): rule_list.append(rule) return rule_list security.declarePrivate('updateSimulation') @UnrestrictedMethod def updateSimulation(self, message_list): expandable_dict = defaultdict(list) for m in message_list: expandable_dict[m.object].append(m) try: for expandable, message_list in expandable_dict.iteritems(): kw = {} for m in message_list: kw.update(m.kw) m.result = None LOG("RuleTool", INFO, "Updating simulation for %s: %r" % (expandable.getPath(), kw)) expandable._updateSimulation(**kw) except Exception: exc_info = sys.exc_info() for m in message_list: m.raised(exc_info) InitializeClass(RuleTool)
return value security.declareProtected(Permissions.ManagePortal, 'setAllCellTALES') def setAllCellTALES(self, new_cells) : """ set all cell values from a dict containing { name: TALES } """ for cell_name, cell_TALES in new_cells.items() : self.setCellTALES(cell_name, cell_TALES) security.declareProtected(Permissions.View, 'getFormatMethodTALES') def getFormatMethodTALES(self): """ returns the TALES expression for the format method attribute """ return self.__format_method__ security.declareProtected(Permissions.ManagePortal, 'setFormatMethodTALES') def setFormatMethodTALES(self, TALES): """ sets TALES expression for the format method attribute """ self.__format_method__ = str(TALES) security.declareProtected(Permissions.View, 'getPageRangeTALES') def getPageRangeTALES(self): """ returns the TALES expression for the page range attribute """ return self.__page_range__ security.declareProtected(Permissions.ManagePortal, 'setPageRangeTALES') def setPageRangeTALES(self, TALES): """ sets TALES expression for the page range attribute """ self.__page_range__ = str(TALES) InitializeClass(PDFForm)
try: for p in 'index.txt', 'crlnumber': p = os.path.join(self.certificate_authority_path, p) os.rename(p + '.old', p) for p in created: if os.path.exists(p): os.unlink(p) except: # do not raise during cleanup pass raise e[0], e[1], e[2] finally: self._unlockCertificateAuthority() def _getValidSerial(self, common_name): index = open(self.index).read().splitlines() valid_line_list = [q for q in index if q.startswith('V') and ('CN=%s/' % common_name in q)] if len(valid_line_list) != 1: raise ValueError('No certificate for %r' % common_name) return valid_line_list[0].split('\t')[3] security.declareProtected(Permissions.AccessContentsInformation, 'revokeCertificate') def revokeCertificateByCommonName(self, common_name): self._checkCertificateAuthority() serial = self._getValidSerial(common_name) self.revokeCertificate(serial) InitializeClass(CertificateAuthorityTool)
from AccessControl import ClassSecurityInfo from Products.ERP5Type.Globals import InitializeClass, DTMLFile from Products.ERP5 import _dtmldir from Products.ERP5Type import Permissions from Products.ERP5Type.Tool.BaseTool import BaseTool """ ERP5 portal_integrations tool """ class IntegrationTool(BaseTool): """ The IntegrationTool is used to exchange with the differents external management systems. """ id = 'portal_integrations' title = 'Integration Tool' meta_type = 'ERP5 Integration Tool' portal_type = 'Integration Tool' allowed_type = () # Declarative Security security = ClassSecurityInfo() # ZMI Methods security.declareProtected(Permissions.ManagePortal, 'manage_overview') manage_overview = DTMLFile('explainIntegrationTool', _dtmldir) InitializeClass(IntegrationTool)
raise NotImplementedError # Implementation of ISolver security.declarePrivate('solve') def solve(self, activate_kw=None): with super_user(): self._solve(activate_kw=activate_kw) def getPortalTypeValue(self): return self.getPortalObject().portal_solvers._getOb( self.getPortalType()) security.declareProtected(Permissions.AccessContentsInformation, 'searchDeliverySolverList') def searchDeliverySolverList(self, **kw): """ this method returns a list of delivery solvers XXX here we cannot test delivery solver as a predicate, because predicate's context should be Solver Decision, not a target solver. """ target_solver_type = self.getPortalTypeValue() solver_list = target_solver_type.getDeliverySolverValueList() return solver_list InitializeClass(SolverMixin)
inventory_date ) self.activate(after_method_id=('runInventoryMethod'), after_tag="runInventoryMethod", priority=5).InventoryModule_reindexMovementList(sql_catalog_id=destination_sql_catalog_id, final_activity_tag="InventoryModule_reindexMovementList" ) if RESPONSE is not None: URL1 = REQUEST.get('URL1') RESPONSE.redirect(URL1 + '/portal_archives?portal_status_message=Archiving%20Started') def runInventoryMethod(self, archive_id, source_connection_id, destination_sql_catalog_id, inventory_date): """ Use a specific method to create inventory in order to use activity to execute it """ archive = self._getOb(archive_id) inventory_method_id = archive.getInventoryMethodId() inventory_method = getattr(archive, inventory_method_id, None) if inventory_method is not None: inventory_method(source_connection_id, destination_sql_catalog_id, inventory_date, tag='runInventoryMethod') InitializeClass(ArchiveTool)
for property_group in delivery_builder.contentValues( portal_type="Property group"): if test_property in property_group.getTestedPropertyList(): application_value_level[ property_group.getCollectGroupOrder()] = None # etc. same security.declareProtected(Permissions.AccessContentsInformation, 'searchTargetSolverList') def searchTargetSolverList(self, divergence_tester, simulation_movement, automatic_solver_only=False, **kw): """ this method returns a list of target solvers, as predicates against simulation movement. """ solver_list = divergence_tester.getSolverValueList() if automatic_solver_only: return [x for x in solver_list if x.isAutomaticSolver() and \ x.test(simulation_movement, **kw)] else: return [ x for x in solver_list if x.test(simulation_movement, **kw) ] InitializeClass(SolverTool)
""" klass = self.getDocumentedObject().__class__ return self._getPropertyHolder().getClassPropertyItemList(klass, **kw) security.declareProtected(Permissions.AccessContentsInformation, 'getClassPropertyIdList') def getClassPropertyIdList(self, **kw): """ Return a list of tuple (id, method) for every class method """ klass = self.getDocumentedObject().__class__ return self._getPropertyHolder().getClassPropertyIdList(klass, **kw) security.declareProtected(Permissions.AccessContentsInformation, 'getGeneratedPropertyIdList') def getGeneratedPropertyIdList(self): """ """ security.declareProtected(Permissions.AccessContentsInformation, 'getGeneratedBaseCategoryIdList') def getGeneratedBaseCategoryIdList(self): """ """ InitializeClass(PortalTypeInstanceDocumentationHelper)
if parent is not None: inner_obj = parent continue new = getattr(inner_obj, 'im_self', None) if new is not None: inner_obj = aq_inner(new) continue break return None InitializeClass(ERP5User) class ERP5UserFactory(BasePlugin): """ PAS plugin for creating users that understand local roles blocking based on type information's acquire_local_roles """ meta_type = 'ERP5 User Factory' security = ClassSecurityInfo() def __init__(self, id, title=None): self._id = self.id = id self.title = title def createUser(self, user_id, name): """ See IUserFactoryPlugin
security.declareObjectProtected(Permissions.AccessContentsInformation) # Default Properties property_sheets = (PropertySheet.Base, PropertySheet.XMLObject, PropertySheet.CategoryCore, PropertySheet.DublinCore, PropertySheet.TargetSolver) def updateConfiguration(self, **kw): # This method is called once for each 'Solver Decision' of a # 'Solver Process' that maps into this solver for the same # Simulation Movement, so we need to take care not to lose # information by overwriting. configuration = self._getConfigurationPropertyDict() tested_property_list = configuration.get('tested_property_list') if tested_property_list is not None: tested_property_set = set(tested_property_list) tested_property_set.update(kw.get('tested_property_list', ())) kw['tested_property_list'] = list(tested_property_set) super(ConfigurablePropertySolverMixin, self).updateConfiguration(**kw) def getTestedPropertyList(self): configuration_dict = self.getConfigurationPropertyDict() tested_property_list = configuration_dict.get('tested_property_list') if tested_property_list is None: portal_type = self.getPortalObject().portal_types.getTypeInfo(self) tested_property_list = portal_type.getTestedPropertyList() return tested_property_list InitializeClass(ConfigurablePropertySolverMixin)
amount._setQuantity(amount.getConvertedQuantity()) amount._setQuantityUnit(amount.getResourceDefaultQuantityUnit()) if rounding: # We hope here that rounding is sufficient at line level amount = getRoundingProxy(amount, context=self) amount._base = delivery_amount result.append(amount) # Contribute quantity *= property_dict.get('price', 1) try: quantity /= property_dict.get('efficiency', 1) except ZeroDivisionError: quantity *= float('inf') for base_contribution, variation_category_list in contribution_list: base_amount.contribute(base_contribution, variation_category_list, quantity) return result security.declareProtected(Permissions.AccessContentsInformation, 'getAggregatedAmountList') def getAggregatedAmountList(self, *args, **kw): """ Implementation of a generic transformation algorith which is applicable to payroll, tax generation and BOMs. Return the list of amounts with aggregation. """ return self.getGeneratedAmountList(*args, **kw).aggregate() InitializeClass(AmountGeneratorMixin)
# Note: special users are a bastard design in Zope: they are expected to # have a user name (aka, a login), but no id (aka, they do not exist as # users). This is likely done to prevent them from having any local role # (ownership or otherwise). In reality, they should have an id (they do # exist, and user ids are some internal detail where it is easy to avoid # such magic strings) and no login (because nobody should ever be able to # log in as a special user, and logins are exposed to users (duh !) and # hence magic values are impossible to avoid with ad-hoc code peppered # everywhere). To avoid such ad-hoc code, this plugin will find magic # users so code checking if a user login exists before allowing it to be # reused, preventing misleading logins from being misused. result.append({ 'id': special_user_name, 'login': special_user_name, 'pluginid': plugin_id, 'path': None, 'uid': None, 'login_list': [ { 'reference': special_user_name, 'path': None, 'uid': None, } ] }) return tuple(result) classImplements(ERP5LoginUserManager, IAuthenticationPlugin, IUserEnumerationPlugin) InitializeClass(ERP5LoginUserManager)