sql.py

from datetime import datetime
from enum import Enum

from sqlalchemy import text, RowMapping, bindparam
from sqlalchemy.dialects.mysql import dialect

from connector import DataBase


class DesignCase(Enum):
    NEW = 'NEW'
    DISABLED = 'DISABLED'
    CHANGES = 'CHANGES'
    ENABLE = 'ENABLE'

class Conn(DataBase):
    local_cache = {}

    def get_producttype_info(self, producttype: str) -> dict:
        """Получает информацию о типе продукта по его ключу.

        Args:
            producttype: Ключ типа продукта (tkey)

        Returns:
            Словарь с информацией о продукте, содержащий:
            - id: идентификатор типа продукта
            - tkey: ключ типа продукта
            - name_1: название продукта
            - price: цена продукта
            - sex: половая принадлежность
            - model_id: ID основной модели
            Если продукт не найден, возвращает пустой словарь.
        """
        query = """
            SELECT 
                pt.id,
                pt.tkey,
                pt.name_1,
                pt.price,
                pt.sex,
                (
                    SELECT m.model_id 
                    FROM models m 
                    WHERE m.producttype_id = pt.id 
                      AND m.is_active = 1 
                    ORDER BY m.position ASC 
                    LIMIT 1
                ) AS model_id
            FROM producttype pt
            WHERE pt.tkey = :producttype 
              AND pt.active = 'Y'
        """

        params = {'producttype': producttype}

        if result := self.local_cache.get(producttype):
            return result

        with self._session() as session:
            result = session.execute(text(query), params).mappings().first()

            if not result:
                return {}

            self.local_cache.update({producttype: dict(result)})
            return dict(result)

    # 14400 секунд = 4 часа
    def get_models_list(self, product_type_id: int) -> list[RowMapping]:
        """Возвращает список моделей для указанного типа продукта с информацией о расположении принта.

        Args:
            product_type_id: Идентификатор типа продукта

        Returns:
            Список словарей с ключами:
            - model_id: идентификатор модели
            - printfield_type_id: расположение принта ('front' или 'back')
        """
        query = """
            SELECT
                model_id,
                CASE
                    WHEN printfield_type_id = 1 THEN 'front'
                    ELSE 'back'
                END AS printfield_type_id
            FROM models
            WHERE producttype_id = :product_type_id 
              AND is_active = 1
            ORDER BY position ASC;
        """

        params = {'product_type_id': product_type_id}

        if result := self.local_cache.get(product_type_id):
            return result

        with self._session() as session:
            result = session.execute(text(query), params).mappings().all()

            if not result:
                return []

            self.local_cache.update({product_type_id: result})
            return result

    def get_product_data(self, case: DesignCase, limit: int | None = None, date: datetime = None) -> list[dict]:
        """Получает данные о продуктах из базы данных"""
        sub_query = ''
        match case:
            case DesignCase.NEW:
                sub_query = self._case_new(limit=limit, date=date)
            case DesignCase.DISABLED:
                sub_query = self._case_disabled(limit=limit, date=date)
            case DesignCase.CHANGES:
                sub_query = self._case_changes(limit=limit, date=date)
            case DesignCase.ENABLE:
                sub_query = self._case_enable(limit)
                print('собираю включенные дизайны')

        if sub_query:
            query = f"""
                SELECT t.theme_id as design_id, 
                       (SELECT pt.tkey
                        FROM producttype pt
                                 JOIN theme_has_producttype thp ON pt.id = thp.producttype_id
                        WHERE thp.theme_id = t.theme_id
                        AND pt.active = 'Y'
                        LIMIT 1)  as product_type, 
                       (SELECT c.tkey
                        FROM color c
                                 JOIN color_has_producttype chp ON c.id = chp.color_id
                                 JOIN producttype pt ON chp.producttype_id = pt.id
                                 JOIN theme_has_producttype thp ON pt.id = thp.producttype_id
                        WHERE thp.theme_id = t.theme_id
                        LIMIT 1)  as color_alias
                FROM ({sub_query}) t 
                """

            with self._session() as session:
                print(query)
                result = session.execute(text(query)).mappings().all()
                return [dict(row) for row in result]
        return []

    @staticmethod
    def _case_enable(limit: int | None = None) -> str:
        """Возвращает SQL-запрос для получения всех активных дизайнов, отображаемых на сайте.

            Args:
                limit: Максимальное количество возвращаемых записей (None - без ограничения)

            Returns:
                Строка с SQL-запросом
            """
        params = [bindparam("limit", value=limit)]

        sub_query = f"""
            SELECT DISTINCT theme_id 
            FROM theme_has_producttype 
            JOIN catalog 
                ON theme_has_producttype.theme_id = catalog.id 
                AND catalog.active = 'Y'
                AND catalog.show_site = 'Y'
            WHERE theme_has_producttype.active = 1
            LIMIT :limit
        """

        sub_query = text(sub_query).bindparams(*params)
        sub_query = sub_query.compile(
            dialect=dialect(),
            compile_kwargs={"literal_binds": True},
        )
        return str(sub_query)

    @staticmethod
    def _case_new(date: datetime, limit: int | None = None) -> str:
        """Возвращает SQL-запрос для получения новых дизайнов, созданных после указанной даты.

        Args:
            date: Дата, начиная с которой искать новые дизайны
            limit: Максимальное количество возвращаемых записей (None - без ограничения)

        Returns:
            Строка с SQL-запросом
        """
        if not date:
            return ""

        params = [
            bindparam("limit", value=limit),
            bindparam("date", value=date)
        ]

        sub_query = f"""
            SELECT DISTINCT theme_id 
            FROM theme_has_producttype 
            JOIN catalog 
                ON theme_has_producttype.theme_id = catalog.id 
                AND catalog.active = 'Y'
                AND catalog.show_site = 'Y'
                AND catalog.moderate_at >= :date
            WHERE theme_has_producttype.active = 1
            LIMIT :limit
        """

        sub_query = text(sub_query).bindparams(*params)
        sub_query = sub_query.compile(
            dialect=dialect(),
            compile_kwargs={"literal_binds": True},
        )
        return str(sub_query)

    @staticmethod
    def _case_disabled(date: datetime = datetime.now(), limit: int | None = None) -> str:
        """Возвращает SQL-запрос для получения отключенных дизайнов (active='N'), но показываемых на сайте.

        Args:
            date: Дата, начиная с которой искать изменения (опционально)
            limit: Максимальное количество возвращаемых записей (None - без ограничения)

        Returns:
            Строка с SQL-запросом
        """
        params = [bindparam("limit", value=limit)]

        # Базовый запрос
        sub_query = """
            SELECT DISTINCT theme_id 
            FROM theme_has_producttype 
            JOIN catalog 
                ON theme_has_producttype.theme_id = catalog.id
                AND catalog.active = 'N'
                AND catalog.show_site = 'Y'
            """

        # Добавляем условие по дате, если она указана
        if date:
            sub_query += "AND catalog.moderate_at >= :date\n"
            params.append(bindparam("date", value=date))

        # Завершающая часть запроса
        sub_query += """
            WHERE theme_has_producttype.active = 1
            LIMIT :limit
        """

        # Компиляция запроса
        sub_query = text(sub_query).bindparams(*params)
        sub_query = sub_query.compile(
            dialect=dialect(),
            compile_kwargs={"literal_binds": True},
        )

        return str(sub_query)

    @staticmethod
    def _case_changes(date: datetime = datetime.now(), limit: int | None = None) -> str:
        """Возвращает SQL-запрос для получения новых дизайнов, обновлённых после указанной даты.

        Args:
            date: Дата, начиная с которой искать изменения (по умолчанию текущая дата/время)
            limit: Максимальное количество возвращаемых записей (None - без ограничения)

        Returns:
            Строка с SQL-запросом
        """
        if not date:
            return ""

        params = [bindparam("limit", value=limit),
                  bindparam("date", value=date)]

        sub_query = """
            SELECT DISTINCT theme_id 
            FROM theme_has_producttype 
            JOIN catalog ON 
                theme_has_producttype.theme_id = catalog.id 
                AND catalog.active = 'Y'
                AND catalog.show_site = 'Y'
                AND catalog.moderate_at >= :date
            WHERE theme_has_producttype.active = 1
            LIMIT :limit
        """

        sub_query = text(sub_query).bindparams(*params)
        sub_query = sub_query.compile(
            dialect=dialect(),
            compile_kwargs={"literal_binds": True},
        )
        return str(sub_query)