edu-rdm-integration 3.8.0__py3-none-any.whl → 3.9.0__py3-none-any.whl

edu_rdm_integration/collect_and_export_data/actions.py

@@ -0,0 +1,121 @@
+from django.conf import (
+    settings,
+)
+from m3 import (
+    OperationResult,
+)
+from m3_ext.ui.containers import (
+    ExtGridCheckBoxSelModel,
+)
+from objectpack.actions import (
+    BaseAction,
+    BaseWindowAction,
+    ObjectPack,
+)
+from objectpack.filters import (
+    ColumnFilterEngine,
+)
+
+from edu_rdm_integration.collect_and_export_data.ui import (
+    CommandQueueSelectWindow,
+)
+from edu_rdm_integration.collect_and_export_data.utils import (
+    BaseTaskStarter,
+)
+from edu_rdm_integration.export_data.ui import (
+    CommandProgressListWindow,
+)
+from edu_rdm_integration.helpers import (
+    make_download_link,
+)
+
+
+class BaseCommandProgressPack(ObjectPack):
+    """Базовый пак прогресса выполнения команд сбора/экспорта данных."""
+
+    list_window = CommandProgressListWindow
+    can_delete = False
+
+    select_related = ['task', 'stage__status']
+
+    filter_engine_clz = ColumnFilterEngine
+
+    def __init__(self):
+        super().__init__()
+
+        self.queue_select_win_action = QueueLevelSelectWinAction()
+
+        self.actions.append(self.queue_select_win_action)
+
+    def get_list_window_params(self, params, request, context):
+        """Получает параметры окна списка."""
+        params = super().get_list_window_params(params, request, context)
+
+        params['queue_select_win_url'] = self.queue_select_win_action.get_absolute_url()
+
+        return params
+
+    def get_edit_window_params(self, params, request, context):
+        """Возвращает словарь параметров, которые будут переданы окну редактирования."""
+        params = super().get_edit_window_params(params, request, context)
+
+        if not params['create_new']:
+            params['read_only'] = True
+            obj = params['object']
+            params['log_url'] = make_download_link(obj.logs_link)
+
+        return params
+
+    def configure_grid(self, grid, *args, **kwargs):
+        """Конфигурирует грид."""
+        super().configure_grid(grid, *args, **kwargs)
+
+        grid.sm = ExtGridCheckBoxSelModel()
+        grid.top_bar.button_new.text = 'Сгенерировать команды'
+        grid.top_bar.button_edit.text = 'Просмотр'
+        grid.top_bar.button_edit.icon_cls = 'icon-application-view-detail'
+        grid.context_menu_row.menuitem_edit.text = 'Просмотр'
+        grid.context_menu_row.menuitem_edit.icon_cls = 'icon-application-view-detail'
+
+    def extend_menu(self, menu):
+        """Расширяет главное меню."""
+        if settings.RDM_MENU_ITEM:
+            return menu.SubMenu(
+                'Администрирование',
+                menu.SubMenu(
+                    'Региональная витрина данных',
+                    menu.Item(
+                        self.title,
+                        self.list_window_action,
+                    ),
+                    icon='menu-dicts-16',
+                ),
+            )
+
+
+class BaseStartTaskAction(BaseAction):
+    """
+    Базовый экшн создания асинхронных задач для выгрузки РВД.
+    """
+
+    url: str = None
+
+    task_starter: BaseTaskStarter = None
+
+    def run(self, request, context):
+        """Непосредственное исполнение запроса."""
+        queue_level = getattr(context, 'queue_level', None)
+        result = self.task_starter().run(command_ids=context.commands, queue_level=queue_level)  # noqa pylint: disable=not-callable
+
+        return OperationResult(
+            success=True,
+            message=result,
+        )
+
+
+class QueueLevelSelectWinAction(BaseWindowAction):
+    """Экшен окна выбора очереди для запуска ручной команды собра/выгрузки."""
+
+    def create_window(self):
+        """Создание окна."""
+        self.win = CommandQueueSelectWindow()

edu_rdm_integration/collect_and_export_data/ui.py

@@ -0,0 +1,137 @@
+from typing import (
+    Iterable,
+)
+
+from m3_ext.ui import (
+    all_components as ext,
+)
+from m3_ext.ui.icons import (
+    Icons,
+)
+from objectpack.ui import (
+    BaseEditWindow,
+    BaseWindow,
+    ComboBoxWithStore,
+)
+
+from educommon.objectpack.ui import (
+    BaseListWindow,
+)
+from educommon.utils.ui import (
+    append_template_globals,
+)
+
+from edu_rdm_integration.enums import (
+    EntityLevelQueueTypeEnum,
+)
+
+
+class CommandProgressListWindow(BaseListWindow):
+    """Окно списка команд на сбор/экспорт данных."""
+
+    def set_params(self, params):
+        """Устанавливает параметры окна."""
+        super().set_params(params)
+
+        self.maximized = True
+        append_template_globals(self, 'ui-js/start-task.js')
+        append_template_globals(self, 'ui-js/async-task-revoke.js')
+
+        self.start_task_url = params['start_task_url']
+        self.revoke_url = params['revoke_url']
+        self.queue_select_win_url = params['queue_select_win_url']
+
+    def _init_components(self):
+        """Инициализирует компоненты окна."""
+        super()._init_components()
+
+        self.start_task_button = ext.ExtButton(
+            text='Запустить команду',
+            icon_cls=Icons.APPLICATION_GO,
+            handler='startTask',
+        )
+        self.revoke_task_button = ext.ExtButton(
+            text='Отменить',
+            icon_cls=Icons.CANCEL,
+            handler='revokeTask',
+        )
+
+    def _do_layout(self):
+        """Располагает компоненты окна."""
+        super()._do_layout()
+
+        self.grid.top_bar.items.insert(1, self.start_task_button)
+        self.grid.top_bar.items.append(self.revoke_task_button)
+
+
+class BaseCreateCommandWindow(BaseEditWindow):
+    """Базовое окно создания команды на сбор/экспорт данных."""
+
+    def _init_components(self):
+        """Инициализация компонентов."""
+        super()._init_components()
+
+        # Поля, которые нужно добавить на форму:
+        self.items_: Iterable = ()
+
+    def _do_layout(self):
+        """Расположение компонентов."""
+        super()._do_layout()
+
+        self.form.items.extend(self.items_)
+
+    def set_params(self, params):
+        """Параметры окна."""
+        super().set_params(params)
+
+        self.form.label_width = 150
+        self.width = 400
+        self.height = 'auto'
+
+
+class CommandQueueSelectWindow(BaseWindow):
+    """Окно выбора очереди для запуска периодических задач команд."""
+
+    def _init_components(self):
+        """Инициализация компонентов."""
+        super()._init_components()
+
+        self.queue_level_combobox = ComboBoxWithStore(
+            label='Очередь выполнения команд',
+            name='queue_level',
+            data=EntityLevelQueueTypeEnum.get_choices(),
+            value=EntityLevelQueueTypeEnum.BASE,
+            allow_blank=False,
+            editable=False,
+            anchor='100%',
+        )
+        self.close_btn = self.btn_close = ext.ExtButton(
+            name='close_btn',
+            text='Закрыть',
+            handler='function(){Ext.getCmp("%s").close();}' % self.client_id,
+        )
+        self.start_task_button = ext.ExtButton(
+            name='start_task',
+            text='Запустить команду',
+            handler='function(){ win.fireEvent("closed_ok");}',
+        )
+
+    def _do_layout(self):
+        """Расположение компонентов."""
+        super()._do_layout()
+
+        self.items.append(self.queue_level_combobox)
+        self.buttons.extend(
+            (
+                self.start_task_button,
+                self.btn_close,
+            )
+        )
+
+    def set_params(self, params):
+        """Параметры окна."""
+        super().set_params(params)
+
+        self.width = 400
+        self.height = 'auto'
+        self.title = 'Очередь для выполнения команды'

edu_rdm_integration/collect_and_export_data/utils.py

@@ -1,6 +1,26 @@
+from abc import (
+    ABC,
+    abstractmethod,
+)
+from typing import (
+    Dict,
+    Iterable,
+    Optional,
+)
+
+from django.db.models import (
+    QuerySet,
+)
+
+from educommon.async_task.exceptions import (
+    TaskUniqueException,
+)
 from educommon.async_task.models import (
     AsyncTaskType,
 )
+from educommon.async_task.tasks import (
+    AsyncTask,
+)
 
 from edu_rdm_integration.collect_and_export_data.models import (
     EduRdmCollectDataCommandProgress,
@@ -12,6 +32,9 @@ from edu_rdm_integration.collect_data.collect import (
 from edu_rdm_integration.consts import (
     TASK_QUEUE_NAME,
 )
+from edu_rdm_integration.enums import (
+    EntityLevelQueueTypeEnum,
+)
 from edu_rdm_integration.export_data.export import (
     ExportEntitiesData,
 )
@@ -92,3 +115,110 @@ class ExportCommandMixin:
 
         if command:
             save_command_log_link(command, log_dir)
+
+
+class BaseTaskProgressUpdater(ABC):
+    """Базовый класс, который обновляет данные в таблицах, хранящих команды сбора/экспорта."""
+
+    @property
+    @abstractmethod
+    def update_model(self):
+        """
+        Основная модель для обновления.
+
+        Необходимо задать в дочернем классе.
+        """
+
+    @property
+    @abstractmethod
+    def async_model(self):
+        """
+        Модель асинхронных задач.
+
+        Необходимо задать в дочернем классе.
+        """
+
+    def set_async_task(self, commands_to_update: Dict[EduRdmCollectDataCommandProgress, str]) -> None:
+        """Устанавливает ссылку на асинхронную задачу."""
+        for command, task_uuid in commands_to_update.items():
+            command.task_id = task_uuid
+
+        self.update_model.objects.bulk_update(
+            commands_to_update,
+            ['task_id'],
+        )
+
+    def set_stage(self, command_id: int, stage_id: int) -> None:
+        """Устанавливает ссылку на stage."""
+        self.update_model.objects.filter(
+            id=command_id,
+        ).update(
+            stage_id=stage_id,
+        )
+
+
+class BaseTaskStarter(ABC):
+    """Запускает асинхронные задачи."""
+
+    updater: BaseTaskProgressUpdater = None
+    async_task: AsyncTask = None
+    model_only_fields: Iterable[str] = ()
+
+    def run(self, command_ids: Iterable[int], queue_level: Optional[int] = None) -> str:
+        """Создает задачи и ставит их в очередь."""
+        commands_to_update = {}
+        skipped_commands_count = 0
+        commands = self._get_commands(command_ids)
+        queue_name = None
+
+        if queue_level:
+            queue_name = EntityLevelQueueTypeEnum.get_queue_name(level=queue_level)
+
+        if not queue_name:
+            queue_name = TASK_QUEUE_NAME
+
+        for command in commands:
+            if command.task_id:
+                # Повторный запуск команды не допускается
+                skipped_commands_count += 1
+                continue
+
+            try:
+                async_result = self.async_task().apply_async(  # noqa pylint: disable=not-callable
+                    args=None,
+                    queue=queue_name,
+                    routing_key=queue_name,
+                    kwargs={
+                        'command_id': command.id,
+                    },
+                    lock_data={
+                        'lock_params': {
+                            'command_id': f'{self.updater.update_model.__name__}_{command.id}',
+                        },
+                    },
+                )
+            except TaskUniqueException:
+                skipped_commands_count += 1
+                continue
+            else:
+                commands_to_update[command] = async_result.task_id
+
+        if commands_to_update:
+            self.updater().set_async_task(commands_to_update)  # noqa pylint: disable=not-callable
+
+        message = f'Поставлено задач в очередь: {len(commands_to_update)} из {len(commands)}.'
+        if skipped_commands_count:
+            message += (
+                f' Кол-во задач, которые были запущены ранее: {skipped_commands_count}. '
+                'Однажды запущенные задачи не могут быть запущены снова!'
+            )
+
+        return message
+
+    def _get_commands(self, command_ids: Iterable[int]) -> 'QuerySet':
+        """Возвращает Queryset команд для создания задач."""
+        return self.updater.update_model.objects.filter(
+            id__in=command_ids,
+        ).only(
+            *self.model_only_fields,
+        )

edu_rdm_integration/collect_data/actions.py

@@ -0,0 +1,276 @@
+from functools import (
+    partial,
+)
+
+from django.db.models import (
+    F,
+    Func,
+    OuterRef,
+    Q,
+    Subquery,
+)
+from django.db.transaction import (
+    atomic,
+)
+from m3.actions.exceptions import (
+    ApplicationLogicException,
+)
+
+from educommon.async_task.actions import (
+    RevokeAsyncTaskAction,
+)
+from educommon.async_task.models import (
+    AsyncTaskStatus,
+)
+from educommon.utils.conversion import (
+    int_or_none,
+)
+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 (
+    EduRdmCollectDataCommandProgress,
+)
+from edu_rdm_integration.collect_data.generators import (
+    FirstCollectModelsDataCommandsGenerator,
+)
+from edu_rdm_integration.collect_data.ui import (
+    CreateCollectCommandWindow,
+    DetailCollectCommandWindow,
+)
+from edu_rdm_integration.enums import (
+    CommandType,
+)
+from edu_rdm_integration.helpers import (
+    make_download_link,
+)
+from edu_rdm_integration.models import (
+    CollectingDataStageStatus,
+    CollectingDataSubStageStatus,
+    CollectingExportedDataSubStage,
+    RegionalDataMartModelEnum,
+)
+
+
+class BaseCollectingDataProgressPack(BaseCommandProgressPack):
+    """Базовый пак команд сбора данных моделей РВД."""
+
+    title = 'Сбор данных моделей РВД'
+    model = EduRdmCollectDataCommandProgress
+
+    add_window = CreateCollectCommandWindow
+    edit_window = DetailCollectCommandWindow
+
+    need_check_permission = True
+
+    select_related = ['task', 'task__status']
+
+    list_sort_order = ('-created', 'model__order_number', 'generation_id')
+    date_filter = partial(DatetimeFilterCreator, model)
+
+    columns = [
+        {
+            'data_index': 'model.pk',
+            'header': 'Модель',
+            'sortable': True,
+            'filter': ChoicesFilter(
+                choices=[(key, key) for key in RegionalDataMartModelEnum.get_model_enum_keys()],
+                parser=str,
+                lookup=lambda key: Q(model=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': 'ready_to_export_sub_stages',
+            'header': 'Подэтапов выполнено',
+            'width': 50,
+        },
+        {
+            'data_index': 'stage.status.key',
+            'header': 'Статус сбора',
+            'sortable': True,
+            'filter': ChoicesFilter(
+                choices=[(key, key) for key in CollectingDataStageStatus.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': 'logs_period_started_at',
+            'header': 'Начало периода',
+            'sortable': True,
+            'filter': date_filter('logs_period_started_at').filter,
+        },
+        {
+            'data_index': 'logs_period_ended_at',
+            'header': 'Конец периода',
+            'sortable': True,
+            'filter': date_filter('logs_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.actions.extend(
+            (
+                self.start_task_action,
+                self.revoke_task_action,
+            )
+        )
+
+    def get_list_window_params(self, params, request, context):
+        """Получает параметры окна списка."""
+
+        params = super().get_list_window_params(params, request, context)
+
+        params['start_task_url'] = self.start_task_action.get_absolute_url()
+        params['revoke_url'] = self.revoke_task_action.get_absolute_url()
+
+        return params
+
+    def declare_context(self, action):
+        """Объявление контекста."""
+
+        context = super().declare_context(action)
+
+        if action is self.save_action:
+            context['logs_period_started_at'] = context['logs_period_ended_at'] = {'type': 'datetime'}
+            context['split_by_quantity'] = context['batch_size'] = {'type': 'int_or_none', 'default': None}
+            context['institute_count'] = {'type': 'int'}
+            context['split_by'] = context['split_mode'] = {'type': 'str', 'default': None}
+            context['by_institutes'] = {'type': 'boolean', 'default': False}
+            context['institute_ids'] = {'type': 'int_list'}
+        elif action is self.start_task_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)
+
+        # Необходимо также рассчитать прогресс сбора:
+        query = query.annotate(
+            ready_to_export_sub_stages=Subquery(
+                CollectingExportedDataSubStage.objects.filter(
+                    stage_id=OuterRef('stage_id'),
+                    status_id=CollectingDataSubStageStatus.READY_TO_EXPORT.key,
+                )
+                .annotate(ready_to_export_sub_stages=Func(F('id'), function='Count'))
+                .values('ready_to_export_sub_stages')
+            )
+        )
+
+        return query
+
+    def prepare_row(self, obj, request, context):
+        """Подготовка данных для отображения в реестре."""
+        obj.log_url = make_download_link(obj.logs_link)
+
+        return obj
+
+    def _get_actual_institute_ids(self):
+        """Возвращает кортеж из идентификаторов организаций, данные по которым можно собрать."""
+        raise NotImplementedError
+
+    @atomic
+    def save_row(self, obj, create_new, request, context, *args, **kwargs):
+        """
+        Сохраняет объект.
+
+        Переопределено, т.к. на основе полученных параметров от клиента,
+        необходимо сформировать команды на сбор и их сохранить в модели.
+        """
+        batch_size = int_or_none(context.batch_size)
+        if not context.split_by and not batch_size:
+            raise ApplicationLogicException('Поле "Размер чанка" обязательно к заполнению')
+
+        split_by_quantity = int_or_none(context.split_by_quantity)
+        if context.split_by and not split_by_quantity:
+            raise ApplicationLogicException('Поле "Размер подпериода" обязательно к заполнению')
+
+        commands_to_save = FirstCollectModelsDataCommandsGenerator(
+            models=[obj.model_id],
+            split_by=context.split_by,
+            split_mode=context.split_mode,
+            split_by_quantity=context.split_by_quantity,
+            logs_period_started_at=context.logs_period_started_at,
+            logs_period_ended_at=context.logs_period_ended_at,
+            batch_size=context.batch_size,
+        ).generate_with_split(
+            by_institutes=context.by_institutes,
+            institute_ids=context.institute_ids,
+            institute_count=context.institute_count,
+            actual_institute_ids=self._get_actual_institute_ids(),
+        )
+
+        objs = [
+            self.model(
+                model_id=obj.model_id,
+                logs_period_started_at=command['period_started_at'],
+                logs_period_ended_at=command['period_ended_at'],
+                generation_id=command['generation_id'],
+                institute_ids=command['institute_ids'],
+                type=CommandType.MANUAL,
+            )
+            for command in commands_to_save
+        ]
+
+        for obj in objs:
+            super().save_row(obj, create_new, request, context, *args, **kwargs)

edu_rdm_integration/collect_data/const.py

@@ -0,0 +1,2 @@
+# Константа сбора по всем организациям через интерфейс
+ALL_UNITS_IN_COMMAND = -1