edu-rdm-integration 3.8.1__py3-none-any.whl → 3.9.1__py3-none-any.whl

edu_rdm_integration/collect_data/generators.py

@@ -7,7 +7,9 @@ from datetime import (
 from typing import (
     TYPE_CHECKING,
     Iterable,
+    List,
     Optional,
+    Tuple,
 )
 
 from django.apps import (
@@ -20,6 +22,9 @@ from django.db import (
 from educommon.utils.date import (
     DatesSplitter,
 )
+from educommon.utils.seqtools import (
+    make_chunks,
+)
 from m3_db_utils.models import (
     ModelEnumValue,
 )
@@ -27,6 +32,9 @@ from m3_db_utils.models import (
 from edu_rdm_integration import (
     consts,
 )
+from edu_rdm_integration.collect_data.const import (
+    ALL_UNITS_IN_COMMAND,
+)
 from edu_rdm_integration.consts import (
     DATE_FORMAT,
 )
@@ -108,7 +116,8 @@ class BaseFirstCollectModelsDataCommandsGenerator:
 
         self.splitter = (
             DatesSplitter(split_by=split_by, split_mode=split_mode, split_by_quantity=split_by_quantity)
-            if split_by else None
+            if split_by
+            else None
         )
 
         self.batch_size = batch_size
@@ -116,8 +125,7 @@ class BaseFirstCollectModelsDataCommandsGenerator:
         self.generation_id = uuid.uuid4()
 
         # Правую дату нужно увеличивать на одну секунду, т.к. подрезались миллисекунды
-        self.get_logs_periods_sql = (
-            """
+        self.get_logs_periods_sql = """
             select min(created),
                    max(created)  + interval '1 second',
                    row_batched
@@ -140,22 +148,18 @@ class BaseFirstCollectModelsDataCommandsGenerator:
             group by row_batched
             order by row_batched;
             """
-        )
 
-        self.ordered_rows_query = (
-            """
+        self.ordered_rows_query = """
             select distinct date_trunc('second', created) as created
             from "{table_name}"
             where created between '{period_started_at}' and '{period_ended_at}'
             """
-        )
 
     def generate(self) -> list:
         """Генерирует список данных для формирования команд для сбора данных РВД."""
         params_for_commands = []
 
         for rdm_model in self.regional_data_mart_models:
-
             # Если не заполнен creating_trigger_models и plugins_info, то список не формируется
             if not rdm_model.creating_trigger_models and not getattr(rdm_model, 'plugins_info', None):
                 continue
@@ -224,3 +228,63 @@ class BaseFirstCollectModelsDataCommandsGenerator:
                     )
 
         return params_for_commands
+
+
+class FirstCollectModelsDataCommandsGenerator(BaseFirstCollectModelsDataCommandsGenerator):
+    """Генерирует команды collect_models_by_generating_logs."""
+
+    def generate_with_split(
+        self,
+        by_institutes: bool,
+        institute_ids: Optional[Iterable[int]],
+        institute_count: Optional[int],
+        actual_institute_ids: Iterable[int],
+    ):
+        """Генерирует команды с разделением по организациям.
+
+        Args:
+            by_institutes: Разделение по организациям.
+            institute_ids: ID организаций по которым генерируются команды.
+            institute_count: Разделение по кол-ву организаций.
+            actual_institute_ids: Текущие организации в системе.
+
+        Returns:
+            Cписок данных для формирования команд.
+        """
+
+        result_commands: List[dict] = []
+        institute_ids_chunks: Tuple[Optional[Iterable]] = (None,)
+
+        raw_commands = self.generate()
+
+        if by_institutes and not institute_ids:
+            # Если указано разбиение по организациям, без перечисления организаций:
+            if institute_count == ALL_UNITS_IN_COMMAND:
+                # Если указано -1, то в команде будут указаны все
+                # существующие организации в параметре institute_ids.
+                institute_ids_chunks = ((),)
+            else:
+                # Если значение, отличное от -1, то в каждой команде будет
+                # указано institute_count кол-во организаций в параметре institute_ids.
+                institute_ids_chunks = make_chunks(
+                    iterable=actual_institute_ids,
+                    size=institute_count,
+                    is_list=True,
+                )
+        elif institute_ids:
+            # Если указано разбиение по организациям и/или перечислены организации:
+            if institute_count == ALL_UNITS_IN_COMMAND:
+                institute_ids_chunks = (institute_ids,)
+            else:
+                institute_ids_chunks = make_chunks(
+                    iterable=institute_ids,
+                    size=institute_count,
+                    is_list=True,
+                )
+
+        # Переформируются команды с учетом организаций и их кол-ва для каждой команды:
+        for institute_ids_chunk in institute_ids_chunks:
+            for command in raw_commands:
+                result_commands.append({**command, 'institute_ids': institute_ids_chunk})
+
+        return result_commands

edu_rdm_integration/collect_data/ui.py

@@ -0,0 +1,246 @@
+from typing import (
+    Any,
+    Dict,
+)
+
+from m3_ext.ui.fields.simple import (
+    ExtCheckBox,
+    ExtComboBox,
+    ExtDateTimeField,
+    ExtDisplayField,
+    ExtNumberField,
+    ExtStringField,
+)
+from m3_ext.ui.misc import (
+    ExtDataStore,
+)
+from objectpack.ui import (
+    allow_blank,
+)
+
+from educommon.objectpack.ui import (
+    BaseEditWindow,
+)
+from educommon.utils.date import (
+    DatesSplitter,
+)
+
+from edu_rdm_integration.collect_and_export_data.ui import (
+    BaseCreateCommandWindow,
+)
+from edu_rdm_integration.collect_data.const import (
+    ALL_UNITS_IN_COMMAND,
+)
+from edu_rdm_integration.consts import (
+    BATCH_SIZE,
+)
+from edu_rdm_integration.models import (
+    RegionalDataMartModelEnum,
+)
+
+
+class CreateCollectCommandWindow(BaseCreateCommandWindow):
+    """Окно создания команды сбора данных модели РВД."""
+
+    def _init_components(self):
+        """Инициализация компонентов."""
+
+        super()._init_components()
+
+        model = ExtComboBox(
+            name='model_id',
+            label='Модель',
+            display_field='model',
+            anchor='100%',
+            editable=False,
+            trigger_action_all=True,
+            allow_blank=False,
+        )
+        model.set_store(
+            ExtDataStore((idx, key) for idx, key in enumerate(RegionalDataMartModelEnum.get_model_enum_keys()))
+        )
+        logs_period_started_at = ExtDateTimeField(
+            name='logs_period_started_at',
+            label='Начало периода',
+            anchor='100%',
+            allow_blank=False,
+        )
+        logs_period_ended_at = ExtDateTimeField(
+            name='logs_period_ended_at',
+            label='Конец периода',
+            anchor='100%',
+            allow_blank=False,
+        )
+        split_by = ExtComboBox(
+            name='split_by',
+            display_field='split_by',
+            label='Единица подпериода',
+            anchor='100%',
+            editable=True,
+            trigger_action_all=True,
+        )
+        split_by.set_store(ExtDataStore(enumerate(DatesSplitter.get_split_by_modes())))
+        split_by_quantity = ExtNumberField(
+            name='split_by_quantity',
+            label='Размер подпериода',
+            allow_blank=False,
+            allow_decimals=False,
+            allow_negative=False,
+            anchor='100%',
+            value=1,
+        )
+        split_mode = ExtComboBox(
+            name='split_mode',
+            display_field='split_mode',
+            label='Режим разбиения на подпериоды',
+            anchor='100%',
+            editable=False,
+            allow_blank=True,
+            trigger_action_all=True,
+            value=DatesSplitter.WW_MODE,
+        )
+        split_mode.set_store(
+            ExtDataStore(enumerate(DatesSplitter.get_modes())),
+        )
+        batch_size = ExtNumberField(
+            name='batch_size',
+            label='Размер чанка',
+            allow_blank=False,
+            allow_decimals=False,
+            allow_negative=False,
+            anchor='100%',
+            value=BATCH_SIZE,
+        )
+        by_institutes = ExtCheckBox(
+            anchor='100%',
+            label='Разбить по организациям',
+            name='by_institutes',
+        )
+        institute_ids = ExtStringField(
+            label='id организаций',
+            name='institute_ids',
+            allow_blank=True,
+            anchor='100%',
+        )
+        institute_count = ExtNumberField(
+            name='institute_count',
+            label='Кол-во организаций в одной команде',
+            allow_decimals=False,
+            anchor='100%',
+            min_value=ALL_UNITS_IN_COMMAND,
+            value=ALL_UNITS_IN_COMMAND,
+        )
+        hint_text = ExtDisplayField(
+            value=(
+                f'Данные можно разбить или по "{batch_size.label}" или по "{split_by.label}"! '
+                f'Если выбрать оба варианта, то будет выбрано разбиение по "{split_by.label}".'
+            ),
+            read_only=True,
+            label_style='width: 0px',
+            style={'text-align': 'center'},
+        )
+        just_or_hint_text = ExtDisplayField(
+            label='или',
+        )
+        self.items_ = (
+            model,
+            logs_period_started_at,
+            logs_period_ended_at,
+            by_institutes,
+            institute_ids,
+            institute_count,
+            hint_text,
+            batch_size,
+            just_or_hint_text,
+            split_by,
+            split_by_quantity,
+            split_mode,
+        )
+
+
+class DetailCollectCommandWindow(BaseEditWindow):
+    """Окно просмотра команды сбора данных модели РВД."""
+
+    def set_params(self, params: Dict[str, Any]) -> None:
+        """Устанавливает параметры окна."""
+
+        super().set_params(params)
+
+        self.height = 'auto'
+        self.logs_link_field.value = params.get('log_url', '')
+
+    def _init_components(self) -> None:
+        """Инициализирует компоненты окна."""
+
+        super()._init_components()
+
+        self.model_field = ExtStringField(
+            name='model_id',
+            label='Модель',
+            anchor='100%',
+        )
+        self.created_field = ExtDateTimeField(
+            name='created',
+            label='Дата создания',
+            anchor='100%',
+        )
+        self.generation_id_field = ExtStringField(
+            name='generation_id',
+            label='Идентификатор генерации',
+            anchor='100%',
+        )
+        self.task_id_field = ExtStringField(
+            name='task_id',
+            label='Идентификатор задачи',
+            anchor='100%',
+        )
+        self.institute_ids_field = ExtStringField(
+            name='institute_ids',
+            label='Идентификаторы организаций',
+            anchor='100%',
+        )
+        self.status_field = ExtStringField(
+            name='stage.status.key',
+            label='Статус сбора',
+            anchor='100%',
+        )
+        self.started_at_field = ExtDateTimeField(
+            name='stage.started_at',
+            label='Время начала сбора',
+            anchor='100%',
+        )
+        self.logs_link_field = ExtDisplayField(
+            name='log_url',
+            label='Ссылка на логи',
+            anchor='100%',
+        )
+        self.logs_period_started_at_field = ExtDateTimeField(
+            name='logs_period_started_at',
+            label='Начало периода',
+            anchor='100%',
+        )
+        self.logs_period_ended_at_field = ExtDateTimeField(
+            name='logs_period_ended_at',
+            label='Конец периода',
+            anchor='100%',
+        )
+
+    def _do_layout(self) -> None:
+        """Располагает компоненты окна."""
+
+        super()._do_layout()
+
+        self.form.items.extend(
+            (
+                self.model_field,
+                self.created_field,
+                self.generation_id_field,
+                self.task_id_field,
+                self.institute_ids_field,
+                self.status_field,
+                self.started_at_field,
+                self.logs_link_field,
+                self.logs_period_started_at_field,
+                self.logs_period_ended_at_field,
+            )
+        )

edu_rdm_integration/enum_register/mixins.py

@@ -73,13 +73,14 @@ class EntityEnumRegisterMixin(BaseEnumRegisterMixin):
 
     # TODO EDUSCHL-20938 Удалить в рамках задачи
     @classmethod
-    def get_additional_model_enums(cls) -> Optional[tuple[ModelEnumValue]]:
+    def get_additional_model_enums(cls) -> tuple[ModelEnumValue, ...]:
         """Возвращает кортеж значений модели-перечисления основной модели сущности.
 
         В классе определяется поле additional_model_enums или данный метод.
 
         !!! Временное решение. Будет удалено в рамках EDUSCHL-20938.
         """
+        return ()
 
 
 class ModelEnumRegisterMixin(BaseEnumRegisterMixin):

edu_rdm_integration/export_data/actions.py

@@ -0,0 +1,291 @@
+from functools import (
+    partial,
+)
+
+from django.db.models import (
+    F,
+    Func,
+    IntegerField,
+    OuterRef,
+    Q,
+    Subquery,
+)
+from django.db.transaction import (
+    atomic,
+)
+from m3.actions.results import (
+    OperationResult,
+)
+from objectpack.actions import (
+    BaseAction,
+)
+
+from educommon.async_task.actions import (
+    RevokeAsyncTaskAction,
+)
+from educommon.async_task.models import (
+    AsyncTaskStatus,
+)
+from educommon.utils.ui import (
+    ChoicesFilter,
+    DatetimeFilterCreator,
+)
+
+from edu_rdm_integration.collect_and_export_data.actions import (
+    BaseCommandProgressPack,
+    BaseStartTaskAction,
+)
+from edu_rdm_integration.collect_and_export_data.models import (
+    EduRdmExportDataCommandProgress,
+)
+from edu_rdm_integration.enums import (
+    CommandType,
+)
+from edu_rdm_integration.export_data.generators import (
+    BaseFirstExportEntitiesDataCommandsGenerator,
+)
+from edu_rdm_integration.export_data.ui import (
+    CreateExportCommandWindow,
+    DetailExportCommandWindow,
+    ExportCommandProgressListWindow,
+)
+from edu_rdm_integration.helpers import (
+    make_download_link,
+)
+from edu_rdm_integration.models import (
+    ExportingDataStageStatus,
+    ExportingDataSubStage,
+    ExportingDataSubStageStatus,
+    RegionalDataMartEntityEnum,
+)
+
+
+class BaseExportingDataProgressPack(BaseCommandProgressPack):
+    """Базоый пак команд экспорта данных сущностей РВД."""
+
+    model = EduRdmExportDataCommandProgress
+    title = 'Экспорт данных сущностей РВД'
+
+    add_window = CreateExportCommandWindow
+    edit_window = DetailExportCommandWindow
+    list_window = ExportCommandProgressListWindow
+
+    need_check_permission = True
+
+    select_related = ['task', 'task__status']
+
+    list_sort_order = ('-created', 'entity__order_number', 'generation_id')
+    date_filter = partial(DatetimeFilterCreator, model)
+
+    columns = [
+        {
+            'data_index': 'entity.pk',
+            'header': 'Сущность',
+            'sortable': True,
+            'filter': ChoicesFilter(
+                choices=[(key, key) for key in RegionalDataMartEntityEnum.get_model_enum_keys()],
+                parser=str,
+                lookup=lambda key: Q(entity=key) if key else Q(),
+            ),
+        },
+        {
+            'data_index': 'task.status.title',
+            'header': 'Статус асинхронной задачи',
+            'sortable': True,
+            'filter': ChoicesFilter(
+                choices=[(value.key, value.title) for value in AsyncTaskStatus.get_model_enum_values()],
+                parser=str,
+                lookup='task__status_id',
+            ),
+        },
+        {
+            'data_index': 'type',
+            'header': 'Тип команды',
+            'filter': ChoicesFilter(
+                choices=CommandType.get_choices(),
+                parser=int,
+                lookup='type',
+            ),
+            'width': 60,
+        },
+        {
+            'data_index': 'finished_sub_stages',
+            'header': 'Подэтапов <br> выполнено',
+            'width': 50,
+        },
+        {
+            'data_index': 'ready_sub_stages',
+            'header': 'Подэтапов <br> подготовлено <br> к выгрузке',
+            'width': 50,
+        },
+        {
+            'data_index': 'process_errors_sub_stages',
+            'header': 'Подэтапов <br> с ошибкой <br> обработки <br> запроса',
+            'width': 50,
+        },
+        {
+            'data_index': 'stage.status.key',
+            'header': 'Статус экспорта',
+            'sortable': True,
+            'filter': ChoicesFilter(
+                choices=[(key, key) for key in ExportingDataStageStatus.get_model_enum_keys()],
+                parser=str,
+                lookup=lambda key: Q(stage__status=key) if key else Q(),
+            ),
+            'width': 50,
+        },
+        {
+            'data_index': 'stage.started_at',
+            'header': 'Время начала экспорта',
+            'sortable': True,
+            'filter': date_filter('stage__started_at').filter,
+        },
+        {
+            'data_index': 'log_url',
+            'header': 'Ссылка на логи',
+            'width': 60,
+        },
+        {
+            'data_index': 'period_started_at',
+            'header': 'Начало периода',
+            'sortable': True,
+            'filter': date_filter('period_started_at').filter,
+        },
+        {
+            'data_index': 'period_ended_at',
+            'header': 'Конец периода',
+            'sortable': True,
+            'filter': date_filter('period_ended_at').filter,
+        },
+        {
+            'data_index': 'generation_id',
+            'header': 'ID генерации',
+            'sortable': True,
+        },
+        {
+            'data_index': 'created',
+            'header': 'Дата создания',
+            'sortable': True,
+        },
+    ]
+
+    _start_task_action_cls: BaseStartTaskAction
+    _revoke_task_action_cls: RevokeAsyncTaskAction
+
+    def __init__(self):
+        super().__init__()
+
+        self.start_task_action = self._start_task_action_cls()
+        self.revoke_task_action = self._revoke_task_action_cls()
+        self.prepare_sub_stage_for_export_action = PrepareSubStageForExportAction()
+
+        self.actions.extend((self.start_task_action, self.revoke_task_action, self.prepare_sub_stage_for_export_action))
+
+    def get_list_window_params(self, params, request, context):
+        """Получает параметры окна списка."""
+        params = super().get_list_window_params(params, request, context)
+
+        params['revoke_url'] = self.revoke_task_action.get_absolute_url()
+        params['start_task_url'] = self.start_task_action.get_absolute_url()
+        params['sub_stage_for_export_url'] = self.prepare_sub_stage_for_export_action.get_absolute_url()
+
+        return params
+
+    def declare_context(self, action):
+        """Декларирует контекст экшна."""
+        context = super().declare_context(action)
+
+        if action is self.save_action:
+            context['period_started_at'] = {'type': 'datetime'}
+            context['period_ended_at'] = {'type': 'datetime'}
+            context['batch_size'] = {'type': 'int'}
+        elif action in (self.start_task_action, self.prepare_sub_stage_for_export_action):
+            context['commands'] = {'type': 'int_list'}
+            context['queue_level'] = {'type': int, 'default': None}
+        elif action is self.revoke_task_action:
+            context['async_task_ids'] = {'type': 'str', 'default': ''}
+
+        return context
+
+    def get_rows_query(self, request, context):
+        """Возвращает выборку из БД для получения списка данных."""
+        query = super().get_rows_query(request, context)
+
+        return query.annotate(
+            finished_sub_stages=Subquery(
+                ExportingDataSubStage.objects.filter(
+                    stage_id=OuterRef('stage_id'),
+                    status=ExportingDataSubStageStatus.FINISHED.key,
+                )
+                .annotate(
+                    finished_count=Func(F('id'), function='Count'),
+                )
+                .values('finished_count'),
+            ),
+            ready_sub_stages=Subquery(
+                ExportingDataSubStage.objects.filter(
+                    stage_id=OuterRef('stage_id'),
+                    status=ExportingDataSubStageStatus.READY_FOR_EXPORT.key,
+                )
+                .annotate(
+                    ready_count=Func(F('id'), function='Count', output_field=IntegerField()),
+                )
+                .values('ready_count'),
+            ),
+            process_errors_sub_stages=Subquery(
+                ExportingDataSubStage.objects.filter(
+                    stage_id=OuterRef('stage_id'),
+                    status=ExportingDataSubStageStatus.PROCESS_ERROR.key,
+                )
+                .annotate(process_errors_count=Func(F('id'), function='Count', output_field=IntegerField()))
+                .values('process_errors_count'),
+            ),
+        )
+
+    def prepare_row(self, obj, request, context):
+        """Подготовка данных для отображения в реестре."""
+        obj.log_url = make_download_link(obj.logs_link)
+
+        return obj
+
+    @atomic
+    def save_row(self, obj, create_new, request, context, *args, **kwargs):
+        """Сохраняет объекты."""
+        commands = BaseFirstExportEntitiesDataCommandsGenerator(
+            entities=[obj.entity_id],
+            period_started_at=context.period_started_at,
+            period_ended_at=context.period_ended_at,
+            batch_size=context.batch_size,
+        ).generate()
+
+        for command in commands:
+            obj = self.model(
+                entity_id=obj.entity_id,
+                period_started_at=command['period_started_at'],
+                period_ended_at=command['period_ended_at'],
+                generation_id=command['generation_id'],
+                type=CommandType.MANUAL,
+            )
+            super().save_row(obj, create_new, request, context, *args, **kwargs)
+
+
+class PrepareSubStageForExportAction(BaseAction):
+    """Смена статусов у подэтапов для переотправки."""
+
+    def run(self, request, context):
+        """Обновление статусов подэтапов не принятых витриной."""
+        command_ids = context.commands
+        stage_ids = EduRdmExportDataCommandProgress.objects.filter(id__in=command_ids).values_list(
+            'stage_id', flat=True
+        )
+
+        updated_count = ExportingDataSubStage.objects.filter(
+            stage_id__in=stage_ids,
+            status=ExportingDataSubStageStatus.PROCESS_ERROR.key,
+        ).update(status=ExportingDataSubStageStatus.READY_FOR_EXPORT.key)
+        if updated_count:
+            message = f'Будет переотправлено {updated_count} подэтапов.'
+        else:
+            message = 'Подэтапов для переотправления не найдено.'
+
+        return OperationResult(success=True, message=message)