edu-rdm-integration 3.21.0__py3-none-any.whl → 3.23.0__py3-none-any.whl

edu_rdm_integration/stages/service/service_outdated_data/cleaners/base.py

@@ -0,0 +1,305 @@
+import asyncio
+from abc import (
+    ABCMeta,
+    abstractmethod,
+)
+from pathlib import (
+    Path,
+)
+from typing import (
+    TYPE_CHECKING,
+)
+
+import asyncpg
+from django.conf import (
+    settings,
+)
+from django.db import (
+    connection,
+)
+
+from educommon import (
+    logger,
+)
+
+
+if TYPE_CHECKING:
+    from asyncpg import (
+        Pool,
+    )
+
+
+class BaseServiceOutdatedDataCleaner(metaclass=ABCMeta):
+    """Базовый класс уборщика устаревших сервисных данных."""
+
+    model = None
+
+    SELECT_RDM_CHUNK_BOUNDED_SQL = """
+        DO $$
+        DECLARE
+            chunk_size INT := {chunk_size};
+            last_id INT := 0;
+            first_id INT;
+            last_chunk_id INT;
+        BEGIN
+            DROP TABLE IF EXISTS rdm_chunk_bounds;
+            CREATE TEMP TABLE rdm_chunk_bounds (
+                chunk_number INT,
+                first_id INT,
+                last_id INT
+            );
+
+            DROP TABLE IF EXISTS tmp_chunk;
+            CREATE TEMP TABLE tmp_chunk (id INT) ON COMMIT DROP;
+
+            WHILE TRUE LOOP
+                TRUNCATE tmp_chunk;
+
+                INSERT INTO tmp_chunk (id)
+                SELECT id
+                FROM {table_name}
+                WHERE id > last_id
+                ORDER BY id
+                LIMIT chunk_size;
+
+                IF NOT FOUND THEN
+                    EXIT;
+                END IF;
+
+                SELECT MIN(id), MAX(id)
+                INTO first_id, last_chunk_id
+                FROM tmp_chunk;
+
+                INSERT INTO rdm_chunk_bounds (chunk_number, first_id, last_id)
+                VALUES (
+                    (SELECT COUNT(*) FROM rdm_chunk_bounds) + 1,
+                    first_id,
+                    last_chunk_id
+                );
+
+                last_id := last_chunk_id;
+            END LOOP;
+        END $$;
+
+        SELECT * FROM rdm_chunk_bounds ORDER BY chunk_number;
+    """
+
+    REMOVE_OUTDATED_DATA_SQL = """
+        WITH deleted_rows AS (
+            DELETE FROM {table_name}
+            WHERE id IN (
+                WITH tbl AS (
+                    SELECT *
+                    FROM {table_name}
+                    WHERE id >= {first_id}
+                        AND id <= {last_id}
+                )
+                SELECT tbl.id
+                FROM tbl
+                WHERE {conditions}
+            )
+            RETURNING id
+        )
+        SELECT COUNT(*) AS deleted_count FROM deleted_rows;
+    """
+
+    def __init__(
+        self,
+        *args,
+        safe: bool = False,
+        log_sql: bool = False,
+        **kwargs
+    ):
+        """Инициализация уборщика."""
+        self._safe = safe
+        self._log_sql = log_sql
+        self._deleted_count = 0
+
+        super().__init__(*args, **kwargs)
+
+    @abstractmethod
+    def get_merged_conditions(self) -> str:
+        """Возвращает условия для удаления устаревших данных."""
+
+    @classmethod
+    def get_table_name(cls) -> str:
+        """Возвращает имя таблицы в базе данных."""
+        if cls.model is None:
+            raise NotImplementedError('Необходимо задать атрибут "model"')
+
+        return cls.model._meta.db_table
+
+    async def file_deletion_process(self, file_paths: list[str]):
+        """Функция для удаления файлов, связанных с удалёнными устаревшими записями.
+
+        Очистка данных производится в таблицах системных моделей РВД.
+        """
+
+    def get_orphan_reference_condition(
+        self,
+        reference_table: str,
+        reference_field: str,
+        local_field: str = 'id'
+    ) -> str:
+        """Условие проверки отсутствия записей в связанной таблице."""
+        return f"""
+            NOT EXISTS (
+                SELECT 1
+                FROM {reference_table} ref
+                WHERE ref.{reference_field} = tbl.{local_field}
+            )
+        """
+
+    def get_status_condition(
+        self,
+        related_table: str,
+        related_field: str,
+        status_value: str,
+        days: int,
+        local_field: str = 'id'
+    ) -> str:
+        """Условие проверки записи с заданным статусом и возрастом."""
+        return f"""
+            EXISTS (
+                SELECT 1
+                FROM {related_table} sub
+                WHERE sub.{related_field} = tbl.{local_field}
+                  AND sub.status_id = '{status_value}'
+                  AND sub.ended_at <= NOW() - INTERVAL '{days} days'
+            )
+        """
+
+    def get_chunk_bounded(self):
+        """Возвращает границы чанков для текущей таблицы."""
+        get_chunk_bounded_sql = self.SELECT_RDM_CHUNK_BOUNDED_SQL.format(
+            table_name=self.get_table_name(),
+            chunk_size=settings.RDM_CLEANUP_MODELS_OUTDATED_DATA_CHUNK_SIZE,
+        )
+
+        if self._log_sql:
+            # Проверка на доступность sqlparse для форматирования
+            try:
+                import sqlparse
+            except ImportError:
+                sqlparse = None
+
+            if sqlparse:
+                # Форматирование кода
+                get_chunk_bounded_sql = sqlparse.format(
+                    sql=get_chunk_bounded_sql,
+                    reindent=True,
+                    strip_comments=True,
+                )
+            logger.info(
+                f'Запрос для получения границ чанков модели {self.get_table_name()}: \n{get_chunk_bounded_sql}\n'
+            )
+
+        with connection.cursor() as cursor:
+            cursor.execute(get_chunk_bounded_sql)
+            result = cursor.fetchall()
+
+        return result
+
+    async def execute_query(self, pool: 'Pool', query: str):
+        """Асинхронное выполнение запроса."""
+        async with pool.acquire() as conn:
+            try:
+                if self._safe:
+                    logger.info(f'Запрос не будет выполнен, включен безопасный режим!\n')
+
+                    if self._log_sql:
+                        logger.info(f'{query}\n')
+                else:
+                    result = await conn.fetch(query)
+                    if not result:
+                        return
+
+                    if self._log_sql:
+                        logger.info(f'При помощи запроса:\n{query}\n')
+
+                    # Проверяем, что вернул запрос
+                    if 'deleted_count' in result[0]:
+                        deleted_count = result[0]['deleted_count']
+                        self._deleted_count += deleted_count
+                        logger.info(f'Было удалено записей: {deleted_count}')
+                    else:
+                        file_paths = [record['file_path'] for record in result if record.get('file_path')]
+                        if file_paths:
+                            await self.file_deletion_process(file_paths)
+                        deleted_count = len(result)
+                        self._deleted_count += deleted_count
+                        logger.info(f'Было удалено записей с файлами: {deleted_count}')
+
+            except Exception as e:
+                logger.error(f'Ошибка при выполнении {query}\n{e}')
+
+    def prepare_queries(self, chunk_bounded: list[tuple[int, int, int]]) -> list[str]:
+        """Формирование списка запросов для удаления устаревших данных."""
+        queries = []
+        conditions = self.get_merged_conditions()
+
+        for chunk_number, first_id, last_id in chunk_bounded:
+            remove_outdated_data_sql = self.REMOVE_OUTDATED_DATA_SQL.format(
+                table_name=self.get_table_name(),
+                first_id=first_id,
+                last_id=last_id,
+                conditions=conditions,
+            )
+
+            queries.append(remove_outdated_data_sql)
+
+        return queries
+
+    async def execute_queries(self, queries: list[str]) -> None:
+        """Асинхронное выполнение запросов."""
+        DB_SETTINGS = settings.DATABASES['default']
+
+        pool = await asyncpg.create_pool(
+            max_size=settings.RDM_CLEANUP_MODELS_OUTDATED_DATA_POOL_SIZE,
+            min_size=settings.RDM_CLEANUP_MODELS_OUTDATED_DATA_POOL_SIZE,
+            host=DB_SETTINGS['HOST'],
+            port=DB_SETTINGS['PORT'],
+            user=DB_SETTINGS['USER'],
+            password=DB_SETTINGS['PASSWORD'],
+            database=DB_SETTINGS['NAME'],
+        )
+
+        tasks = [self.execute_query(pool, query) for query in queries]
+
+        await asyncio.gather(*tasks)
+
+    def run(self):
+        """Запуск очистки устаревших данных."""
+        chunk_bounded = self.get_chunk_bounded()
+
+        queries = self.prepare_queries(chunk_bounded=chunk_bounded)
+
+        if queries:
+            even_loop = asyncio.new_event_loop()
+            try:
+                even_loop.run_until_complete(self.execute_queries(queries=queries))
+            finally:
+                even_loop.close()
+
+        logger.info(f'Удалено записей модели {self.model.__name__}: {self._deleted_count}')
+
+
+class ServiceFileCleaner:
+    """Асинхронный сервис для безопасного удаления файлов из MEDIA_ROOT."""
+
+    @staticmethod
+    async def file_deletion_process(file_paths: list[str]) -> None:
+        """Удаляет указанные файлы, считая пути относительными к MEDIA_ROOT."""
+        media_root = Path(settings.MEDIA_ROOT).resolve()
+
+        async def delete_file(path_str: str):
+            path = (media_root / path_str).resolve()
+            try:
+                exists = await asyncio.to_thread(path.exists)
+                if exists and await asyncio.to_thread(path.is_file):
+                    await asyncio.to_thread(path.unlink)
+
+            except Exception as e:
+                logger.warning(f"Не удалось удалить {path}: {e}")
+
+        await asyncio.gather(*(delete_file(path) for path in file_paths))

edu_rdm_integration/stages/service/service_outdated_data/cleaners/collect_data.py

@@ -0,0 +1,119 @@
+from typing import (
+    Optional,
+)
+
+from django.core.exceptions import (
+    FieldDoesNotExist,
+)
+from django.db.models import (
+    Subquery,
+)
+
+from edu_rdm_integration.rdm_models.models import (
+    RDMModelEnum,
+)
+from edu_rdm_integration.stages.collect_data.models import (
+    RDMCollectingDataCommandProgress,
+    RDMCollectingDataStage,
+    RDMCollectingDataSubStage,
+)
+from educommon.utils.seqtools import (
+    make_chunks,
+)
+
+from .base import (
+    BaseServiceOutdatedDataCleaner,
+)
+from .consts import (
+    UNION_CHUNK_SIZE,
+)
+
+
+class CollectingDataSubStageCleaner(BaseServiceOutdatedDataCleaner):
+    """Очистка подэтапов сбора данных, которые не ссылаются ни на одну модель РВД.
+
+    Подход:
+        - Проходим по всем моделям, зарегистрированным в RDMModelEnum, и собираем
+            значения полей collecting_sub_stage_id (если модель содержит такое поле).
+        - Объединяем запросы по моделям в UNION, получая набор валидных id.
+        - Удаляем те подэтапы, id которых отсутствуют в полученном наборе.
+    """
+
+    model = RDMCollectingDataSubStage
+
+    def _get_valid_substage_ids_subquery(self) -> Optional[Subquery]:
+        """Подзапрос, возвращающий все допустимые collecting_sub_stage_id из моделей, описанных в RDMModelEnum."""
+        model_enum_values = RDMModelEnum.get_model_enum_values()
+        all_model = [model_enum.model for model_enum in model_enum_values]
+        chunk_queries = []
+
+        for enum_values_chunk in make_chunks(all_model, UNION_CHUNK_SIZE, is_list=True):
+            qs_list = []
+            for model_cls in enum_values_chunk:
+                try:
+                    model_cls._meta.get_field('collecting_sub_stage_id')
+                except FieldDoesNotExist:
+                    continue
+
+                qs_list.append(model_cls.objects.values('collecting_sub_stage_id'))
+
+            if qs_list:
+                chunk_union = qs_list[0].union(*qs_list[1:])
+                chunk_queries.append(chunk_union)
+
+        if not chunk_queries:
+            return
+
+        # Объединяем все чанки в один общий UNION
+        full_union = chunk_queries[0].union(*chunk_queries[1:])
+
+        return Subquery(full_union)
+
+    def get_merged_conditions(self) -> str:
+        """Формирует условие удаления для устаревших данных.
+
+         Удаляем подэтапы, которых нет в объединённом наборе валидных collecting_sub_stage_id
+        (т.е. подэтапы, не используемые ни одной моделью данных).
+        """
+        conditions = ''
+        subquery = self._get_valid_substage_ids_subquery()
+        if subquery:
+            conditions = f"""
+                NOT EXISTS (
+                    SELECT collecting_sub_stage_id
+                    FROM ({str(subquery.query)}) AS valid
+                    WHERE valid.collecting_sub_stage_id = tbl.id
+                )
+            """
+
+        return conditions
+
+
+class CollectingDataStageCleaner(BaseServiceOutdatedDataCleaner):
+    """Очистка этапов сбора данных, у которых нет связанных подэтапов."""
+
+    model = RDMCollectingDataStage
+
+    def get_merged_conditions(self) -> str:
+        """Формирует условие удаления для устаревших данных."""
+        sub_stage_table = CollectingDataSubStageCleaner.get_table_name()
+
+        return self.get_orphan_reference_condition(sub_stage_table, 'stage_id')
+
+
+class CollectingDataCommandProgressCleaner(BaseServiceOutdatedDataCleaner):
+    """Очистка устаревших хранящихся задач по сбору данных."""
+
+    model = RDMCollectingDataCommandProgress
+
+    def get_merged_conditions(self) -> str:
+        """Формирует условие удаления для устаревших данных."""
+        stage_table = CollectingDataStageCleaner.get_table_name()
+        conditions = [
+            'stage_id IS NULL',
+            f'({self.get_status_condition(stage_table, "id", "FINISHED", 7, "stage_id")})',
+            f'({self.get_status_condition(stage_table, "id", "FAILED", 30, "stage_id")})',
+            f'({self.get_orphan_reference_condition(stage_table, "id", "stage_id")})',
+        ]
+
+        return " OR ".join(conditions)

edu_rdm_integration/stages/service/service_outdated_data/cleaners/consts.py

@@ -0,0 +1 @@
+UNION_CHUNK_SIZE = 5

edu_rdm_integration/stages/service/service_outdated_data/cleaners/export_data.py

@@ -0,0 +1,174 @@
+from typing import (
+    Optional,
+)
+
+from django.core.exceptions import (
+    FieldDoesNotExist,
+)
+from django.db.models import (
+    Subquery,
+)
+
+from edu_rdm_integration.rdm_models.models import (
+    RDMModelEnum,
+)
+from edu_rdm_integration.stages.export_data.models import (
+    RDMExportingDataCommandProgress,
+    RDMExportingDataStage,
+    RDMExportingDataSubStage,
+    RDMExportingDataSubStageAttachment,
+    RDMExportingDataSubStageEntity,
+)
+from educommon.utils.seqtools import (
+    make_chunks,
+)
+
+from .base import (
+    BaseServiceOutdatedDataCleaner,
+    ServiceFileCleaner,
+)
+from .consts import (
+    UNION_CHUNK_SIZE,
+)
+
+
+class ExportingDataSubStageCleaner(BaseServiceOutdatedDataCleaner):
+    """Очистка подэтапов выгрузки данных, которые не ссылаются ни на одну модель РВД.
+
+    Подход:
+        - Проходим по всем моделям, зарегистрированным в RDMModelEnum, и собираем
+            значения полей exporting_sub_stage_id (если модель содержит такое поле).
+        - Объединяем запросы по моделям в UNION, получая набор валидных id.
+        - Удаляем те подэтапы, id которых отсутствуют в полученном наборе.
+    """
+    model = RDMExportingDataSubStage
+
+    def _get_valid_substage_ids_subquery(self) -> Optional[Subquery]:
+        """Подзапрос, возвращающий все допустимые exporting_sub_stage_id из моделей, описанных в RDMModelEnum."""
+        model_enum_values = RDMModelEnum.get_model_enum_values()
+        all_model = [model_enum.model for model_enum in model_enum_values]
+        chunk_queries = []
+
+        for enum_values_chunk in make_chunks(all_model, UNION_CHUNK_SIZE, is_list=True):
+            qs_list = []
+            for model_cls in enum_values_chunk:
+                try:
+                    model_cls._meta.get_field('exporting_sub_stage_id')
+                except FieldDoesNotExist:
+                    continue
+                qs_list.append(model_cls.objects.values('exporting_sub_stage_id'))
+
+            if qs_list:
+                chunk_union = qs_list[0].union(*qs_list[1:])
+                chunk_queries.append(chunk_union)
+
+        if not chunk_queries:
+            return
+
+        # Объединяем все чанки в один общий UNION
+        full_union = chunk_queries[0].union(*chunk_queries[1:])
+
+        return Subquery(full_union.values('exporting_sub_stage_id'))
+
+    def get_merged_conditions(self) -> str:
+        """Формирует условие удаления для устаревших данных.
+
+         Удаляем подэтапы, которых нет в объединённом наборе валидных exporting_sub_stage_id
+        (т.е. подэтапы, не используемые ни одной моделью данных).
+        """
+        conditions = ''
+        subquery = self._get_valid_substage_ids_subquery()
+        if subquery:
+           conditions = f"""
+                NOT EXISTS (
+                    SELECT exporting_sub_stage_id
+                    FROM ({str(subquery.query)}) AS valid
+                    WHERE valid.exporting_sub_stage_id = tbl.id
+                )
+            """
+
+        return conditions
+
+
+class ExportingDataStageCleaner(BaseServiceOutdatedDataCleaner):
+    """Очистка этапов выгрузки данных без подэтапов."""
+
+    model = RDMExportingDataStage
+
+    def get_merged_conditions(self) -> str:
+        """Формирует условие удаления для устаревших данных."""
+        sub_stage_table = ExportingDataSubStageCleaner.get_table_name()
+
+        return self.get_orphan_reference_condition(sub_stage_table, 'stage_id')
+
+
+class ExportingDataSubStageAttachmentCleaner(ServiceFileCleaner, BaseServiceOutdatedDataCleaner):
+    """Очистка вложений подэтапов выгрузки данных."""
+
+    model = RDMExportingDataSubStageAttachment
+
+    REMOVE_OUTDATED_DATA_SQL = """
+        WITH deleted_rows AS (
+            DELETE FROM {table_name}
+            WHERE id IN (
+                WITH tbl AS (
+                    SELECT *
+                    FROM {table_name}
+                    WHERE id >= {first_id}
+                        AND id <= {last_id}
+                )
+                SELECT tbl.id
+                FROM tbl
+                WHERE {conditions}
+            )
+            RETURNING attachment AS file_path
+        )
+        SELECT file_path FROM deleted_rows;
+    """
+
+    def get_merged_conditions(self) -> str:
+        """Формирует условие удаления для устаревших данных."""
+        sub_stage_table = ExportingDataSubStageCleaner.get_table_name()
+        conditions = [
+            'exporting_data_sub_stage_id IS NULL',
+            f'({self.get_status_condition(sub_stage_table, "id", "FINISHED", 7, "exporting_data_sub_stage_id")})',
+            f'({self.get_status_condition(sub_stage_table, "id", "FAILED",30, "exporting_data_sub_stage_id")})',
+            f'({self.get_orphan_reference_condition(sub_stage_table, "id", "exporting_data_sub_stage_id")})',
+        ]
+
+        return ' OR '.join(conditions)
+
+
+class ExportingDataSubStageEntityCleaner(BaseServiceOutdatedDataCleaner):
+    """Очистка связей сущности и подэтапов выгрузки данных."""
+
+    model = RDMExportingDataSubStageEntity
+
+    def get_merged_conditions(self) -> str:
+        """Формирует условие удаления для устаревших данных."""
+        sub_stage_table = ExportingDataSubStageCleaner.get_table_name()
+        conditions = [
+            f'({self.get_status_condition(sub_stage_table, "id", "FINISHED", 7, "exporting_data_sub_stage_id")})',
+            f'({self.get_status_condition(sub_stage_table, "id", "FAILED",30, "exporting_data_sub_stage_id")})',
+            f'({self.get_orphan_reference_condition(sub_stage_table, "id", "exporting_data_sub_stage_id")})',
+        ]
+
+        return ' OR '.join(conditions)
+
+
+class ExportingDataCommandProgressCleaner(BaseServiceOutdatedDataCleaner):
+    """Очистка устаревших хранящихся задач по экспорту данных."""
+
+    model = RDMExportingDataCommandProgress
+
+    def get_merged_conditions(self) -> str:
+        """Формирует условие удаления для устаревших данных."""
+        stage_table = ExportingDataStageCleaner.get_table_name()
+        conditions = [
+            'stage_id IS NULL',
+            f'({self.get_status_condition(stage_table, "id", "FINISHED", 7, "stage_id")})',
+            f'({self.get_status_condition(stage_table, "id", "FAILED",30, "stage_id")})',
+            f'({self.get_orphan_reference_condition(stage_table, "id", "stage_id")})',
+        ]
+
+        return ' OR '.join(conditions)

edu_rdm_integration/stages/service/service_outdated_data/cleaners/upload_data.py

@@ -0,0 +1,64 @@
+from edu_rdm_integration.stages.upload_data.models import (
+    RDMExportingDataSubStageUploaderClientLog,
+    RDMUploadStatusRequestLog,
+)
+from uploader_client.models import (
+    Entry,
+)
+
+from .base import (
+    BaseServiceOutdatedDataCleaner,
+)
+from .export_data import (
+    ExportingDataSubStageAttachmentCleaner,
+    ExportingDataSubStageCleaner,
+)
+
+
+class ExportingDataSubStageUploaderClientLogCleaner(BaseServiceOutdatedDataCleaner):
+    """Очистка логов загрузчика подэтапов выгрузки данных без связи с подэтапами или файлами."""
+
+    model = RDMExportingDataSubStageUploaderClientLog
+
+    def get_merged_conditions(self) -> str:
+        """Формирует условие удаления для устаревших данных."""
+        sub_stage_table = ExportingDataSubStageCleaner.get_table_name()
+        attachment_table = ExportingDataSubStageAttachmentCleaner.get_table_name()
+
+        conditions = [
+            f'({self.get_status_condition(sub_stage_table, "id", "FINISHED", 7, "sub_stage_id")})',
+            f'({self.get_status_condition(sub_stage_table, "id", "FAILED", 30, "sub_stage_id")})',
+            f'({self.get_orphan_reference_condition(sub_stage_table, "id", local_field="sub_stage_id")})',
+            f'({self.get_orphan_reference_condition(attachment_table, "id", local_field="attachment_id")})',
+        ]
+
+        return ' OR '.join(conditions)
+
+
+class UploadStatusRequestLogCleaner(BaseServiceOutdatedDataCleaner):
+    """Очистка логов статуса загрузки файла в витрину без связей upload."""
+
+    model = RDMUploadStatusRequestLog
+
+    def get_merged_conditions(self) -> str:
+        """Формирует условие удаления для устаревших данных."""
+        uploader_client_log_table = ExportingDataSubStageUploaderClientLogCleaner.get_table_name()
+
+        return self.get_orphan_reference_condition(uploader_client_log_table, 'id', local_field='upload_id')
+
+
+class EntryCleaner(BaseServiceOutdatedDataCleaner):
+    """Очистка записей журнала, не связанные ни с upload, ни с логами."""
+
+    model = Entry
+
+    def get_merged_conditions(self) -> str:
+        """Формирует условие удаления для устаревших данных."""
+        uploader_client_log_table = ExportingDataSubStageUploaderClientLogCleaner.get_table_name()
+        upload_status_log_table = UploadStatusRequestLogCleaner.get_table_name()
+        conditions = [
+            f'({self.get_orphan_reference_condition(uploader_client_log_table, "entry_id")})',
+            f'({self.get_orphan_reference_condition(upload_status_log_table, "entry_id")})',
+        ]
+
+        return ' AND '.join(conditions)