Пример #1
0
    def _determine_next_flow(self, data):
        """
        根据当前传入的数据判断下一个应该流向的 flow
        :param data:
        :return:
        """
        for condition in self.conditions:
            try:
                local = {
                    'result':
                    eval(condition.source_key, {},
                         {'data': data.get_outputs()})
                }
            except KeyError:
                raise SourceKeyException(
                    '%s does not exist in %s' %
                    (condition.source_key, data.get_outputs()))

            try:
                result = eval(condition.evaluate, {}, local)
            except Exception as e:
                raise EvaluationException('%s fail with message: %s' %
                                          (condition.evaluate, e.message))
            if result:
                return condition.sequence_flow

        return None
Пример #2
0
    def targets_meet_condition(self, data):

        targets = []

        for condition in self.conditions:
            deformatted_data = {
                deformat_constant_key(key): value
                for key, value in data.items()
            }
            try:
                resolved_evaluate = ConstantTemplate(
                    condition.evaluate).resolve_data(deformatted_data)
                result = BoolRule(resolved_evaluate).test(data)
            except Exception as e:
                raise EvaluationException(
                    'evaluate[%s] fail with data[%s] message: %s' %
                    (condition.evaluate, json.dumps(deformatted_data),
                     e.message))
            if result:
                targets.append(condition.sequence_flow.target)

        if not targets:
            raise ConditionExhaustedException(
                'all conditions of branches are False')

        return targets
Пример #3
0
    def _determine_next_flow_with_boolrule(self, data):
        """
        根据当前传入的数据判断下一个应该流向的 flow ( 不使用 eval 的版本)
        :param data:
        :return:
        """
        for condition in self.conditions:
            try:
                result = BoolRule(condition.evaluate).test(data)
            except Exception as e:
                raise EvaluationException(
                    'evaluate[%s] fail with data[%s] message: %s' %
                    (condition.evaluate, json.dumps(data), e.message))
            if result:
                return condition.sequence_flow

        return None
Пример #4
0
    def _determine_next_flow_with_boolrule(self, data):
        """
        根据当前传入的数据判断下一个应该流向的 flow ( 不使用 eval 的版本)
        :param data:
        :return:
        """
        for condition in self.conditions:
            deformatted_data = {deformat_constant_key(key): value for key, value in data.items()}
            try:
                resolved_evaluate = ConstantTemplate(condition.evaluate).resolve_data(deformatted_data)
                result = BoolRule(resolved_evaluate).test(data)
            except Exception as e:
                raise EvaluationException(
                    'evaluate[%s] fail with data[%s] message: %s' % (
                        condition.evaluate,
                        json.dumps(deformatted_data),
                        e.message
                    )
                )
            if result:
                return condition.sequence_flow

        return None