edu-rdm-integration 3.8.1__tar.gz → 3.9.0__tar.gz

{edu_rdm_integration-3.8.1 → edu_rdm_integration-3.9.0}/CHANGELOG.md

@@ -29,6 +29,14 @@
 ### Удалено
 
 
+## [3.9.0] - 2025-05-22
+
+### Добавлено
+
+- [EDUKNDG-15430](https://jira.bars.group/browse/EDUKNDG-15430)
+  MAJOR Из проектов вынесен UI в общий пакет (Сбор данных моделей РВД и Экспорт данных сущностей РВД).
+
+
 ## [3.8.1] - 2025-05-20
 
 Доработка журнала логов РВД.

{edu_rdm_integration-3.8.1 → edu_rdm_integration-3.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: edu-rdm-integration
-Version: 3.8.1
+Version: 3.9.0
 Summary: Интеграция с Региональной витриной данных
 Author-email: BARS Group <education_dev@bars.group>
 Project-URL: Homepage, https://stash.bars-open.ru/projects/EDUBASE/repos/edu_rdm_integration/browse

edu_rdm_integration-3.9.0/src/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-3.9.0/src/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-3.9.0/src/edu_rdm_integration/collect_and_export_data/utils.py

@@ -0,0 +1,224 @@
+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,
+    EduRdmExportDataCommandProgress,
+)
+from edu_rdm_integration.collect_data.collect import (
+    BaseCollectModelsDataByGeneratingLogs,
+)
+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,
+)
+from edu_rdm_integration.helpers import (
+    save_command_log_link,
+)
+
+
+class CollectCommandMixin:
+    """Класс-примесь для запуска команды сборки моделей."""
+
+    queue = TASK_QUEUE_NAME
+    routing_key = TASK_QUEUE_NAME
+    description = 'Сбор данных моделей РВД'
+    task_type = AsyncTaskType.SYSTEM
+
+    def get_collect_command(self, command_id: int) -> EduRdmCollectDataCommandProgress:
+        """Возвращает экземпляр модели команды запуска."""
+        command = EduRdmCollectDataCommandProgress.objects.get(id=command_id)
+
+        return command
+
+    def get_collect_models_class(self):
+        """Возвращает класс для сбора данных."""
+        return BaseCollectModelsDataByGeneratingLogs
+
+    def run_collect_command(self, command) -> None:
+        """Запуск команды сбора."""
+        collect_models_data_class = self.get_collect_models_class()
+        collect_models_data_class(
+            models=(command.model_id,),
+            logs_period_started_at=command.logs_period_started_at,
+            logs_period_ended_at=command.logs_period_ended_at,
+            command_id=command.id,
+            institute_ids=tuple(command.institute_ids or ()),
+        ).collect()
+
+    def save_collect_command_logs(self, command_id: int, log_dir: str):
+        """Сохранение ссылки на файл логов в команде."""
+        try:
+            command = self.get_collect_command(command_id)
+        except EduRdmCollectDataCommandProgress.DoesNotExist:
+            command = None
+
+        if command:
+            save_command_log_link(command, log_dir)
+
+
+class ExportCommandMixin:
+    """Класс-примесь для запуска команды выгрузки сущностей."""
+
+    queue = TASK_QUEUE_NAME
+    routing_key = TASK_QUEUE_NAME
+    description = 'Экспорт данных сущностей РВД'
+    task_type = AsyncTaskType.SYSTEM
+
+    def get_export_command(self, command_id: int) -> EduRdmExportDataCommandProgress:
+        """Возвращает экземпляр модели команды запуска."""
+        command = EduRdmExportDataCommandProgress.objects.get(id=command_id)
+
+        return command
+
+    def run_export_command(self, command: EduRdmExportDataCommandProgress) -> None:
+        """Запуск команды выгрузки."""
+        ExportEntitiesData(
+            entities=(command.entity_id,),
+            period_started_at=command.period_started_at,
+            period_ended_at=command.period_ended_at,
+            command_id=command.id,
+        ).export()
+
+    def save_export_command_logs(self, command_id: int, log_dir: str):
+        """Сохранение ссылки на файл логов в команде."""
+        try:
+            command = self.get_export_command(command_id)
+        except EduRdmExportDataCommandProgress.DoesNotExist:
+            command = None
+
+        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,
+        )