def fetch_enabled(self): enabled = self._enabled if not callable(enabled): return defer.succeed(bool(enabled)) # By default the key is the action name maker = IContextMaker(self.model) context = maker.make_context(key=self.name, action=self) return enabled(None, context)
def perform(self, *args, **kwargs): parameters = self._parameters # Only once cause it is costly value = None d = defer.Deferred() try: if len(args) > 0: values = list(args) values += [kwargs[u"value"]] if u"value" in kwargs else [] if len(values) > 1: raise TypeError("Action %s can only have one value: %s" % (self.name, ", ".join([repr(v) for v in values]))) if args: kwargs[u"value"] = args[0] params = set(kwargs.keys()) expected = set(parameters.keys()) required = set([p.name for p in parameters.itervalues() if p.is_required]) if not required <= params: raise TypeError("Action %s require parameters: %s" % (self.name, ", ".join(required))) if not params <= expected: if not expected: raise TypeError("Action %s expect no parameter" % (self.name, )) raise TypeError("Action %s expect only parameters: %s" % (self.name, ", ".join(expected))) validated = {} for param_name, param_value in kwargs.iteritems(): info = parameters[param_name].value_info validated[param_name] = IValidator(info).validate(param_value) for param in parameters.itervalues(): if not param.is_required: info = param.value_info if param.name not in validated and info.use_default: validated[param.name] = info.default value = validated.pop(u"value", None) # We use the model name instead of the action name as key maker = IContextMaker(self.model) context = maker.make_context(action=self) def log_effect_Error(failure, effect): error.handle_failure(None, failure, "Failure during effect %s execution", effect.func_name) return failure for effect in self._effects: try: d.addCallback(effect, context, **validated) d.addErrback(log_effect_Error, effect) except AssertionError: err = ValueError("Invalid action effect: %r" % (effect, )) return defer.fail(err) if self._result_info is not None: d.addCallback(IValidator(self._result_info).publish) else: d.addCallback(defer.override_result, None) except ValueError: return defer.fail() except TypeError: return defer.fail() else: d.callback(value) return d
param_errors = ", ".join("%s: %s" % (p, m) for p, m in errors.iteritems()) msg = ("Action %s parameter(s) invalid: %s" % (self.name, param_errors)) raise InvalidParameters(msg, params=errors) for param in parameters: if not param.is_required: info = param.value_info if param.name not in validated and info.use_default: validated[param.name] = info.default value = validated.pop(u"value", None) # We use the model name instead of the action name as key maker = IContextMaker(self.model) context = maker.make_context(action=self) def log_effect_Error(failure, effect): error.handle_failure(None, failure, "Failure during effect %s execution", effect.func_name) return failure for effect in self._effects: try: d.addCallback(effect, context, **validated) d.addErrback(log_effect_Error, effect) except AssertionError: err = ValueError("Invalid action effect: %r" % (effect, )) failure = Failure(err, exc_tb=sys.exc_info()[2])