Exemple #1
0
    def validate_term_model(cls):
        """
        RUS: Добавляет термин 'Категория пользователя' и 'Неизвестный пользователь' в модель терминов TermModel
        при их отсутствии.
        """
        # валидируем только один раз
        key = 'vldt:сstmr_ctgr'
        need_validation = EntityModel._validate_term_model_cache.get(key, True)
        if need_validation:
            EntityModel._validate_term_model_cache[key] = False

            with transaction.atomic():
                try:  # customer-category
                    customer_category = TermModel.objects.get(
                        slug=cls.CUSTOMER_CATEGORY_ROOT_TERM_SLUG, parent=None)
                except TermModel.DoesNotExist:
                    customer_category = TermModel(
                        slug=cls.CUSTOMER_CATEGORY_ROOT_TERM_SLUG,
                        parent=None,
                        name=force_text(_('Customer category')),
                        semantic_rule=TermModel.XOR_RULE,
                        system_flags=(
                            TermModel.system_flags.delete_restriction
                            | TermModel.system_flags.change_parent_restriction
                            | TermModel.system_flags.change_slug_restriction))
                    customer_category.save()
            with transaction.atomic():
                try:  # unknown-customer
                    customer_category.get_descendants(include_self=False).get(
                        slug=cls.UNKNOWN_CUSTOMER_TERM_SLUG)
                except TermModel.DoesNotExist:
                    unknown_customer = TermModel(
                        slug=cls.UNKNOWN_CUSTOMER_TERM_SLUG,
                        parent_id=customer_category.id,
                        name=force_text(_('Unknown customer')),
                        semantic_rule=TermModel.OR_RULE,
                        system_flags=(
                            TermModel.system_flags.delete_restriction
                            | TermModel.system_flags.change_parent_restriction
                            | TermModel.system_flags.change_slug_restriction
                            | TermModel.system_flags.has_child_restriction))
                    unknown_customer.save()
        super(CustomerCategoryMixin, cls).validate_term_model()
Exemple #2
0
    def validate_term_model(cls):
        """
        RUS: Добавляет термин Регион и Другие регионы в модель терминов TermModel при их отсутствии.
        """
        # валидируем только один раз
        key = 'vldt:place'
        need_validation = EntityModel._validate_term_model_cache.get(key, True)
        if need_validation:
            EntityModel._validate_term_model_cache[key] = False

            with transaction.atomic():
                try:  # region
                    region = TermModel.objects.get(
                        slug=cls.REGION_ROOT_TERM_SLUG, parent=None)
                except TermModel.DoesNotExist:
                    region = TermModel(
                        slug=cls.REGION_ROOT_TERM_SLUG,
                        parent=None,
                        name=force_text(_('Region')),
                        semantic_rule=TermModel.XOR_RULE,
                        system_flags=(
                            TermModel.system_flags.delete_restriction
                            | TermModel.system_flags.change_parent_restriction
                            | TermModel.system_flags.change_slug_restriction))
                    region.save()
            with transaction.atomic():
                try:  # terra-incognita
                    region.get_descendants(include_self=False).get(
                        slug=cls.TERRA_INCOGNITA_TERM_SLUG)
                except TermModel.DoesNotExist:
                    terra_incognita = TermModel(
                        slug=cls.TERRA_INCOGNITA_TERM_SLUG,
                        parent_id=region.id,
                        name=force_text(_('Terra Incognita')),
                        semantic_rule=TermModel.OR_RULE,
                        system_flags=(
                            TermModel.system_flags.delete_restriction
                            | TermModel.system_flags.change_parent_restriction
                            | TermModel.system_flags.change_slug_restriction
                            | TermModel.system_flags.has_child_restriction))
                    terra_incognita.save()
        super(PlaceMixin, cls).validate_term_model()
Exemple #3
0
    def validate_term_model(cls):
        """
        RUS: Добавляет Состояние родителя и объекта в модель TermModel при их отсутствии и сохраняет их.
        """
        super(FSMMixin, cls).validate_term_model()

        if not cls._meta.abstract and cls._meta.get_field(
                'status').model == cls:
            system_flags = _default_system_flags_restriction

            model_root_term = get_or_create_model_class_wrapper_term(cls)
            with transaction.atomic():
                try:
                    states_parent_term = TermModel.objects.get(
                        slug=cls.STATE_ROOT_TERM_SLUG, parent=model_root_term)
                except TermModel.DoesNotExist:
                    states_parent_term = TermModel(
                        slug=cls.STATE_ROOT_TERM_SLUG,
                        parent_id=model_root_term.id,
                        name=force_text(
                            cls._meta.get_field('status').verbose_name),
                        semantic_rule=TermModel.XOR_RULE,
                        system_flags=system_flags)
                    states_parent_term.save()
            transition_states = cls.TRANSITION_TARGETS
            for state_key, state_name in transition_states.items():
                with transaction.atomic():
                    try:
                        states_parent_term.get_descendants(
                            include_self=False).get(slug=state_key)
                    except TermModel.DoesNotExist:
                        state = TermModel(slug=state_key,
                                          parent_id=states_parent_term.id,
                                          name=force_text(state_name),
                                          semantic_rule=TermModel.OR_RULE,
                                          system_flags=system_flags)
                        state.save()