ref: рефакторинг usecases

2025-12-11 18:02:46 +03:00
parent 38f1b3feba
commit 1f80d9bdfb
47 changed files with 853 additions and 3454 deletions
--- a/src/adapter/postgres.py
+++ b/src/adapter/postgres.py
@@ -2,6 +2,7 @@ import datetime
 import typing
 import uuid

+from tortoise import timezone
 from tortoise.transactions import in_transaction

 from shared.datebase_base import DatabaseBase
@@ -12,31 +13,34 @@ class Postgres(DatabaseBase):
    def transaction(self) -> typing.AsyncContextManager[None]:
        return in_transaction()

+    async def create_user(self, user: domain.User) -> None:
+        await user.save()
+
+    async def create_login_token(self, login_token: domain.LoginToken) -> None:
+        await login_token.save()
+
+    async def create_external_channel(self, channel: domain.ExternalChannel) -> None:
+        await channel.save()
+
+    async def create_creative(self, creative: domain.Creative) -> None:
+        await creative.save()
+
    async def get_user(self, user_id: uuid.UUID | None = None, telegram_id: int | None = None) -> domain.User | None:
        if user_id:
            return await domain.User.get_or_none(id=user_id)
        elif telegram_id:
            return await domain.User.get_or_none(telegram_id=telegram_id)
+
        raise ValueError('Either user_id or telegram_id must be provided')

-    async def create_user(self, user: domain.User) -> domain.User:
-        await user.save()
-        return user
-
-    async def create_login_token(
-        self, user_id: uuid.UUID, token: str, expires_at: datetime.datetime
-    ) -> domain.LoginToken:
-        login_token = await domain.LoginToken.create(user_id=user_id, token=token, expires_at=expires_at)
-        return login_token
-
    async def get_login_token(self, token: str) -> domain.LoginToken | None:
        return await domain.LoginToken.get_or_none(token=token)

    async def mark_token_as_used(self, token: str) -> None:
-        login_token = await domain.LoginToken.get_or_none(token=token)
-        if login_token:
-            login_token.used_at = datetime.datetime.now(datetime.UTC)
-            await login_token.save()
+        updated = await domain.LoginToken.filter(token=token, used_at__isnull=True).update(used_at=timezone.now())
+
+        if updated == 0:
+            raise domain.LoginTokenAlreadyUsed()  # либо нет токена, либо он уже использован

    async def get_target_channel(
        self, user_id: uuid.UUID, channel_id: uuid.UUID | None = None, telegram_id: int | None = None
@@ -44,36 +48,34 @@ class Postgres(DatabaseBase):
        if not channel_id and not telegram_id:
            raise ValueError('Either channel_id or telegram_id must be provided')

-        query = domain.TargetChannel.filter(user_id=user_id)
+        q = domain.TargetChannel.filter(user_id=user_id)
        if channel_id:
-            query = query.filter(id=channel_id)
+            q = q.filter(id=channel_id)
        if telegram_id:
-            query = query.filter(telegram_id=telegram_id)
+            q = q.filter(telegram_id=telegram_id)

-        return await query.first()
+        return await q.first()

-    async def upsert_target_channel(self, channel: domain.TargetChannel) -> domain.TargetChannel:
+    async def upsert_target_channel(self, channel: domain.TargetChannel) -> None:
        existing = await self.get_target_channel(user_id=channel.user_id, telegram_id=channel.telegram_id)

        if not existing:
            await channel.save()
-            return channel
+            return

        existing.title = channel.title
        existing.username = channel.username
        existing.user_id = channel.user_id
        existing.status = channel.status
        existing.deleted_at = None
-        existing.updated_at = datetime.datetime.now(datetime.UTC)
+        existing.updated_at = timezone.now()
        await existing.save()
-        return existing

    async def get_user_target_channels(self, user_id: uuid.UUID) -> list[domain.TargetChannel]:
        return await domain.TargetChannel.filter(user_id=user_id, status=domain.TargetChannelStatus.ACTIVE).all()

-    async def update_target_channel(self, channel: domain.TargetChannel) -> domain.TargetChannel:
+    async def update_target_channel(self, channel: domain.TargetChannel) -> None:
        await channel.save()
-        return channel

    async def get_external_channel(
        self, user_id: uuid.UUID, channel_id: uuid.UUID | None = None, telegram_id: int | None = None
@@ -86,14 +88,8 @@ class Postgres(DatabaseBase):

        return await query.first()

-    async def create_external_channel(self, channel: domain.ExternalChannel) -> domain.ExternalChannel:
-        await channel.save()
-        return channel
-
    async def get_external_channels_for_target(self, target_channel_id: uuid.UUID) -> list[domain.ExternalChannel]:
-        target = await (
-            domain.TargetChannel.filter(id=target_channel_id).prefetch_related('external_channels').first()
-        )
+        target = await domain.TargetChannel.filter(id=target_channel_id).prefetch_related('external_channels').first()
        if not target:
            return []
        return await target.external_channels.all()
@@ -129,22 +125,14 @@ class Postgres(DatabaseBase):
    async def delete_external_channel(self, channel_id: uuid.UUID) -> None:
        await domain.ExternalChannel.filter(id=channel_id).delete()

-    async def update_external_channel(self, channel: domain.ExternalChannel) -> domain.ExternalChannel:
+    async def update_external_channel(self, channel: domain.ExternalChannel) -> None:
        await channel.save()
-        return channel

    async def get_creative(self, user_id: uuid.UUID, creative_id: uuid.UUID) -> domain.Creative | None:
        return await domain.Creative.get_or_none(id=creative_id, user_id=user_id).prefetch_related('target_channel')

-    async def create_creative(self, creative: domain.Creative) -> domain.Creative:
+    async def update_creative(self, creative: domain.Creative) -> None:
        await creative.save()
-        await creative.fetch_related('target_channel')
-        return creative
-
-    async def update_creative(self, creative: domain.Creative) -> domain.Creative:
-        await creative.save()
-        await creative.fetch_related('target_channel')
-        return creative

    async def get_user_creatives(
        self, user_id: uuid.UUID, target_channel_id: uuid.UUID | None = None, include_archived: bool = False
@@ -167,15 +155,11 @@ class Postgres(DatabaseBase):
            'target_channel', 'external_channel', 'creative'
        )

-    async def create_placement(self, placement: domain.Placement) -> domain.Placement:
+    async def create_placement(self, placement: domain.Placement) -> None:
        await placement.save()
-        await placement.fetch_related('target_channel', 'external_channel', 'creative')
-        return placement

-    async def update_placement(self, placement: domain.Placement) -> domain.Placement:
+    async def update_placement(self, placement: domain.Placement) -> None:
        await placement.save()
-        await placement.fetch_related('target_channel', 'external_channel', 'creative')
-        return placement

    async def get_user_placements(
        self,
@@ -211,78 +195,30 @@ class Postgres(DatabaseBase):
            'target_channel', 'external_channel', 'creative'
        )

-    async def get_placement_by_id(self, placement_id: uuid.UUID) -> domain.Placement | None:
-        return await domain.Placement.get_or_none(id=placement_id)
-
-    async def update_placement_from_post_found(
-        self, placement_id: uuid.UUID, ad_post_url: str, message_id: int, views_count: int
-    ) -> domain.Placement:
-        placement = await domain.Placement.get_or_none(id=placement_id)
-        if not placement:
-            raise ValueError(f'Placement {placement_id} not found')
-
-        placement.status = domain.PlacementStatus.ACTIVE
-        placement.ad_post_url = ad_post_url
-        placement.external_channel_message_id = message_id
-        placement.views_count = views_count
-        placement.views_availability = domain.PostViewsAvailability.AVAILABLE
-        placement.last_views_fetch_at = datetime.datetime.now(datetime.UTC)
-
-        await placement.save()
-        return placement
-
-    async def update_placement_from_post_deleted(self, placement_id: uuid.UUID) -> domain.Placement:
-        placement = await domain.Placement.get_or_none(id=placement_id)
-        if not placement:
-            raise ValueError(f'Placement {placement_id} not found')
-
-        placement.status = domain.PlacementStatus.DELETED
-        await placement.save()
-        return placement
-
-    async def update_placement_views(self, placement_id: uuid.UUID, views_count: int) -> domain.Placement:
-        placement = await domain.Placement.get_or_none(id=placement_id)
-        if not placement:
-            raise ValueError(f'Placement {placement_id} not found')
-
-        placement.views_count = views_count
-        placement.last_views_fetch_at = datetime.datetime.now(datetime.UTC)
-
-        await placement.save()
-        return placement
-
    async def get_subscriber(self, telegram_id: int) -> domain.Subscriber | None:
        return await domain.Subscriber.get_or_none(telegram_id=telegram_id)

-    async def create_subscriber(self, subscriber: domain.Subscriber) -> domain.Subscriber:
-        await subscriber.save()
-        return subscriber
-
-    async def upsert_subscriber(self, subscriber: domain.Subscriber) -> domain.Subscriber:
+    async def upsert_subscriber(self, subscriber: domain.Subscriber) -> None:
        existing = await self.get_subscriber(subscriber.telegram_id)
-        if existing:
-            # Обновляем данные если изменились
-            existing.username = subscriber.username
-            existing.first_name = subscriber.first_name
-            existing.last_name = subscriber.last_name
-            await existing.save()
-            return existing
-        return await self.create_subscriber(subscriber)
+        if not existing:
+            await subscriber.save()
+            return

-    async def create_subscription(self, subscription: domain.Subscription) -> domain.Subscription:
+        existing.username = subscriber.username
+        existing.first_name = subscriber.first_name
+        existing.last_name = subscriber.last_name
+        await existing.save()
+
+    async def create_subscription(self, subscription: domain.Subscription) -> None:
        await subscription.save()
-        await subscription.fetch_related('placement', 'subscriber')
-        return subscription

    async def get_subscription_by_subscriber_and_placement(
        self, subscriber_id: uuid.UUID, placement_id: uuid.UUID
    ) -> domain.Subscription | None:
        return await domain.Subscription.get_or_none(subscriber_id=subscriber_id, placement_id=placement_id)

-    async def update_subscription(self, subscription: domain.Subscription) -> domain.Subscription:
+    async def update_subscription(self, subscription: domain.Subscription) -> None:
        await subscription.save()
-        await subscription.fetch_related('placement', 'subscriber')
-        return subscription

    async def get_active_subscriptions_by_subscriber_and_channel(
        self, subscriber_id: uuid.UUID, channel_telegram_id: int
@@ -310,12 +246,8 @@ class Postgres(DatabaseBase):
            .first()
        )

-    async def create_placement_views_history(
-        self, history: domain.PlacementViewsHistory
-    ) -> domain.PlacementViewsHistory:
+    async def create_placement_views_history(self, history: domain.PlacementViewsHistory) -> None:
        await history.save()
-        await history.fetch_related('placement')
-        return history

    async def get_views_history(
        self,
@@ -344,7 +276,7 @@ class Postgres(DatabaseBase):
        if existing:
            existing.state = state
            existing.context = context
-            existing.updated_at = datetime.datetime.now(datetime.UTC)
+            existing.updated_at = timezone.now()
            await existing.save()
            return existing