def check_restrictions(cls, models, restrictions, action=None): """Check if attribute satisfied restrictions :param models: objects which represent models in restrictions :type models: dict :param restrictions: list of restrictions to check :type restrictions: list :param action: filtering restrictions by action key :type action: string :returns: dict -- object with 'result' as number and 'message' as dict """ satisfied = [] if restrictions: expened_restrictions = map( cls._expand_restriction, restrictions) # Filter by action if action: filterd_by_action_restrictions = filter( lambda item: item.get('action') == action, expened_restrictions) else: filterd_by_action_restrictions = expened_restrictions[:] # Filter which restriction satisfied condition satisfied = filter( lambda item: Expression( item.get('condition'), models).evaluate(), filterd_by_action_restrictions) return { 'result': bool(satisfied), 'message': '. '.join([item.get('message') for item in satisfied if item.get('message')]) }
def check_roles_requirement(cls, roles, roles_metadata, models): for role in roles: if "depends" in roles_metadata[role]: depends = roles_metadata[role]['depends'] for condition in depends: expression = condition['condition'] if not Expression(expression, models).evaluate(): raise errors.InvalidData(condition['warning'])
def evaluate(condition): try: logger.debug("evaluate legacy condition: %s", condition) return Expression( Context.transform_legacy_condition(condition), context, strict=False).evaluate() except Exception as e: logger.error("Failed to evaluate legacy condition '%s': %s", condition, e) raise
def test_plugin_role_restrictions_normalization(self): # checking presence and syntax of generated restriction for role, meta in six.iteritems( self.plugin_adapter.normalized_roles_metadata): for condition in meta['restrictions']: self.assertNotRaises( errors.ParseError, lambda: Expression(condition, { 'settings': self.cluster.attributes.editable }, strict=False).evaluate())
def check_roles_requirement(cls, roles, roles_metadata, models): for role in roles: if "restrictions" in roles_metadata[role]: restrictions = roles_metadata[role]['restrictions'] for condition in restrictions: expression = condition['condition'] if Expression(expression, models).evaluate(): message = condition.get('message', expression) raise errors.InvalidNodeRole( "Role '{}' restrictions mismatch: {}" .format(role, message))
def _evaluate_expression(self, expression, models): """Evaluate expression if it exists""" if expression: return Expression(str(expression), models).evaluate()
def evaluate_expression(expression, models, strict): return Expression(expression, models, strict).evaluate()
def should_execute(self): if 'condition' not in self.task: return True return Expression(self.task['condition'], self._expression_context).evaluate()
def evaluate_expression(expression, models): return Expression(expression, models).evaluate()