def validate_terms(instance):
"""
Валидатор терминов представлений для конкретной инстанции
"""
system_flags = _default_layout_system_flags_restriction
views_layouts = get_views_layouts()
pages_layouts_root = views_layouts.get(PAGE_LAYOUT_ROOT_TERM_SLUG, None)
if pages_layouts_root is not None:
if instance.id is not None:
try:
origin = PageLayout.objects.get(pk=instance.id)
except PageLayout.DoesNotExist:
pass
else:
layout = views_layouts.get(origin.key, None)
if layout is not None:
layout.slug, layout.name = instance.key, instance.title
layout.save()
else:
layout = TermModel(slug=instance.key,
parent=pages_layouts_root,
name=instance.title,
semantic_rule=TermModel.OR_RULE,
system_flags=system_flags)
layout.save()
def validate_term_model():
"""
Валидатор терминов для не Entity модели
"""
views_layouts_root = get_or_create_view_layouts_root()
try: # page layout root
pages_layouts_root = TermModel.objects.get(
slug=PAGE_LAYOUT_ROOT_TERM_SLUG, parent=views_layouts_root)
except TermModel.DoesNotExist:
pages_layouts_root = TermModel(
slug=PAGE_LAYOUT_ROOT_TERM_SLUG,
parent=views_layouts_root,
name=_('Page layout'),
semantic_rule=TermModel.XOR_RULE,
system_flags=_default_layout_system_flags_restriction)
pages_layouts_root.save()
for page_layout in PageLayout.objects.all():
try: # page layout
TermModel.objects.get(slug=page_layout.key,
parent=pages_layouts_root)
except TermModel.DoesNotExist:
layout = TermModel(
slug=page_layout.key,
parent=pages_layouts_root,
name=page_layout.title,
semantic_rule=TermModel.OR_RULE,
system_flags=_default_layout_system_flags_restriction)
layout.save()
def test_term_decompress(self):
self.assertEqual(TermModel.decompress(value=[4, 5]), {
1: [[[], []]],
2: [[], []],
4: [],
5: []
})
def patch_data(self, data, **kwargs):
tree = TermModel.cached_decompress([], fix_it=True)
data.update({
'_initial_filter_meta': tree,
'_terms_filter_meta': tree,
'_data_mart': None,
'_terms_ids': []
})
def validate_term_model(cls):
"""
RUS: Валидация модели терминов.
Добавляет термины класса объекта в дерево согласно структуре наследования.
"""
view_root = get_or_create_view_layouts_root()
try: # publication root
TermModel.objects.get(slug=cls.LAYOUT_TERM_SLUG, parent=view_root)
except TermModel.DoesNotExist:
publication_root = TermModel(
slug=cls.LAYOUT_TERM_SLUG,
parent=view_root,
name=_('Publication'),
semantic_rule=TermModel.XOR_RULE,
system_flags=_publication_root_terms_system_flags_restriction)
publication_root.save()
super(PublicationBase, cls).validate_term_model()
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()
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()
def invalidate_after_terms_set_changed(sender, instance, **kwargs):
if getattr(instance, "_during_terms_normalization", False):
return
action = kwargs.pop('action', None)
if action in ["pre_remove", "pre_add"]:
valid_pk_set = getattr(instance, "_valid_pk_set", None)
if valid_pk_set is None:
valid_pk_set = set()
setattr(instance, "_valid_pk_set", valid_pk_set)
pk_set = kwargs.pop('pk_set')
if getattr(instance, "_during_terms_validation", False):
valid_pk_set.update(pk_set)
return
normal_pk_set = set(
TermModel.objects.filter(pk__in=pk_set).exclude(
system_flags=TermModel.system_flags.
external_tagging_restriction).order_by().values_list(
'id', flat=True))
normal_pk_set.difference_update(valid_pk_set)
pk_set.clear()
pk_set.update(normal_pk_set)
if action == "pre_add":
# normalize terms set
origin_pk_set = set(instance.terms.values_list('id', flat=True))
tree = TermModel.decompress(origin_pk_set | pk_set, fix_it=False)
normal_pk_set = set(
[x.term.id for x in tree.values() if x.is_leaf])
# pk set to add
pk_set_difference = normal_pk_set - origin_pk_set
pk_set.clear()
pk_set.update(pk_set_difference)
# pk set to remove
pk_set_difference = origin_pk_set - normal_pk_set
if pk_set_difference:
instance._during_terms_normalization = True
instance.terms.remove(*list(pk_set_difference))
del instance._during_terms_normalization
if pk_set:
external_add_terms.send(sender=instance.__class__,
instance=instance,
pk_set=pk_set)
else:
if pk_set:
external_remove_terms.send(sender=instance.__class__,
instance=instance,
pk_set=pk_set)
def get_or_create_term_wrapper(
original_term,
default_name=_("Type"),
rule=TermModel.AND_RULE,
wrapped_rule=TermModel.XOR_RULE,
specification=TermModel.SPECIFICATION_MODES[0][0],
system_flags=_default_system_flags_restriction):
"""
RUS: Получает или создает термин обертку.
"""
term_parent = original_term.parent
# Compose new entity model class term slug
new_term_slug = ENTITY_CLASS_WRAPPER_TERM_SLUG_PATTERN.format(
original_term.slug)
if (term_parent is None) or (term_parent.slug != new_term_slug):
with transaction.atomic():
try: # get or create model class root term
root_term = TermModel.objects.get(slug=new_term_slug,
parent=term_parent)
except TermModel.DoesNotExist:
root_term = TermModel(slug=new_term_slug,
parent=term_parent,
name=original_term.name,
semantic_rule=rule,
specification_mode=specification,
system_flags=system_flags)
root_term.save()
# set original entity model class term to new parent
if original_term.parent != root_term:
original_term.parent = root_term
original_term.name = default_name
original_term.semantic_rule = wrapped_rule
original_term.save()
else:
root_term = term_parent
return root_term
def get_or_create_view_layouts_root():
"""
Создаем или возвращаем корневой термин представлений
"""
view_root = getattr(PageLayout, '_view_layouts_root_cache', None)
if not view_root:
try: # view layout root
view_root = TermModel.objects.get(slug=VIEW_LAYOUT_ROOT_TERM_SLUG,
parent=None)
except TermModel.DoesNotExist:
view_root = TermModel(
slug=VIEW_LAYOUT_ROOT_TERM_SLUG,
parent=None,
name=_('View'),
semantic_rule=TermModel.XOR_RULE,
system_flags=_default_layout_system_flags_restriction)
view_root.save()
PageLayout._view_layouts_root_cache = view_root
return view_root
def validate_term_model(cls):
"""
RUS: Добавляет год в модель терминов TermModel.
"""
# Устанавливаем таймаут для валидации
key = 'vldt:year_add'
need_validation = EntityModel._validate_term_model_cache.get(key, True)
if need_validation:
EntityModel._validate_term_model_cache[key] = False
system_flags = _default_system_flags_restriction
with transaction.atomic():
try: # added year
TermModel.objects.get(slug=cls.ADDED_YEAR_ROOT_TERM_SLUG)
except TermModel.DoesNotExist:
added_year = TermModel(slug=cls.ADDED_YEAR_ROOT_TERM_SLUG,
parent=None,
name=_('Added year'),
semantic_rule=TermModel.XOR_RULE,
system_flags=system_flags)
added_year.save()
super(AddedYearTermsValidationMixin, cls).validate_term_model()
def get_or_create_model_class_wrapper_term(cls):
"""
RUS: Получает или создает модель класса пользователя model_root_term.
"""
system_flags = _default_system_flags_restriction
cls_name_lower = cls.__name__.lower()
# Get original entity model class term
original_model_class_term = cls.get_entities_types(
from_cache=False)[cls_name_lower]
original_model_class_term_parent = original_model_class_term.parent
# Compose new entity model class term slug
new_model_class_term_slug = ENTITY_CLASS_WRAPPER_TERM_SLUG_PATTERN.format(
cls_name_lower)
if original_model_class_term_parent.slug != new_model_class_term_slug:
with transaction.atomic():
try: # get or create model class root term
model_root_term = TermModel.objects.get(
slug=new_model_class_term_slug,
parent=original_model_class_term_parent)
except TermModel.DoesNotExist:
model_root_term = TermModel(
slug=new_model_class_term_slug,
parent_id=original_model_class_term_parent.id,
name=force_text(cls._meta.verbose_name),
semantic_rule=TermModel.AND_RULE,
system_flags=system_flags)
model_root_term.save()
# set original entity model class term to new parent
original_model_class_term.parent = model_root_term
original_model_class_term.name = _("Type")
original_model_class_term.save()
else:
model_root_term = original_model_class_term_parent
return model_root_term
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()
def data_mart_available_terms_ids(self):
"""
Return available terms ids for current data mart and filters
"""
# дерево терминов вычисляется на этапе фильтрации, помимо витрины данных учитываются дополнительные фильтры
tree = self.context.get('initial_filter_meta', None)
if tree is None:
# при POST запросе потребуется вычислить дерево терминов, поскольку фильтрация не производится
data_mart = self.data_mart_from_request
if data_mart is not None:
tree = TermModel.decompress(data_mart.active_terms_ids)
else:
return []
# Удаляем термины с ограничением на установку извне
return [key for key, value in tree.expand().items() if not value.term.system_flags.external_tagging_restriction]
def invalidate_after_terms_set_changed(sender, instance, **kwargs):
if getattr(instance, "_during_terms_normalization", False):
return
action = kwargs.pop('action', None)
if action in ["pre_remove", "pre_add"]:
valid_pk_set = getattr(instance, "_valid_pk_set", None)
if valid_pk_set is None:
valid_pk_set = set()
setattr(instance, "_valid_pk_set", valid_pk_set)
pk_set = kwargs.pop('pk_set', None)
if getattr(instance, "_during_terms_validation", False):
valid_pk_set.update(pk_set)
return
if instance.system_flags.change_terms_restriction:
# disable updating terms set on change restriction
pk_set.clear()
return
pk_set.difference_update(valid_pk_set)
if action == "pre_add":
# normalize terms set
origin_pk_set = set(instance.terms.values_list('id', flat=True))
tree = TermModel.decompress(origin_pk_set | pk_set, fix_it=True)
normal_pk_set = set(
[x.term.id for x in tree.values() if x.is_leaf])
# pk set to add
pk_set_difference = normal_pk_set - origin_pk_set
pk_set.clear()
pk_set.update(pk_set_difference)
# pk set to remove
pk_set_difference = origin_pk_set - normal_pk_set
if pk_set_difference:
instance._during_terms_normalization = True
instance.terms.remove(*list(pk_set_difference))
del instance._during_terms_normalization
elif action in ['post_add', 'post_remove']:
# clear cache
keys = get_data_mart_all_active_terms_keys()
cache.delete_many(keys)
def validate_term_model(cls):
"""
RUS: Добавляет месяц в модель терминов TermModel. Проверяет, есть ли месяц в модели TermModel,
и при его отсутствии создает диапазон месяцев (1-12) и разбивку по месяцам в этих диапазонах.
"""
# Устанавливаем таймаут для валидации
key = 'vldt:mnth_add'
need_validation = EntityModel._validate_term_model_cache.get(key, True)
if need_validation:
EntityModel._validate_term_model_cache[key] = False
system_flags = _default_system_flags_restriction
with transaction.atomic():
try: # added month
added_month = TermModel.objects.get(
slug=cls.ADDED_MONTH_ROOT_TERM_SLUG, parent=None)
except TermModel.DoesNotExist:
added_month = TermModel(
slug=cls.ADDED_MONTH_ROOT_TERM_SLUG,
parent=None,
name=_('Added month'),
semantic_rule=TermModel.OR_RULE,
system_flags=system_flags)
added_month.save()
for i in range(1, 13):
month_key = cls.ADDED_MONTH_KEY.format(i)
with transaction.atomic():
try:
TermModel.objects.get(slug=month_key,
parent=added_month)
except TermModel.DoesNotExist:
month = TermModel(slug=month_key,
parent_id=added_month.id,
name=_(calendar.month_name[i]),
semantic_rule=TermModel.OR_RULE,
system_flags=system_flags)
month.save()
super(AddedMonthTermsValidationMixin, cls).validate_term_model()
def test_term_decompress_fix_it_true(self):
self.assertEqual(TermModel.decompress(value=[4, 5], fix_it=True), {
1: [[]],
2: []
})
def on_cache_set(key):
buf = TermModel.get_children_buffer()
old_key = buf.record(key)
if old_key != buf.empty:
cache.delete(old_key)
def filter_data_mart_pk(self, name, queryset, value):
self._data_mart_id = value
if self.data_mart_id is None:
return queryset
return queryset.filter(id__in=TermModel.decompress(self.data_mart_term_ids, fix_it=True).keys())
def validate_term_model(cls):
"""
RUS: Добавляет день в модель терминов. Проверяет, есть ли день в модели TermModel,
и при его отсутствии создает диапазон дат и разбивку по дням в этих диапазонах.
"""
# валидируем только один раз
key = 'vldt:day_add'
need_validation = EntityModel._validate_term_model_cache.get(key, True)
if need_validation:
EntityModel._validate_term_model_cache[key] = False
system_flags = _default_system_flags_restriction
with transaction.atomic():
try: # added day
added_day = TermModel.objects.get(
slug=cls.ADDED_DAY_ROOT_TERM_SLUG, parent=None)
except TermModel.DoesNotExist:
added_day = TermModel(slug=cls.ADDED_DAY_ROOT_TERM_SLUG,
parent=None,
name=_('Added day'),
semantic_rule=TermModel.OR_RULE,
system_flags=system_flags)
added_day.save()
day_ranges = ((1, 11), (11, 21), (21, 32))
for r in day_ranges: # added day range
day_range_key = cls.ADDED_DAY_RANGE_KEY.format(r[0], r[1] - 1)
with transaction.atomic():
try:
added_day_range = TermModel.objects.get(
slug=day_range_key, parent=added_day)
except TermModel.DoesNotExist:
added_day_range = TermModel(
slug=day_range_key,
parent_id=added_day.id,
name="{} - {}".format(r[0], r[1] - 1),
semantic_rule=TermModel.OR_RULE,
system_flags=system_flags)
added_day_range.save()
for i in range(r[0], r[1]): # added day
day_key = cls.ADDED_DAY_KEY.format(i)
with transaction.atomic():
try:
TermModel.objects.get(slug=day_key)
except TermModel.DoesNotExist:
day = TermModel(slug=day_key,
parent_id=added_day_range.id,
name="{:02d}".format(i),
semantic_rule=TermModel.OR_RULE,
system_flags=system_flags)
day.save()
super(AddedDayTermsValidationMixin, cls).validate_term_model()
