Python：建造者模式

# -*- coding:utf-8 -*-
import json


class Optimizing:
    """ 优化实体类 """
    def __init__(self):
        self._optimizing = {}

    @property
    def optimizing(self):
        return self._optimizing["optimizing_id"]

    @optimizing.setter
    def optimizing(self, optimizing_id):
        self._optimizing["optimizing_id"] = optimizing_id

    def __str__(self):
        return f"<class 'Optimizing'; {self._optimizing}"


class RiskAnalysis:
    """ 风险分析实体类 """
    def __init__(self):
        self._risk_analysis = {}
        self._relation_optimizing = []
        self._index = -1

    def build_relation_optimizing(self, optimizing: Optimizing):
        self._relation_optimizing.append(optimizing)

    @property
    def risk_analysis(self):
        return self._risk_analysis["risk_analysis_id"]

    @risk_analysis.setter
    def risk_analysis(self, risk_analysis_id):
        self._risk_analysis["risk_analysis_id"] = risk_analysis_id

    def __iter__(self):
        return self

    def __next__(self):
        if self._index <= len(self._relation_optimizing) - 2 and len(self._relation_optimizing) > 0:
            self._index += 1
            return self._relation_optimizing[self._index]
        else:
            self._index = -1
            raise StopIteration

    def __str__(self):
        return f"<class> 'RiskAnalysis'; {self._risk_analysis}"


class FailureCause:
    """ 失效起因实体类 """
    def __init__(self):
        self._failure_cause = {}
        self._relation_process = {}
        self._relation_failure_mode = {}

        # 失效起因关联风险分析
        self._cause_relation_risk_analysis = {}

    @property
    def cause_relation_risk_analysis(self):
        return self._cause_relation_risk_analysis["risk_analysis_id"]

    @cause_relation_risk_analysis.setter
    def cause_relation_risk_analysis(self, risk: RiskAnalysis):
        self._cause_relation_risk_analysis["risk_analysis_id"] = risk

    @property
    def failure_cause(self):
        return self._failure_cause["failure_cause_id"]

    @failure_cause.setter
    def failure_cause(self, failure_cause_id):
        self._failure_cause["failure_cause_id"] = failure_cause_id

    @property
    def relation_process(self):
        return self._relation_process[self.failure_cause]

    @relation_process.setter
    def relation_process(self, process_id):
        self._relation_process[self.failure_cause] = process_id

    @property
    def relation_failure_mode(self):
        return self._relation_failure_mode[self._failure_cause]

    @relation_failure_mode.setter
    def relation_failure_mode(self, failure_mode_id):
        self._relation_failure_mode[self.failure_cause] = failure_mode_id

    def __str__(self):
        return f"<class> 'FailureCause'; {self._failure_cause}"


class FailureEffect:
    """ 失效影响实体类 """
    def __init__(self):
        # 失效影响id
        self._failure_effect = {}

        # 失效影响关联失效起因list
        self.effect_relation_cause = []

        # # 失效影响 关联 风险分析
        # self.effect_relation_analysis = []

    def build_relation_cause(self, cause: FailureCause):
        self.effect_relation_cause.append(cause)

    @property
    def failure_effect(self):
        return self._failure_effect["failure_effect_id"]

    @failure_effect.setter
    def failure_effect(self, failure_effect_id):
        self._failure_effect["failure_effect_id"] = failure_effect_id

    def __str__(self):
        return f"<class> 'FailureEffect'; {self._failure_effect}"


class FailureMode:
    """ 失效模式实体类 """
    def __init__(self):
        self._failure_mode = {}
        self.failure_effect = []
        self.mode_relation_cause = []

    @property
    def failure_mode(self):
        return self._failure_mode["failure_mode_id"]

    @failure_mode.setter
    def failure_mode(self, failure_mode_id):
        self._failure_mode["failure_mode_id"] = failure_mode_id

    def build_failure_effect(self, failure_effect: FailureEffect):
        self.failure_effect.append(failure_effect)

    def build_failure_cause(self, process_id, failure_cause_id):
        self.mode_relation_cause.append({
            "process_id": process_id,
            "failure_cause_id": failure_cause_id,
        })

    def __str__(self):
        return f"<class> 'FailureMode'; {self._failure_mode}"


# class Relation:
#     # 废弃
#     def __init__(self):
#         self.processStepId = None
#         self.processElementId = None
#         self.productFeatureId = None
#         self.isRefProcessFeature = None


class Process:
    """ 过程特性实体类 """
    def __init__(self):
        self._process_obj = {}

    @property
    def process_obj(self):
        return self._process_obj["process_id"]

    @process_obj.setter
    def process_obj(self, process_id):
        self._process_obj["process_id"] = process_id

    def __str__(self):
        return f"<class> 'Process'; {self._process_obj}"


class Element:
    """ 工作要素实体类 """
    def __init__(self):
        self._element_obj = {}
        self.process_list = []
        self.is_link_process = False
        self.index = -1

    @property
    def element_obj(self):
        return self._element_obj["element_obj"]

    @element_obj.setter
    def element_obj(self, element_id):
        self._element_obj["element_obj"] = element_id

    def build_is_link_process(self, is_link: bool):
        self.is_link_process = is_link

    def build_process_list(self, process: Process = None):
        self.process_list.append(process)

    def __str__(self):
        return f"<class> 'Element'; {self._element_obj}"

    def __iter__(self):
        return self

    def __next__(self):
        if self.index <= len(self.process_list) - 2 and len(self.process_list) > 0:
            self.index += 1
            return self.process_list[self.index]
        else:
            self.index = -1
            raise StopIteration


class Product:
    """ 产品特性实体类 """
    def __init__(self):
        self._product_obj = {}
        self.element_list = []
        self.failure_mode_list = []

    @property
    def product_obj(self):
        return self._product_obj["product_id"]

    @product_obj.setter
    def product_obj(self, product_id):
        self._product_obj["product_id"] = product_id

    def build_element_list(self, element: Element):
        self.element_list.append(element)

    def build_failure_mode_list(self, failure_mode: FailureMode):
        self.failure_mode_list.append(failure_mode)

    def __str__(self):
        return f"<class> 'Product'; {self._product_obj}"


class Step:
    """ 过程步骤实体类 """
    def __new__(cls, *args, **kwargs):
        flag = super().__new__(cls)
        return flag

    def __init__(self):
        self.step_obj = {}
        self.product_list = []
        self.index = -1

    # 产品特性id对象列表
    def build_step(self, step_id):
        self.step_obj["step_id"] = step_id

    def build_product_list(self, product: Product):
        self.product_list.append(product)

    def __str__(self):
        return f"<class> 'Step'; {self.step_obj}"

    def __iter__(self):
        return self

    def __next__(self):
        if self.index <= len(self.product_list) - 2 and len(self.product_list) > 0:
            self.index += 1
            return self.product_list[self.index]
        else:
            self.index = -1
            raise StopIteration


class Analysis:
    """ PFMEA分析实体类 """
    def __init__(self):
        # 步骤id对象列表
        self.step_list = []
        self.index = -1
        # self.iter = True

    # def __repr__(self):
    #     return f""

    def __str__(self):
        return f"<class> 'Analysis'"

    def build_step_list(self, step: Step):
        self.step_list.append(step)

    def __iter__(self):
        # self.iter = iter(self.step_list)
        return self

    def __next__(self):
        if self.index <= len(self.step_list) - 2 and len(self.step_list) > 0:
            self.index += 1
            # yield self.step_list[self.index]
            # next(self.step_list[self.index])
            return self.step_list[self.index]
        else:
            # del self.iter
            self.index = -1
            raise StopIteration