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

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)
+        updated = await domain.LoginToken.filter(token=token, used_at__isnull=True).update(used_at=timezone.now())
-        if login_token:
+
-            login_token.used_at = datetime.datetime.now(datetime.UTC)
+        if updated == 0:
-            await login_token.save()
+            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 (
+        target = await domain.TargetChannel.filter(id=target_channel_id).prefetch_related('external_channels').first()
-            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:
+    async def upsert_subscriber(self, subscriber: domain.Subscriber) -> None:
-        await subscriber.save()
-        return subscriber
-
-    async def upsert_subscriber(self, subscriber: domain.Subscriber) -> domain.Subscriber:
         existing = await self.get_subscriber(subscriber.telegram_id)
-        if existing:
+        if not existing:
-            # Обновляем данные если изменились
+            await subscriber.save()
+            return
+
         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)
 
-    async def create_subscription(self, subscription: domain.Subscription) -> domain.Subscription:
+    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(
+    async def create_placement_views_history(self, history: domain.PlacementViewsHistory) -> None:
-        self, history: domain.PlacementViewsHistory
-    ) -> domain.PlacementViewsHistory:
         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
 

src/adapter/telegram_bot.py

@@ -1,5 +1,4 @@
 import logging
-from typing import Any
 
 from aiogram.types import BotCommand, InlineKeyboardButton, InlineKeyboardMarkup
 
@@ -16,10 +15,6 @@ class TelegramBot(TelegramBase):
         keyboard = InlineKeyboardMarkup(inline_keyboard=[[InlineKeyboardButton(text=button_text, url=button_url)]])
         await self.bot.send_message(chat_id=chat_id, text=text, reply_markup=keyboard)
 
-    async def get_chat_member(self, chat_id: int, user_id: int) -> dict[str, Any]:
-        member = await self.bot.get_chat_member(chat_id=chat_id, user_id=user_id)
-        return member.model_dump()
-
     async def create_chat_invite_link(self, chat_id: int, requires_approval: bool = False) -> str:
         invite_link = await self.bot.create_chat_invite_link(chat_id=chat_id, creates_join_request=requires_approval)
         return invite_link.invite_link

src/usecase/__init__.py

@@ -50,11 +50,11 @@ class Database(typing.Protocol):
 
     async def get_user(self, user_id: UUID | None = None, telegram_id: int | None = None) -> domain.User | None: ...
 
-    async def create_user(self, user: domain.User) -> domain.User: ...
+    async def create_user(self, user: domain.User) -> None: ...
 
-    async def create_login_token(
+    async def create_login_token(self, login_token: domain.LoginToken) -> None: ...
-        self, user_id: UUID, token: str, expires_at: datetime.datetime
+
-    ) -> domain.LoginToken: ...
+    async def create_creative(self, creative: domain.Creative) -> None: ...
 
     async def get_login_token(self, token: str) -> domain.LoginToken | None: ...
 
@@ -64,17 +64,17 @@ class Database(typing.Protocol):
         self, user_id: UUID, channel_id: UUID | None = None, telegram_id: int | None = None
     ) -> domain.TargetChannel | None: ...
 
-    async def upsert_target_channel(self, channel: domain.TargetChannel) -> domain.TargetChannel: ...
+    async def upsert_target_channel(self, channel: domain.TargetChannel) -> None: ...
 
     async def get_user_target_channels(self, user_id: UUID) -> list[domain.TargetChannel]: ...
 
-    async def update_target_channel(self, channel: domain.TargetChannel) -> domain.TargetChannel: ...
+    async def update_target_channel(self, channel: domain.TargetChannel) -> None: ...
 
     async def get_external_channel(
         self, user_id: UUID, channel_id: UUID | None = None, telegram_id: int | None = None
     ) -> domain.ExternalChannel | None: ...
 
-    async def create_external_channel(self, channel: domain.ExternalChannel) -> domain.ExternalChannel: ...
+    async def create_external_channel(self, channel: domain.ExternalChannel) -> None: ...
 
     async def get_external_channels_for_target(self, target_channel_id: UUID) -> list[domain.ExternalChannel]: ...
 
@@ -88,13 +88,11 @@ class Database(typing.Protocol):
 
     async def delete_external_channel(self, channel_id: UUID) -> None: ...
 
-    async def update_external_channel(self, channel: domain.ExternalChannel) -> domain.ExternalChannel: ...
+    async def update_external_channel(self, channel: domain.ExternalChannel) -> None: ...
 
     async def get_creative(self, user_id: UUID, creative_id: UUID) -> domain.Creative | None: ...
 
-    async def create_creative(self, creative: domain.Creative) -> domain.Creative: ...
+    async def update_creative(self, creative: domain.Creative) -> None: ...
-
-    async def update_creative(self, creative: domain.Creative) -> domain.Creative: ...
 
     async def get_user_creatives(
         self, user_id: UUID, target_channel_id: UUID | None = None, include_archived: bool = False
@@ -104,9 +102,9 @@ class Database(typing.Protocol):
 
     async def get_placement(self, user_id: UUID, placement_id: UUID) -> domain.Placement | None: ...
 
-    async def create_placement(self, placement: domain.Placement) -> domain.Placement: ...
+    async def create_placement(self, placement: domain.Placement) -> None: ...
 
-    async def update_placement(self, placement: domain.Placement) -> domain.Placement: ...
+    async def update_placement(self, placement: domain.Placement) -> None: ...
 
     async def get_user_placements(
         self,
@@ -123,17 +121,15 @@ class Database(typing.Protocol):
 
     async def get_subscriber(self, telegram_id: int) -> domain.Subscriber | None: ...
 
-    async def create_subscriber(self, subscriber: domain.Subscriber) -> domain.Subscriber: ...
+    async def upsert_subscriber(self, subscriber: domain.Subscriber) -> None: ...
 
-    async def upsert_subscriber(self, subscriber: domain.Subscriber) -> domain.Subscriber: ...
+    async def create_subscription(self, subscription: domain.Subscription) -> None: ...
-
-    async def create_subscription(self, subscription: domain.Subscription) -> domain.Subscription: ...
 
     async def get_subscription_by_subscriber_and_placement(
         self, subscriber_id: UUID, placement_id: UUID
     ) -> domain.Subscription | None: ...
 
-    async def update_subscription(self, subscription: domain.Subscription) -> domain.Subscription: ...
+    async def update_subscription(self, subscription: domain.Subscription) -> None: ...
 
     async def get_active_subscriptions_by_subscriber_and_channel(
         self, subscriber_id: UUID, channel_telegram_id: int
@@ -143,9 +139,7 @@ class Database(typing.Protocol):
         self, subscriber_id: UUID, channel_telegram_id: int
     ) -> domain.Subscription | None: ...
 
-    async def create_placement_views_history(
+    async def create_placement_views_history(self, history: domain.PlacementViewsHistory) -> None: ...
-        self, history: domain.PlacementViewsHistory
-    ) -> domain.PlacementViewsHistory: ...
 
     async def get_views_history(
         self,
@@ -163,17 +157,6 @@ class Database(typing.Protocol):
 
     async def clear_telegram_state(self, telegram_id: int) -> None: ...
 
-    # NATS-related methods for placement tracking
-    async def get_placement_by_id(self, placement_id: UUID) -> domain.Placement | None: ...
-
-    async def update_placement_from_post_found(
-        self, placement_id: UUID, ad_post_url: str, message_id: int, views_count: int
-    ) -> domain.Placement: ...
-
-    async def update_placement_from_post_deleted(self, placement_id: UUID) -> domain.Placement: ...
-
-    async def update_placement_views(self, placement_id: UUID, views_count: int) -> domain.Placement: ...
-
 
 class TelegramBotWriter(typing.Protocol):
     async def send_message(self, text: str, chat_id: int) -> None: ...
@@ -186,8 +169,6 @@ class TelegramBotWriter(typing.Protocol):
 
     async def edit_message_reply_markup(self, chat_id: int, message_id: int) -> None: ...
 
-    async def get_chat_member(self, chat_id: int, user_id: int) -> dict[str, typing.Any]: ...
-
     async def create_chat_invite_link(self, chat_id: int, requires_approval: bool = False) -> str: ...
 
 

src/usecase/analytics/get_creatives_analytics.py

@@ -14,19 +14,13 @@ log = logging.getLogger(__name__)
 async def get_creatives_analytics(
     self: 'Usecase', input: dto.GetCreativesAnalyticsInput
 ) -> dto.GetCreativesAnalyticsOutput:
-    async with self.database.transaction():
     if input.target_channel_id:
         target_channel = await self.database.get_target_channel(input.user_id, input.target_channel_id)
         if not target_channel:
             raise domain.TargetChannelNotFound(input.target_channel_id)
 
-        creatives = await self.database.get_user_creatives(
+    creatives = await self.database.get_user_creatives(input.user_id, input.target_channel_id, include_archived=False)
-            input.user_id, input.target_channel_id, include_archived=False
+    placements = await self.database.get_user_placements(input.user_id, input.target_channel_id, include_archived=False)
-        )
-
-        placements = await self.database.get_user_placements(
-            input.user_id, input.target_channel_id, include_archived=False
-        )
 
     @dataclass
     class CreativeStats:
@@ -57,9 +51,7 @@ async def get_creatives_analytics(
             else None
         )
         avg_cpm = (
-                (stats.total_cost / stats.total_views * 1000)
+            (stats.total_cost / stats.total_views * 1000) if stats.total_views > 0 and stats.total_cost > 0 else None
-                if stats.total_views > 0 and stats.total_cost > 0
-                else None
         )
 
         result.append(

src/usecase/analytics/get_external_channels_analytics.py

@@ -14,7 +14,6 @@ log = logging.getLogger(__name__)
 async def get_external_channels_analytics(
     self: 'Usecase', input: dto.GetExternalChannelsAnalyticsInput
 ) -> dto.GetExternalChannelsAnalyticsOutput:
-    async with self.database.transaction():
     if input.target_channel_id:
         target_channel = await self.database.get_target_channel(input.user_id, input.target_channel_id)
         if not target_channel:
@@ -23,9 +22,7 @@ async def get_external_channels_analytics(
     else:
         external_channels = await self.database.get_user_external_channels(input.user_id)
 
-        placements = await self.database.get_user_placements(
+    placements = await self.database.get_user_placements(input.user_id, input.target_channel_id, include_archived=False)
-            input.user_id, input.target_channel_id, include_archived=False
-        )
 
     @dataclass
     class ChannelStats:
@@ -56,9 +53,7 @@ async def get_external_channels_analytics(
             else None
         )
         avg_cpm = (
-                (stats.total_cost / stats.total_views * 1000)
+            (stats.total_cost / stats.total_views * 1000) if stats.total_views > 0 and stats.total_cost > 0 else None
-                if stats.total_views > 0 and stats.total_cost > 0
-                else None
         )
 
         result.append(

src/usecase/analytics/get_placements_analytics.py

@@ -24,15 +24,12 @@ def _calculate_cpm(cost: float | None, views: int | None) -> float | None:
 async def get_placements_analytics(
     self: 'Usecase', input: dto.GetPlacementsAnalyticsInput
 ) -> dto.GetPlacementsAnalyticsOutput:
-    async with self.database.transaction():
     if input.target_channel_id:
         target_channel = await self.database.get_target_channel(input.user_id, input.target_channel_id)
         if not target_channel:
             raise domain.TargetChannelNotFound(input.target_channel_id)
 
-        placements = await self.database.get_user_placements(
+    placements = await self.database.get_user_placements(input.user_id, input.target_channel_id, include_archived=False)
-            input.user_id, input.target_channel_id, include_archived=False
-        )
 
     result = [
         dto.PlacementAnalyticsOutput(

src/usecase/analytics/get_spending_analytics.py

@@ -33,15 +33,12 @@ def _format_period(dt: 'datetime.datetime', grouping: dto.DateGrouping) -> str:
 async def get_spending_analytics(
     self: 'Usecase', input: dto.GetSpendingAnalyticsInput
 ) -> dto.GetSpendingAnalyticsOutput:
-    async with self.database.transaction():
     if input.target_channel_id:
         target_channel = await self.database.get_target_channel(input.user_id, input.target_channel_id)
         if not target_channel:
             raise domain.TargetChannelNotFound(input.target_channel_id)
 
-        placements = await self.database.get_user_placements(
+    placements = await self.database.get_user_placements(input.user_id, input.target_channel_id, include_archived=False)
-            input.user_id, input.target_channel_id, include_archived=False
-        )
 
     filtered = [
         p

src/usecase/auth/get_me.py

@@ -8,7 +8,6 @@ if typing.TYPE_CHECKING:
 
 
 async def get_me(self: 'Usecase', user_id: uuid.UUID) -> dto.UserOutput:
-    async with self.database.transaction():
     user = await self.database.get_user(user_id=user_id)
 
     if not user:

src/usecase/auth/telegram_login.py

@@ -2,6 +2,8 @@ import datetime
 import secrets
 import typing
 
+from tortoise import timezone
+
 from src import domain, dto
 from src.config import settings
 
@@ -10,27 +12,29 @@ if typing.TYPE_CHECKING:
 
 
 async def telegram_login(self: 'Usecase', input: dto.TelegramLoginInput) -> None:
-    async with self.database.transaction():
+    user = await self.database.get_user(telegram_id=input.telegram_id)
-        user: domain.User | None = await self.database.get_user(telegram_id=input.telegram_id)
-
     if not user:
         user = domain.User(
             telegram_id=input.telegram_id,
             username=input.username,
         )
-            user = await self.database.create_user(user)
+        await self.database.create_user(user)
 
     token = secrets.token_urlsafe(32)
-        expires_at = datetime.datetime.now(datetime.UTC) + datetime.timedelta(minutes=10)
+    expires_at = timezone.now() + datetime.timedelta(minutes=10)
 
-        await self.database.create_login_token(user.id, token, expires_at)
+    login_token = domain.LoginToken(
+        token=token,
+        user=user,
+        expires_at=expires_at,
+    )
+    await self.database.create_login_token(login_token)
 
-    login_url = f'{settings.app.URL}{token}'
+    login_url = f'{settings.app.URL}{login_token.token}'
 
-    username_display = f'@{user.username}' if user.username else 'пользователь'
     await self.telegram_bot.send_message_with_button(
-        f'Привет, {username_display}!\n\nНажми кнопку ниже для входа на сайт.',
+        f'Привет, {user.username or "аноним"}!\n\nНажми кнопку ниже для входа на сайт.',
-        chat_id=input.chat_id,
+        input.chat_id,
         button_text='Войти на сайт',
         button_url=login_url,
     )

src/usecase/auth/telegram_start.py

@@ -8,13 +8,12 @@ log = logging.getLogger(__name__)
 
 
 async def telegram_start(self: 'Usecase', telegram_id: int, chat_id: int) -> None:
-    async with self.database.transaction():
     user = await self.database.get_user(telegram_id=telegram_id)
 
-        if user:
+    if not user:
-            username_display = f'@{user.username}' if user.username else 'пользователь'
-            message = f'Привет, {username_display}! 👋\n\nДоступные команды:\n/new_creative - Создать новый креатив'
-        else:
         message = 'Привет! 👋\n\nДля работы с ботом необходимо авторизоваться через веб-интерфейс.'
+        await self.telegram_bot.send_message(message, chat_id)
+        return
 
-        await self.telegram_bot.send_message(message, chat_id=chat_id)
+    message = f'Привет, {user.username or "аноним"}! 👋\n\nДоступные команды:\n/new_creative - Создать новый креатив'
+    await self.telegram_bot.send_message(message, chat_id)

src/usecase/auth/validate_login_token.py

@@ -1,6 +1,7 @@
-import datetime
 import typing
 
+from tortoise import timezone
+
 from src import domain, dto
 
 if typing.TYPE_CHECKING:
@@ -8,7 +9,6 @@ if typing.TYPE_CHECKING:
 
 
 async def validate_login_token(self: 'Usecase', input: dto.ValidateLoginTokenInput) -> dto.ValidateLoginTokenOutput:
-    async with self.database.transaction():
     login_token = await self.database.get_login_token(input.token)
 
     if not login_token:
@@ -17,7 +17,7 @@ async def validate_login_token(self: 'Usecase', input: dto.ValidateLoginTokenInp
     if login_token.used_at:
         raise domain.LoginTokenAlreadyUsed()
 
-        if login_token.expires_at < datetime.datetime.now(datetime.UTC):
+    if login_token.expires_at < timezone.now():
         raise domain.LoginTokenExpired()
 
     user = await self.database.get_user(user_id=login_token.user_id)
@@ -26,7 +26,6 @@ async def validate_login_token(self: 'Usecase', input: dto.ValidateLoginTokenInp
 
     await self.database.mark_token_as_used(input.token)
 
-    # Генерируем JWT токен с информацией о пользователе
     access_token = self.jwt_encoder.encode_access_token(
         user_id=user.id,
         telegram_id=user.telegram_id,

src/usecase/creative/create_creative.py

@@ -11,12 +11,9 @@ log = logging.getLogger(__name__)
 
 
 async def create_creative(self: 'Usecase', input: dto.CreateCreativeInput, user_id: uuid.UUID) -> dto.CreativeOutput:
-    async with self.database.transaction():
     target_channel = await self.database.get_target_channel(user_id, channel_id=input.target_channel_id)
     if not target_channel:
-            log.warning(
+        log.warning('User %s attempted to create creative for unavailable target %s', user_id, input.target_channel_id)
-                'User %s attempted to create creative for unavailable target %s', user_id, input.target_channel_id
-            )
         raise domain.TargetChannelNotFound(input.target_channel_id)
 
     creative = domain.Creative(
@@ -27,15 +24,15 @@ async def create_creative(self: 'Usecase', input: dto.CreateCreativeInput, user_
         user_id=user_id,
     )
 
-        created = await self.database.create_creative(creative)
+    await self.database.create_creative(creative)
 
     return dto.CreativeOutput(
-            id=created.id,
+        id=creative.id,
-            name=created.name,
+        name=creative.name,
-            text=created.text,
+        text=creative.text,
-            target_channel_id=created.target_channel_id,
+        target_channel_id=target_channel.id,
-            target_channel_title=created.target_channel.title,
+        target_channel_title=target_channel.title,
-            created_at=created.created_at,
+        created_at=creative.created_at,
-            status=created.status,
+        status=creative.status,
-            placements_count=created.placements_count,
+        placements_count=creative.placements_count,
     )

src/usecase/creative/delete_creative.py

@@ -10,7 +10,6 @@ log = logging.getLogger(__name__)
 
 
 async def delete_creative(self: 'Usecase', input: dto.DeleteCreativeInput) -> None:
-    async with self.database.transaction():
     creative = await self.database.get_creative(input.user_id, input.creative_id)
     if not creative:
         log.warning('User %s attempted to delete unavailable creative %s', input.user_id, input.creative_id)

src/usecase/creative/get_creative.py

@@ -10,7 +10,6 @@ log = logging.getLogger(__name__)
 
 
 async def get_creative(self: 'Usecase', input: dto.GetCreativeInput) -> dto.CreativeOutput:
-    async with self.database.transaction():
     creative = await self.database.get_creative(input.user_id, input.creative_id)
     if not creative:
         log.warning('User %s attempted to access unavailable creative %s', input.user_id, input.creative_id)

src/usecase/creative/get_creatives.py

@@ -7,10 +7,7 @@ if TYPE_CHECKING:
 
 
 async def get_creatives(self: 'Usecase', input: dto.GetCreativesInput) -> dto.GetCreativesOutput:
-    async with self.database.transaction():
+    creatives = await self.database.get_user_creatives(input.user_id, input.target_channel_id, input.include_archived)
-        creatives = await self.database.get_user_creatives(
-            input.user_id, target_channel_id=input.target_channel_id, include_archived=input.include_archived
-        )
 
     return dto.GetCreativesOutput(
         creatives=[

src/usecase/creative/handle_creative_callback.py

@@ -13,7 +13,6 @@ log = logging.getLogger(__name__)
 async def handle_creative_callback(
     self: 'Usecase', telegram_id: int, chat_id: int, callback_data: str, message_id: int
 ) -> None:
-    async with self.database.transaction():
     state = await self.database.get_telegram_state(telegram_id)
     if not state or state.state != domain.TelegramStateEnum.CREATIVE_WAITING_CHANNEL:
         log.debug('User %s has no active creative creation flow or wrong state', telegram_id)
@@ -32,24 +31,22 @@ async def handle_creative_callback(
 
     user = await self.database.get_user(telegram_id=telegram_id)
     if not user:
-            await self.telegram_bot.send_message('❌ Ошибка: пользователь не найден.', chat_id=chat_id)
+        await self.telegram_bot.send_message('❌ Ошибка: пользователь не найден.', chat_id)
         await self.database.clear_telegram_state(telegram_id)
         return
 
     channel = await self.database.get_target_channel(user.id, channel_id=channel_id)
     if not channel:
-            await self.telegram_bot.send_message('❌ Канал не найден или не принадлежит вам.', chat_id=chat_id)
+        await self.telegram_bot.send_message('❌ Канал не найден или не принадлежит вам.', chat_id)
         await self.database.clear_telegram_state(telegram_id)
         return
 
     await self.database.set_telegram_state(
-            telegram_id=telegram_id,
+        telegram_id,
-            state=domain.TelegramStateEnum.CREATIVE_WAITING_NAME,
+        domain.TelegramStateEnum.CREATIVE_WAITING_NAME,
-            context={'target_channel_id': str(channel_id), 'channel_title': channel.title},
+        {'target_channel_id': str(channel_id), 'channel_title': channel.title},
     )
 
     await self.telegram_bot.edit_message_reply_markup(chat_id, message_id)
 
-        await self.telegram_bot.send_message(
+    await self.telegram_bot.send_message(f'✅ Канал выбран: {channel.title}\n\n📝 Введите название креатива:', chat_id)
-            f'✅ Канал выбран: {channel.title}\n\n📝 Введите название креатива:', chat_id=chat_id
-        )

src/usecase/creative/handle_creative_text_input.py

@@ -13,35 +13,28 @@ log = logging.getLogger(__name__)
 
 
 async def handle_creative_text_input(
-    self: 'Usecase',
+    self: 'Usecase', telegram_id: int, chat_id: int, text: str, text_html: str | None = None
-    telegram_id: int,
-    chat_id: int,
-    text: str,
-    text_html: str | None = None,
 ) -> None:
-    async with self.database.transaction():
     state = await self.database.get_telegram_state(telegram_id)
     if not state:
         return
 
     user = await self.database.get_user(telegram_id=telegram_id)
     if not user:
-            await self.telegram_bot.send_message('❌ Ошибка: пользователь не найден.', chat_id=chat_id)
+        await self.telegram_bot.send_message('❌ Ошибка: пользователь не найден.', chat_id)
         await self.database.clear_telegram_state(telegram_id)
         return
 
     if state.state == domain.TelegramStateEnum.CREATIVE_WAITING_NAME:
         await self.database.set_telegram_state(
-                telegram_id=telegram_id,
+            telegram_id, domain.TelegramStateEnum.CREATIVE_WAITING_TEXT, {**state.context, 'creative_name': text}
-                state=domain.TelegramStateEnum.CREATIVE_WAITING_TEXT,
-                context={**state.context, 'creative_name': text},
         )
         await self.telegram_bot.send_message(
             '✅ Название сохранено!\n\n'
             '💬 Теперь отправьте или перешлите текст креатива.\n'
             'Используйте {link} для обозначения места вставки ссылки на ваш канал.\n'
             'Вы также можете указать текст ссылки в формате [текст]{link}.',
-                chat_id=chat_id,
+            chat_id,
         )
 
     elif state.state == domain.TelegramStateEnum.CREATIVE_WAITING_TEXT:
@@ -50,7 +43,7 @@ async def handle_creative_text_input(
 
         if not target_channel_id_str or not creative_name:
             log.error('Missing context data for creative creation: %s', state.context)
-                await self.telegram_bot.send_message('❌ Ошибка: данные не найдены. Начните заново.', chat_id=chat_id)
+            await self.telegram_bot.send_message('❌ Ошибка: данные не найдены. Начните заново.', chat_id)
             await self.database.clear_telegram_state(telegram_id)
             return
 
@@ -58,13 +51,13 @@ async def handle_creative_text_input(
             target_channel_id = uuid.UUID(target_channel_id_str)
         except ValueError:
             log.error('Invalid target_channel_id in context: %s', target_channel_id_str)
-                await self.telegram_bot.send_message('❌ Ошибка: неверный формат данных.', chat_id=chat_id)
+            await self.telegram_bot.send_message('❌ Ошибка: неверный формат данных.', chat_id)
             await self.database.clear_telegram_state(telegram_id)
             return
 
         channel = await self.database.get_target_channel(user.id, channel_id=target_channel_id)
         if not channel:
-                await self.telegram_bot.send_message('❌ Канал не найден.', chat_id=chat_id)
+            await self.telegram_bot.send_message('❌ Канал не найден.', chat_id)
             await self.database.clear_telegram_state(telegram_id)
             return
 
@@ -79,18 +72,18 @@ async def handle_creative_text_input(
             target_channel_id=target_channel_id,
         )
 
-            created = await self.database.create_creative(creative)
+        async with self.database.transaction():
-
+            await self.database.create_creative(creative)
             await self.database.clear_telegram_state(telegram_id)
 
         text_preview_source = text
         text_preview = text_preview_source[:100] + '...' if len(text_preview_source) > 100 else text_preview_source
         await self.telegram_bot.send_message(
             f'✅ Креатив успешно создан!\n\n'
-                f'📝 Название: {created.name}\n'
+            f'📝 Название: {creative.name}\n'
             f'📢 Канал: {channel.title}\n\n'
             f'💬 Текст:\n{text_preview}',
-                chat_id=chat_id,
+            chat_id,
         )
 
     else:

src/usecase/creative/start_creative_creation.py

@@ -12,32 +12,22 @@ log = logging.getLogger(__name__)
 
 
 async def start_creative_creation(self: 'Usecase', telegram_id: int, chat_id: int) -> None:
-    async with self.database.transaction():
     user = await self.database.get_user(telegram_id=telegram_id)
     if not user:
-            await self.telegram_bot.send_message(
+        await self.telegram_bot.send_message('❌ Вы не авторизованы. Используйте /start для входа.', chat_id)
-                '❌ Вы не авторизованы. Используйте /start для входа.', chat_id=chat_id
-            )
         return
 
     channels = await self.database.get_user_target_channels(user.id)
-
     if not channels:
         await self.telegram_bot.send_message(
-                '❌ У вас нет подключенных каналов. Добавьте бота в свой канал для начала работы.', chat_id=chat_id
+            '❌ У вас нет подключенных каналов. Добавьте бота в свой канал для начала работы.', chat_id
         )
         return
 
-        buttons = [
+    buttons = [[InlineKeyboardButton(text=channel.title, callback_data=f'cc_ch:{channel.id}')] for channel in channels]
-            [InlineKeyboardButton(text=channel.title, callback_data=f'cc_ch:{channel.id}')] for channel in channels
-        ]
 
     await self.telegram_bot.send_message_with_inline_keyboard(
-            '✨ Создание нового креатива\n\nВыберите канал, для которого создается креатив:',
+        '✨ Создание нового креатива\n\nВыберите канал, для которого создается креатив:', chat_id, buttons
-            chat_id=chat_id,
-            buttons=buttons,
     )
 
-        await self.database.set_telegram_state(
+    await self.database.set_telegram_state(telegram_id, domain.TelegramStateEnum.CREATIVE_WAITING_CHANNEL, context={})
-            telegram_id=telegram_id, state=domain.TelegramStateEnum.CREATIVE_WAITING_CHANNEL, context={}
-        )

src/usecase/creative/update_creative.py

@@ -13,28 +13,27 @@ log = logging.getLogger(__name__)
 async def update_creative(
     self: 'Usecase', creative_id: uuid.UUID, input: dto.UpdateCreativeInput, user_id: uuid.UUID
 ) -> dto.CreativeOutput:
-    async with self.database.transaction():
     creative = await self.database.get_creative(user_id, creative_id)
     if not creative:
         log.warning('User %s attempted to update unavailable creative %s', user_id, creative_id)
         raise domain.CreativeNotFound(creative_id)
 
-        if input.name is not None:
+    if input.name:
         creative.name = input.name
-        if input.text is not None:
+    if input.text:
         creative.text = input.text
-        if input.status is not None:
+    if input.status:
         creative.status = input.status
 
-        updated = await self.database.update_creative(creative)
+    await self.database.update_creative(creative)
 
     return dto.CreativeOutput(
-            id=updated.id,
+        id=creative.id,
-            name=updated.name,
+        name=creative.name,
-            text=updated.text,
+        text=creative.text,
-            target_channel_id=updated.target_channel_id,
+        target_channel_id=creative.target_channel_id,
-            target_channel_title=updated.target_channel.title,
+        target_channel_title=creative.target_channel.title,
-            created_at=updated.created_at,
+        created_at=creative.created_at,
-            status=updated.status,
+        status=creative.status,
-            placements_count=updated.placements_count,
+        placements_count=creative.placements_count,
     )

src/usecase/external_channel/create_external_channel.py

@@ -13,13 +13,14 @@ log = logging.getLogger(__name__)
 async def create_external_channel(
     self: 'Usecase', input: dto.CreateExternalChannelInput, user_id: uuid.UUID
 ) -> dto.ExternalChannelOutput:
-    async with self.database.transaction():
     for target_id in input.target_channel_ids:
         target_channel = await self.database.get_target_channel(user_id, channel_id=target_id)
+
         if not target_channel:
             log.warning('User %s attempted to add external channel to unavailable target %s', user_id, target_id)
             raise domain.TargetChannelNotFound(target_id)
 
+    async with self.database.transaction():
         channel = domain.ExternalChannel(
             telegram_id=input.telegram_id,
             title=input.title,
@@ -28,20 +29,20 @@ async def create_external_channel(
             subscribers_count=input.subscribers_count,
             user_id=user_id,
         )
-        created_channel = await self.database.create_external_channel(channel)
+        await self.database.create_external_channel(channel)
 
         if input.target_channel_ids:
-            await self.database.add_external_channel_to_targets(created_channel.id, input.target_channel_ids)
+            await self.database.add_external_channel_to_targets(channel.id, input.target_channel_ids)
 
     log.info(
         'External channel %s created and linked to %s target channels', input.telegram_id, len(input.target_channel_ids)
     )
 
     return dto.ExternalChannelOutput(
-        id=created_channel.id,
+        id=channel.id,
-        telegram_id=created_channel.telegram_id,
+        telegram_id=channel.telegram_id,
-        title=created_channel.title,
+        title=channel.title,
-        username=created_channel.username,
+        username=channel.username,
-        description=created_channel.description,
+        description=channel.description,
-        subscribers_count=created_channel.subscribers_count,
+        subscribers_count=channel.subscribers_count,
     )

src/usecase/external_channel/delete_external_channel.py

@@ -10,7 +10,6 @@ log = logging.getLogger(__name__)
 
 
 async def delete_external_channel(self: 'Usecase', input: dto.DeleteExternalChannelInput) -> None:
-    async with self.database.transaction():
     channel = await self.database.get_external_channel(input.user_id, channel_id=input.channel_id)
     if not channel:
         log.warning('User %s attempted to delete unavailable external channel %s', input.user_id, input.channel_id)

src/usecase/external_channel/get_external_channels.py

@@ -10,12 +10,9 @@ log = logging.getLogger(__name__)
 
 
 async def get_external_channels(self: 'Usecase', input: dto.GetExternalChannelsInput) -> dto.GetExternalChannelsOutput:
-    async with self.database.transaction():
     target_channel = await self.database.get_target_channel(input.user_id, channel_id=input.target_channel_id)
     if not target_channel:
-            log.warning(
+        log.warning('Target channel %s not found or not accessible for user %s', input.target_channel_id, input.user_id)
-                'Target channel %s not found or not accessible for user %s', input.target_channel_id, input.user_id
-            )
         raise domain.TargetChannelNotFound(input.target_channel_id)
 
     channels = await self.database.get_external_channels_for_target(input.target_channel_id)

src/usecase/external_channel/update_external_channel.py

@@ -13,7 +13,6 @@ log = logging.getLogger(__name__)
 async def update_external_channel(
     self: 'Usecase', channel_id: uuid.UUID, input: dto.UpdateExternalChannelInput, user_id: uuid.UUID
 ) -> dto.ExternalChannelOutput:
-    async with self.database.transaction():
     external_channel = await self.database.get_external_channel(user_id, channel_id=channel_id)
     if not external_channel:
         log.warning('External channel %s not found', channel_id)
@@ -28,15 +27,15 @@ async def update_external_channel(
     if input.subscribers_count is not None:
         external_channel.subscribers_count = input.subscribers_count
 
-        updated = await self.database.update_external_channel(external_channel)
+    await self.database.update_external_channel(external_channel)
 
     log.info('External channel %s updated', channel_id)
 
     return dto.ExternalChannelOutput(
-            id=updated.id,
+        id=external_channel.id,
-            telegram_id=updated.telegram_id,
+        telegram_id=external_channel.telegram_id,
-            title=updated.title,
+        title=external_channel.title,
-            username=updated.username,
+        username=external_channel.username,
-            description=updated.description,
+        description=external_channel.description,
-            subscribers_count=updated.subscribers_count,
+        subscribers_count=external_channel.subscribers_count,
     )

src/usecase/external_channel/update_external_channel_links.py

@@ -13,7 +13,6 @@ log = logging.getLogger(__name__)
 async def update_external_channel_links(
     self: 'Usecase', channel_id: uuid.UUID, input: dto.UpdateExternalChannelLinksInput, user_id: uuid.UUID
 ) -> dto.ExternalChannelOutput:
-    async with self.database.transaction():
     external_channel = await self.database.get_external_channel(user_id, channel_id=channel_id)
     if not external_channel:
         log.warning('External channel %s not found', channel_id)
@@ -22,11 +21,10 @@ async def update_external_channel_links(
     for target_id in input.add_target_channel_ids:
         target_channel = await self.database.get_target_channel(user_id, channel_id=target_id)
         if not target_channel:
-                log.warning(
+            log.warning('User %s attempted to link external channel to target %s they do not own', user_id, target_id)
-                    'User %s attempted to link external channel to target %s they do not own', user_id, target_id
-                )
             raise domain.TargetChannelNotFound(target_id)
 
+    async with self.database.transaction():
         if input.add_target_channel_ids:
             await self.database.add_external_channel_to_targets(channel_id, input.add_target_channel_ids)
 

src/usecase/placement/create_placement.py

@@ -11,16 +11,11 @@ log = logging.getLogger(__name__)
 
 
 async def create_placement(self: 'Usecase', input: dto.CreatePlacementInput, user_id: uuid.UUID) -> dto.PlacementOutput:
-    async with self.database.transaction():
-        # Проверяем существование целевого канала
     target_channel = await self.database.get_target_channel(user_id, channel_id=input.target_channel_id)
     if not target_channel:
-            log.warning(
+        log.warning('User %s attempted to create placement for unavailable target %s', user_id, input.target_channel_id)
-                'User %s attempted to create placement for unavailable target %s', user_id, input.target_channel_id
-            )
         raise domain.TargetChannelNotFound(input.target_channel_id)
 
-        # Проверяем существование внешнего канала
     external_channel = await self.database.get_external_channel(user_id, channel_id=input.external_channel_id)
     if not external_channel:
         log.warning(
@@ -28,20 +23,14 @@ async def create_placement(self: 'Usecase', input: dto.CreatePlacementInput, use
         )
         raise domain.ExternalChannelNotFound(input.external_channel_id)
 
-        # Проверяем существование креатива
     creative = await self.database.get_creative(user_id, input.creative_id)
     if not creative:
         log.warning('User %s attempted to create placement for unavailable creative %s', user_id, input.creative_id)
         raise domain.CreativeNotFound(input.creative_id)
 
-        # Создаём уникальную пригласительную ссылку через Telegram Bot API
     requires_approval = input.invite_link_type == domain.InviteLinkType.APPROVAL
-        invite_link = await self.telegram_bot.create_chat_invite_link(
+    invite_link = await self.telegram_bot.create_chat_invite_link(target_channel.telegram_id, requires_approval)
-            chat_id=target_channel.telegram_id,
-            requires_approval=requires_approval,
-        )
 
-        # Создаём закуп со статусом PENDING (ожидаем публикацию поста)
     placement = domain.Placement(
         target_channel_id=input.target_channel_id,
         external_channel_id=input.external_channel_id,
@@ -55,30 +44,30 @@ async def create_placement(self: 'Usecase', input: dto.CreatePlacementInput, use
         status=domain.PlacementStatus.PENDING,
     )
 
-        created = await self.database.create_placement(placement)
+    async with self.database.transaction():
+        await self.database.create_placement(placement)
 
-        # Увеличиваем счётчик закупов у креатива
         creative.placements_count += 1
         await self.database.update_creative(creative)
 
     return dto.PlacementOutput(
-            id=created.id,
+        id=placement.id,
-            target_channel_id=created.target_channel_id,
+        target_channel_id=placement.target_channel_id,
         target_channel_title=target_channel.title,
-            external_channel_id=created.external_channel_id,
+        external_channel_id=placement.external_channel_id,
         external_channel_title=external_channel.title,
-            creative_id=created.creative_id,
+        creative_id=placement.creative_id,
         creative_name=creative.name,
-            placement_date=created.placement_date,
+        placement_date=placement.placement_date,
-            cost=created.cost,
+        cost=placement.cost,
-            comment=created.comment,
+        comment=placement.comment,
-            ad_post_url=created.ad_post_url,
+        ad_post_url=placement.ad_post_url,
-            invite_link_type=created.invite_link_type,
+        invite_link_type=placement.invite_link_type,
-            invite_link=created.invite_link,
+        invite_link=placement.invite_link,
-            status=created.status,
+        status=placement.status,
-            subscriptions_count=created.subscriptions_count,
+        subscriptions_count=placement.subscriptions_count,
-            views_count=created.views_count,
+        views_count=placement.views_count,
-            views_availability=created.views_availability,
+        views_availability=placement.views_availability,
-            last_views_fetch_at=created.last_views_fetch_at,
+        last_views_fetch_at=placement.last_views_fetch_at,
-            created_at=created.created_at,
+        created_at=placement.created_at,
     )

src/usecase/placement/delete_placement.py

@@ -10,14 +10,16 @@ log = logging.getLogger(__name__)
 
 
 async def delete_placement(self: 'Usecase', input: dto.DeletePlacementInput) -> None:
-    async with self.database.transaction():
     placement = await self.database.get_placement(input.user_id, input.placement_id)
     if not placement:
         log.warning('Placement %s not found for user %s', input.placement_id, input.user_id)
         raise domain.PlacementNotFound(input.placement_id)
 
-        # Уменьшаем счётчик закупов у креатива, если закуп был активным
+    if placement.status != domain.PlacementStatus.ACTIVE:
-        if placement.status == domain.PlacementStatus.ACTIVE:
+        await self.database.delete_placement(input.placement_id)
+        return
+
+    async with self.database.transaction():
         creative = await self.database.get_creative(input.user_id, placement.creative_id)
         if creative and creative.placements_count > 0:
             creative.placements_count -= 1

src/usecase/placement/get_placement.py

@@ -10,7 +10,6 @@ log = logging.getLogger(__name__)
 
 
 async def get_placement(self: 'Usecase', input: dto.GetPlacementInput) -> dto.PlacementOutput:
-    async with self.database.transaction():
     placement = await self.database.get_placement(input.user_id, input.placement_id)
     if not placement:
         log.warning('Placement %s not found for user %s', input.placement_id, input.user_id)

src/usecase/placement/get_placements.py

@@ -7,7 +7,6 @@ if TYPE_CHECKING:
 
 
 async def get_placements(self: 'Usecase', input: dto.GetPlacementsInput) -> dto.GetPlacementsOutput:
-    async with self.database.transaction():
     placements = await self.database.get_user_placements(
         input.user_id,
         target_channel_id=input.target_channel_id,

src/usecase/placement/update_placement.py

@@ -13,13 +13,11 @@ log = logging.getLogger(__name__)
 async def update_placement(
     self: 'Usecase', placement_id: uuid.UUID, input: dto.UpdatePlacementInput, user_id: uuid.UUID
 ) -> dto.PlacementOutput:
-    async with self.database.transaction():
     placement = await self.database.get_placement(user_id, placement_id)
     if not placement:
         log.warning('Placement %s not found for user %s', placement_id, user_id)
         raise domain.PlacementNotFound(placement_id)
 
-        # Обновляем только те поля, которые были переданы
     if input.placement_date is not None:
         placement.placement_date = input.placement_date
     if input.cost is not None:
@@ -29,26 +27,26 @@ async def update_placement(
     if input.status is not None:
         placement.status = input.status
 
-        updated = await self.database.update_placement(placement)
+    await self.database.update_placement(placement)
 
     return dto.PlacementOutput(
-            id=updated.id,
+        id=placement.id,
-            target_channel_id=updated.target_channel_id,
+        target_channel_id=placement.target_channel_id,
-            target_channel_title=updated.target_channel.title,
+        target_channel_title=placement.target_channel.title,
-            external_channel_id=updated.external_channel_id,
+        external_channel_id=placement.external_channel_id,
-            external_channel_title=updated.external_channel.title,
+        external_channel_title=placement.external_channel.title,
-            creative_id=updated.creative_id,
+        creative_id=placement.creative_id,
-            creative_name=updated.creative.name,
+        creative_name=placement.creative.name,
-            placement_date=updated.placement_date,
+        placement_date=placement.placement_date,
-            cost=updated.cost,
+        cost=placement.cost,
-            comment=updated.comment,
+        comment=placement.comment,
-            ad_post_url=updated.ad_post_url,
+        ad_post_url=placement.ad_post_url,
-            invite_link_type=updated.invite_link_type,
+        invite_link_type=placement.invite_link_type,
-            invite_link=updated.invite_link,
+        invite_link=placement.invite_link,
-            status=updated.status,
+        status=placement.status,
-            subscriptions_count=updated.subscriptions_count,
+        subscriptions_count=placement.subscriptions_count,
-            views_count=updated.views_count,
+        views_count=placement.views_count,
-            views_availability=updated.views_availability,
+        views_availability=placement.views_availability,
-            last_views_fetch_at=updated.last_views_fetch_at,
+        last_views_fetch_at=placement.last_views_fetch_at,
-            created_at=updated.created_at,
+        created_at=placement.created_at,
     )

src/usecase/subscription/handle_subscription.py

@@ -17,7 +17,6 @@ async def handle_subscription(
     first_name: str | None = None,
     last_name: str | None = None,
 ) -> None:
-    async with self.database.transaction():
     placement = await self.database.get_placement_by_invite_link(invite_link)
     if not placement:
         log.warning('Placement not found for invite_link: %s', invite_link)
@@ -29,7 +28,7 @@ async def handle_subscription(
         first_name=first_name,
         last_name=last_name,
     )
-        subscriber = await self.database.upsert_subscriber(subscriber)
+    await self.database.upsert_subscriber(subscriber)
 
     active_subscription = await self.database.get_active_subscription_by_subscriber_and_channel(
         subscriber.id, placement.target_channel.telegram_id
@@ -54,7 +53,7 @@ async def handle_subscription(
     existing_sub = await self.database.get_subscription_by_subscriber_and_placement(subscriber.id, placement.id)
 
     if existing_sub and existing_sub.status == domain.SubscriptionStatus.UNSUBSCRIBED:
-            # Реактивируем старую подписку через тот же placement
+        async with self.database.transaction():
             existing_sub.status = domain.SubscriptionStatus.ACTIVE
             existing_sub.unsubscribed_at = None
             await self.database.update_subscription(existing_sub)
@@ -76,6 +75,7 @@ async def handle_subscription(
         target_channel_id=placement.target_channel_id,
         invite_link=invite_link,
     )
+    async with self.database.transaction():
         await self.database.create_subscription(subscription)
 
         placement.subscriptions_count += 1

src/usecase/subscription/handle_unsubscription.py

@@ -1,7 +1,8 @@
-import datetime
 import logging
 from typing import TYPE_CHECKING
 
+from tortoise import timezone
+
 from src import domain
 
 if TYPE_CHECKING:
@@ -11,7 +12,6 @@ log = logging.getLogger(__name__)
 
 
 async def handle_unsubscription(self: 'Usecase', user_telegram_id: int, channel_telegram_id: int) -> None:
-    async with self.database.transaction():
     subscriber = await self.database.get_subscriber(user_telegram_id)
     if not subscriber:
         log.warning('Subscriber not found for telegram_id: %s', user_telegram_id)
@@ -31,11 +31,11 @@ async def handle_unsubscription(self: 'Usecase', user_telegram_id: int, channel_
         return
 
     for subscription in subscriptions:
+        async with self.database.transaction():
             subscription.status = domain.SubscriptionStatus.UNSUBSCRIBED
-            subscription.unsubscribed_at = datetime.datetime.now(datetime.UTC)
+            subscription.unsubscribed_at = timezone.now()
             await self.database.update_subscription(subscription)
 
-            # Декрементируем счётчик подписок у закупа
             placement = subscription.placement
             if placement.subscriptions_count > 0:
                 placement.subscriptions_count -= 1

src/usecase/target_channel/connect_target_chan.py

@@ -17,7 +17,7 @@ async def connect_target_chan(self: 'Usecase', input: dto.ConnectTargetChanInput
         await self.telegram_bot.send_message(
             f'⚠️ Бот был добавлен в канал "{input.title}", но не является админом.\n\n'
             'Пожалуйста, сделайте бота администратором канала.',
-            chat_id=input.user_telegram_id,
+            input.user_telegram_id,
         )
         raise domain.ChannelNoAdminRights()
 
@@ -37,18 +37,17 @@ async def connect_target_chan(self: 'Usecase', input: dto.ConnectTargetChanInput
             f'⚠️ Бот был добавлен в канал "{input.title}", но не имеет необходимых прав.\n\n'
             f'Отсутствующие права:\n{permissions_text}\n\n'
             'Пожалуйста, предоставьте эти права боту в настройках канала.',
-            chat_id=input.user_telegram_id,
+            input.user_telegram_id,
         )
         raise domain.ChannelNoAdminRights()
 
-    async with self.database.transaction():
     user = await self.database.get_user(telegram_id=input.user_telegram_id)
     if not user:
         log.warning(f'User {input.user_telegram_id} not found when trying to connect channel {input.telegram_id}')
         await self.telegram_bot.send_message(
             f'⚠️ Канал "{input.title}" не может быть подключен.\n\n'
             'Вы должны сначала авторизоваться в веб-панели перед подключением каналов.',
-                chat_id=input.user_telegram_id,
+            input.user_telegram_id,
         )
         raise domain.UserNotFound()
 
@@ -60,19 +59,16 @@ async def connect_target_chan(self: 'Usecase', input: dto.ConnectTargetChanInput
         status=domain.TargetChannelStatus.ACTIVE,
     )
 
-        upserted_channel = await self.database.upsert_target_channel(channel)
+    await self.database.upsert_target_channel(channel)
     log.info(f'Channel {input.telegram_id} connected/updated successfully by user {input.user_telegram_id}')
 
-    await self.telegram_bot.send_message(
+    await self.telegram_bot.send_message(f'✅ Канал "{input.title}" успешно подключен!', input.user_telegram_id)
-        f'✅ Канал "{input.title}" успешно подключен!',
-        chat_id=input.user_telegram_id,
-    )
 
     return dto.ConnectTargetChanOutput(
-        id=upserted_channel.id,
+        id=channel.id,
-        telegram_id=upserted_channel.telegram_id,
+        telegram_id=channel.telegram_id,
-        title=upserted_channel.title,
+        title=channel.title,
-        username=upserted_channel.username,
+        username=channel.username,
-        status=upserted_channel.status,
+        status=channel.status,
-        is_active=upserted_channel.status == domain.TargetChannelStatus.ACTIVE,
+        is_active=channel.status == domain.TargetChannelStatus.ACTIVE,
     )

src/usecase/target_channel/disconnect_target_chan.py

@@ -10,7 +10,6 @@ log = logging.getLogger(__name__)
 
 
 async def disconnect_target_chan(self: 'Usecase', input: dto.DisconnectTargetChanInput) -> None:
-    async with self.database.transaction():
     channel = await self.database.get_target_channel(channel_id=input.channel_id, user_id=input.user_id)
     if not channel:
         raise domain.TargetChannelNotFound(input.channel_id)

src/usecase/target_channel/disconnect_target_chan_by_tg_id.py

@@ -10,7 +10,6 @@ log = logging.getLogger(__name__)
 
 
 async def disconnect_target_chan_by_tg_id(self: 'Usecase', input: dto.DisconnectTargetChanByTgIdInput) -> None:
-    async with self.database.transaction():
     user = await self.database.get_user(telegram_id=input.user_telegram_id)
     if not user:
         log.warning(f'User with telegram_id {input.user_telegram_id} not found when disconnecting channel')

src/usecase/target_channel/get_user_target_chans.py

@@ -7,7 +7,6 @@ if TYPE_CHECKING:
 
 
 async def get_user_target_chans(self: 'Usecase', input: dto.GetUserTargetChansInput) -> dto.GetUserTargetChansOutput:
-    async with self.database.transaction():
     channels = await self.database.get_user_target_channels(input.user_id)
 
     return dto.GetUserTargetChansOutput(

src/usecase/target_channel/update_target_chan_permissions.py

@@ -22,7 +22,6 @@ async def update_target_chan_permissions(self: 'Usecase', input: dto.UpdateTarge
         log.warning(f'User with telegram_id {input.user_telegram_id} not found when updating channel permissions')
         return
 
-    async with self.database.transaction():
     channel = await self.database.get_target_channel(user.id, telegram_id=input.telegram_id)
     if not channel:
         log.warning(f'Target channel {input.telegram_id} not found when permissions changed')
@@ -35,7 +34,7 @@ async def update_target_chan_permissions(self: 'Usecase', input: dto.UpdateTarge
 
             await self.telegram_bot.send_message(
                 f'✅ Канал "{input.chat_title}" был активирован.\n\nВсе необходимые права боту предоставлены!',
-                    chat_id=input.user_telegram_id,
+                input.user_telegram_id,
             )
             log.info(f'Target channel {input.telegram_id} reactivated - all permissions granted')
         return
@@ -48,8 +47,6 @@ async def update_target_chan_permissions(self: 'Usecase', input: dto.UpdateTarge
         await self.telegram_bot.send_message(
             f'⚠️ Канал "{input.chat_title}" был деактивирован.\
             \n\nБоту убрали необходимые права:\n{missed_permissions}',
-                chat_id=input.user_telegram_id,
+            input.user_telegram_id,
-            )
-            log.warning(
-                f'Target channel {input.telegram_id} deactivated due to missing permissions: {missing_permissions}'
         )
+        log.warning(f'Target channel {input.telegram_id} deactivated due to missing permissions: {missing_permissions}')

src/usecase/views/get_views_history.py

@@ -10,8 +10,6 @@ log = logging.getLogger(__name__)
 
 
 async def get_views_history(self: 'Usecase', input: dto.GetViewsHistoryInput) -> dto.GetViewsHistoryOutput:
-    """Получить историю просмотров для закупа."""
-    async with self.database.transaction():
     placement = await self.database.get_placement(input.user_id, input.placement_id)
     if not placement:
         log.warning('Placement %s not found for user %s', input.placement_id, input.user_id)

src/usecase/views/update_views_manually.py

@@ -1,7 +1,8 @@
-import datetime
 import logging
 from typing import TYPE_CHECKING
 
+from tortoise import timezone
+
 from src import domain, dto
 
 if TYPE_CHECKING:
@@ -11,14 +12,14 @@ log = logging.getLogger(__name__)
 
 
 async def update_views_manually(self: 'Usecase', input: dto.UpdateViewsManuallyInput) -> dto.PlacementOutput:
-    async with self.database.transaction():
     placement = await self.database.get_placement(input.user_id, input.placement_id)
     if not placement:
         log.warning('Placement %s not found for user %s', input.placement_id, input.user_id)
         raise domain.PlacementNotFound(input.placement_id)
 
-        fetched_at = datetime.datetime.now(datetime.UTC)
+    fetched_at = timezone.now()
 
+    async with self.database.transaction():
         placement.views_count = input.views_count
         placement.views_availability = domain.PostViewsAvailability.MANUAL
         placement.last_views_fetch_at = fetched_at

tests/conftest.py

@@ -1,430 +0,0 @@
-import datetime
-import uuid
-from contextlib import AbstractAsyncContextManager
-from typing import Any
-from unittest.mock import AsyncMock
-
-import pytest
-
-from src import domain, usecase
-
-
-class MockDatabase:
-    def __init__(self) -> None:
-        self.users: dict[uuid.UUID, domain.User] = {}
-        self.users_by_telegram_id: dict[int, domain.User] = {}
-        self.login_tokens: dict[str, domain.LoginToken] = {}
-        self.target_channels: dict[uuid.UUID, domain.TargetChannel] = {}
-        self.target_channels_by_telegram_id: dict[int, domain.TargetChannel] = {}
-        self.external_channels: dict[uuid.UUID, domain.ExternalChannel] = {}
-        self.creatives: dict[uuid.UUID, domain.Creative] = {}
-        self.placements: dict[uuid.UUID, domain.Placement] = {}
-        self.subscribers: dict[uuid.UUID, domain.Subscriber] = {}
-        self.subscribers_by_telegram_id: dict[int, domain.Subscriber] = {}
-        self.subscriptions: dict[uuid.UUID, domain.Subscription] = {}
-        self.placement_views_histories: dict[uuid.UUID, domain.PlacementViewsHistory] = {}
-        self.m2m_target_external: dict[uuid.UUID, list[uuid.UUID]] = {}
-
-    def transaction(self) -> AbstractAsyncContextManager[None]:
-        return AsyncMock()
-
-    async def get_user(self, *, user_id: uuid.UUID | None = None, telegram_id: int | None = None) -> domain.User | None:
-        if user_id:
-            return self.users.get(user_id)
-        if telegram_id:
-            return self.users_by_telegram_id.get(telegram_id)
-        return None
-
-    async def create_user(self, user: domain.User) -> domain.User:
-        if not user.id:
-            user.id = uuid.uuid4()
-        if not hasattr(user, 'created_at') or user.created_at is None:
-            user.created_at = datetime.datetime.now(datetime.UTC)
-        if not hasattr(user, 'updated_at') or user.updated_at is None:
-            user.updated_at = datetime.datetime.now(datetime.UTC)
-        self.users[user.id] = user
-        self.users_by_telegram_id[user.telegram_id] = user
-        return user
-
-    async def create_login_token(
-        self, user_id: uuid.UUID, token: str, expires_at: datetime.datetime
-    ) -> domain.LoginToken:
-        login_token = domain.LoginToken(user_id=user_id, token=token, expires_at=expires_at, used_at=None)
-        if not login_token.id:
-            login_token.id = uuid.uuid4()
-        if not hasattr(login_token, 'created_at') or login_token.created_at is None:
-            login_token.created_at = datetime.datetime.now(datetime.UTC)
-        if not hasattr(login_token, 'updated_at') or login_token.updated_at is None:
-            login_token.updated_at = datetime.datetime.now(datetime.UTC)
-        self.login_tokens[token] = login_token
-        return login_token
-
-    async def get_login_token(self, token: str) -> domain.LoginToken | None:
-        return self.login_tokens.get(token)
-
-    async def mark_token_as_used(self, token: str) -> None:
-        if token in self.login_tokens:
-            self.login_tokens[token].used_at = datetime.datetime.now(datetime.UTC)
-
-    async def get_target_channel(
-        self, user_id: uuid.UUID, channel_id: uuid.UUID | None = None, telegram_id: int | None = None
-    ) -> domain.TargetChannel | None:
-        if channel_id:
-            channel = self.target_channels.get(channel_id)
-            if channel and channel.user_id == user_id:
-                return channel
-        if telegram_id:
-            channel = self.target_channels_by_telegram_id.get(telegram_id)
-            if channel and channel.user_id == user_id:
-                return channel
-        return None
-
-    async def upsert_target_channel(self, channel: domain.TargetChannel) -> domain.TargetChannel:
-        existing = self.target_channels_by_telegram_id.get(channel.telegram_id)
-        if existing:
-            existing.title = channel.title
-            existing.username = channel.username
-            existing.status = channel.status
-            return existing
-        if not channel.id:
-            channel.id = uuid.uuid4()
-        if not hasattr(channel, 'created_at') or channel.created_at is None:
-            channel.created_at = datetime.datetime.now(datetime.UTC)
-        if not hasattr(channel, 'updated_at') or channel.updated_at is None:
-            channel.updated_at = datetime.datetime.now(datetime.UTC)
-        self.target_channels[channel.id] = channel
-        self.target_channels_by_telegram_id[channel.telegram_id] = channel
-        return channel
-
-    async def get_user_target_channels(self, user_id: uuid.UUID) -> list[domain.TargetChannel]:
-        return [c for c in self.target_channels.values() if c.user_id == user_id]
-
-    async def update_target_channel(self, channel: domain.TargetChannel) -> domain.TargetChannel:
-        self.target_channels[channel.id] = channel
-        return channel
-
-    async def create_external_channel(self, channel: domain.ExternalChannel) -> domain.ExternalChannel:
-        if not channel.id:
-            channel.id = uuid.uuid4()
-        if not hasattr(channel, 'created_at') or channel.created_at is None:
-            channel.created_at = datetime.datetime.now(datetime.UTC)
-        if not hasattr(channel, 'updated_at') or channel.updated_at is None:
-            channel.updated_at = datetime.datetime.now(datetime.UTC)
-        self.external_channels[channel.id] = channel
-        return channel
-
-    async def add_external_channel_to_targets(
-        self, external_channel_id: uuid.UUID, target_channel_ids: list[uuid.UUID]
-    ) -> None:
-        if external_channel_id not in self.m2m_target_external:
-            self.m2m_target_external[external_channel_id] = []
-        self.m2m_target_external[external_channel_id].extend(target_channel_ids)
-
-    async def get_external_channels_for_target(self, target_channel_id: uuid.UUID) -> list[domain.ExternalChannel]:
-        result = []
-        for ext_id, targets in self.m2m_target_external.items():
-            if target_channel_id in targets:
-                ext_ch = self.external_channels.get(ext_id)
-                if ext_ch:
-                    result.append(ext_ch)
-        return result
-
-    async def get_external_channel(
-        self, user_id: uuid.UUID, channel_id: uuid.UUID | None = None, telegram_id: int | None = None
-    ) -> domain.ExternalChannel | None:
-        if channel_id:
-            channel = self.external_channels.get(channel_id)
-            if channel and channel.user_id == user_id:
-                return channel
-        if telegram_id:
-            for channel in self.external_channels.values():
-                if channel.telegram_id == telegram_id and channel.user_id == user_id:
-                    return channel
-        return None
-
-    async def remove_external_channel_from_target(
-        self, external_channel_id: uuid.UUID, target_channel_id: uuid.UUID
-    ) -> None:
-        if external_channel_id in self.m2m_target_external:
-            targets = self.m2m_target_external[external_channel_id]
-            if target_channel_id in targets:
-                targets.remove(target_channel_id)
-
-    async def delete_external_channel(self, channel_id: uuid.UUID) -> None:
-        self.external_channels.pop(channel_id, None)
-        self.m2m_target_external.pop(channel_id, None)
-
-    async def create_creative(self, creative: domain.Creative) -> domain.Creative:
-        if not creative.id:
-            creative.id = uuid.uuid4()
-        if not hasattr(creative, 'created_at') or creative.created_at is None:
-            creative.created_at = datetime.datetime.now(datetime.UTC)
-        if not hasattr(creative, 'updated_at') or creative.updated_at is None:
-            creative.updated_at = datetime.datetime.now(datetime.UTC)
-        if not hasattr(creative, 'placements_count') or creative.placements_count is None:
-            creative.placements_count = 0
-        target_ch = self.target_channels.get(creative.target_channel_id)
-        if target_ch:
-            creative.target_channel = target_ch
-        if not hasattr(creative, 'status') or creative.status is None:
-            creative.status = domain.CreativeStatus.ACTIVE
-        self.creatives[creative.id] = creative
-        return creative
-
-    async def get_creative(self, user_id: uuid.UUID, creative_id: uuid.UUID) -> domain.Creative | None:
-        creative = self.creatives.get(creative_id)
-        if creative and creative.user_id == user_id:
-            return creative
-        return None
-
-    async def update_creative(self, creative: domain.Creative) -> domain.Creative:
-        self.creatives[creative.id] = creative
-        return creative
-
-    async def get_user_creatives(
-        self,
-        user_id: uuid.UUID,
-        *,
-        target_channel_id: uuid.UUID | None = None,
-        include_archived: bool = False,
-    ) -> list[domain.Creative]:
-        result = [c for c in self.creatives.values() if c.user_id == user_id]
-        if target_channel_id:
-            result = [c for c in result if c.target_channel_id == target_channel_id]
-        if not include_archived:
-            result = [c for c in result if c.status == domain.CreativeStatus.ACTIVE]
-        return result
-
-    async def delete_creative(self, creative_id: uuid.UUID) -> None:
-        self.creatives.pop(creative_id, None)
-
-    async def create_placement(self, placement: domain.Placement) -> domain.Placement:
-        if not placement.id:
-            placement.id = uuid.uuid4()
-        if not hasattr(placement, 'created_at') or placement.created_at is None:
-            placement.created_at = datetime.datetime.now(datetime.UTC)
-        if not hasattr(placement, 'updated_at') or placement.updated_at is None:
-            placement.updated_at = datetime.datetime.now(datetime.UTC)
-        if not hasattr(placement, 'subscriptions_count') or placement.subscriptions_count is None:
-            placement.subscriptions_count = 0
-        if not hasattr(placement, 'status') or placement.status is None:
-            placement.status = domain.PlacementStatus.ACTIVE
-        if not hasattr(placement, 'views_availability') or placement.views_availability is None:
-            placement.views_availability = domain.PostViewsAvailability.UNKNOWN
-        # Загружаем связанные объекты
-        target_ch = self.target_channels.get(placement.target_channel_id)
-        if target_ch:
-            placement.target_channel = target_ch
-        ext_ch = self.external_channels.get(placement.external_channel_id)
-        if ext_ch:
-            placement.external_channel = ext_ch
-        creative = self.creatives.get(placement.creative_id)
-        if creative:
-            placement.creative = creative
-        self.placements[placement.id] = placement
-        return placement
-
-    async def get_placement(self, user_id: uuid.UUID, placement_id: uuid.UUID) -> domain.Placement | None:
-        placement = self.placements.get(placement_id)
-        if placement and placement.user_id == user_id:
-            return placement
-        return None
-
-    async def update_placement(self, placement: domain.Placement) -> domain.Placement:
-        self.placements[placement.id] = placement
-        return placement
-
-    async def get_user_placements(
-        self,
-        user_id: uuid.UUID,
-        *,
-        target_channel_id: uuid.UUID | None = None,
-        external_channel_id: uuid.UUID | None = None,
-        creative_id: uuid.UUID | None = None,
-        include_archived: bool = False,
-    ) -> list[domain.Placement]:
-        result = [p for p in self.placements.values() if p.user_id == user_id]
-        if target_channel_id:
-            result = [p for p in result if p.target_channel_id == target_channel_id]
-        if external_channel_id:
-            result = [p for p in result if p.external_channel_id == external_channel_id]
-        if creative_id:
-            result = [p for p in result if p.creative_id == creative_id]
-        if not include_archived:
-            result = [p for p in result if p.status == domain.PlacementStatus.ACTIVE]
-        return sorted(result, key=lambda p: p.placement_date, reverse=True)
-
-    async def delete_placement(self, placement_id: uuid.UUID) -> None:
-        self.placements.pop(placement_id, None)
-
-    async def check_creative_in_use(self, creative_id: uuid.UUID) -> bool:
-        for placement in self.placements.values():
-            if placement.creative_id == creative_id and placement.status == domain.PlacementStatus.ACTIVE:
-                return True
-        return False
-
-    async def get_placement_by_invite_link(self, invite_link: str) -> domain.Placement | None:
-        for placement in self.placements.values():
-            if placement.invite_link == invite_link:
-                return placement
-        return None
-
-    async def get_subscriber(self, telegram_id: int) -> domain.Subscriber | None:
-        return self.subscribers_by_telegram_id.get(telegram_id)
-
-    async def create_subscriber(self, subscriber: domain.Subscriber) -> domain.Subscriber:
-        if not subscriber.id:
-            subscriber.id = uuid.uuid4()
-        if not hasattr(subscriber, 'created_at') or subscriber.created_at is None:
-            subscriber.created_at = datetime.datetime.now(datetime.UTC)
-        if not hasattr(subscriber, 'updated_at') or subscriber.updated_at is None:
-            subscriber.updated_at = datetime.datetime.now(datetime.UTC)
-        self.subscribers[subscriber.id] = subscriber
-        self.subscribers_by_telegram_id[subscriber.telegram_id] = subscriber
-        return subscriber
-
-    async def upsert_subscriber(self, subscriber: domain.Subscriber) -> domain.Subscriber:
-        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
-            return existing
-        return await self.create_subscriber(subscriber)
-
-    async def create_subscription(self, subscription: domain.Subscription) -> domain.Subscription:
-        if not subscription.id:
-            subscription.id = uuid.uuid4()
-        if not hasattr(subscription, 'created_at') or subscription.created_at is None:
-            subscription.created_at = datetime.datetime.now(datetime.UTC)
-        if not hasattr(subscription, 'updated_at') or subscription.updated_at is None:
-            subscription.updated_at = datetime.datetime.now(datetime.UTC)
-        # Загружаем связанные объекты
-        placement = self.placements.get(subscription.placement_id)
-        if placement:
-            subscription.placement = placement
-        subscriber = self.subscribers.get(subscription.subscriber_id)
-        if subscriber:
-            subscription.subscriber = subscriber
-        self.subscriptions[subscription.id] = subscription
-        return subscription
-
-    async def get_subscription_by_subscriber_and_placement(
-        self, subscriber_id: uuid.UUID, placement_id: uuid.UUID
-    ) -> domain.Subscription | None:
-        for subscription in self.subscriptions.values():
-            if subscription.subscriber_id == subscriber_id and subscription.placement_id == placement_id:
-                return subscription
-        return None
-
-    async def get_active_subscriptions_by_subscriber_and_channel(
-        self, subscriber_id: uuid.UUID, channel_telegram_id: int
-    ) -> list[domain.Subscription]:
-        result = []
-        for subscription in self.subscriptions.values():
-            if subscription.subscriber_id == subscriber_id and subscription.unsubscribed_at is None:
-                placement = self.placements.get(subscription.placement_id)
-                if placement:
-                    target_channel = self.target_channels.get(placement.target_channel_id)
-                    if target_channel and target_channel.telegram_id == channel_telegram_id:
-                        subscription.placement = placement
-                        result.append(subscription)
-        return result
-
-    async def get_active_subscription_by_subscriber_and_channel(
-        self, subscriber_id: uuid.UUID, channel_telegram_id: int
-    ) -> domain.Subscription | None:
-        subscriptions = await self.get_active_subscriptions_by_subscriber_and_channel(
-            subscriber_id, channel_telegram_id
-        )
-        return subscriptions[0] if subscriptions else None
-
-    async def create_placement_views_history(
-        self, history: domain.PlacementViewsHistory
-    ) -> domain.PlacementViewsHistory:
-        if not history.id:
-            history.id = uuid.uuid4()
-        if not hasattr(history, 'created_at') or history.created_at is None:
-            history.created_at = datetime.datetime.now(datetime.UTC)
-        if not hasattr(history, 'updated_at') or history.updated_at is None:
-            history.updated_at = datetime.datetime.now(datetime.UTC)
-        placement = self.placements.get(history.placement_id)
-        if placement:
-            history.placement = placement
-        self.placement_views_histories[history.id] = history
-        return history
-
-    async def get_views_history(
-        self,
-        placement_id: uuid.UUID,
-        *,
-        from_date: datetime.datetime | None = None,
-        to_date: datetime.datetime | None = None,
-    ) -> list[domain.PlacementViewsHistory]:
-        result = [h for h in self.placement_views_histories.values() if h.placement_id == placement_id]
-        if from_date:
-            result = [h for h in result if h.fetched_at >= from_date]
-        if to_date:
-            result = [h for h in result if h.fetched_at <= to_date]
-        return sorted(result, key=lambda h: h.fetched_at)
-
-
-class MockTelegramWriter:
-    def __init__(self) -> None:
-        self.sent_messages: list[dict[str, Any]] = []
-        self.invite_link_counter = 0
-
-    async def send_message(self, text: str, chat_id: int) -> None:
-        self.sent_messages.append({'text': text, 'chat_id': chat_id, 'button': None})
-
-    async def send_message_with_button(self, text: str, chat_id: int, button_text: str, button_url: str) -> None:
-        self.sent_messages.append(
-            {'text': text, 'chat_id': chat_id, 'button': {'text': button_text, 'url': button_url}}
-        )
-
-    async def send_message_with_inline_keyboard(self, text: str, chat_id: int, buttons: list[list[Any]]) -> None:
-        self.sent_messages.append({'text': text, 'chat_id': chat_id, 'inline_keyboard': buttons})
-
-    async def edit_message_reply_markup(self, chat_id: int, message_id: int) -> None:
-        pass
-
-    async def get_chat_member(self, chat_id: int, user_id: int) -> dict[str, Any]:
-        return {}
-
-    async def create_chat_invite_link(self, chat_id: int, requires_approval: bool = False) -> str:
-        self.invite_link_counter += 1
-        link_type = 'approval' if requires_approval else 'public'
-        return f'https://t.me/+{link_type}_link_{self.invite_link_counter}_{chat_id}'
-
-
-class MockJWTEncoder:
-    def encode_access_token(self, user_id: uuid.UUID, telegram_id: int, username: str | None = None) -> str:
-        return f'jwt_token_{user_id}_{telegram_id}'
-
-
-@pytest.fixture
-def mock_database() -> MockDatabase:
-    return MockDatabase()
-
-
-@pytest.fixture
-def mock_telegram() -> MockTelegramWriter:
-    return MockTelegramWriter()
-
-
-@pytest.fixture
-def mock_jwt() -> MockJWTEncoder:
-    return MockJWTEncoder()
-
-
-@pytest.fixture
-def usecases(
-    mock_database: MockDatabase,
-    mock_telegram: MockTelegramWriter,
-    mock_jwt: MockJWTEncoder,
-) -> usecase.Usecase:
-    return usecase.Usecase(
-        database=mock_database,  # type: ignore[arg-type]
-        telegram_bot=mock_telegram,
-        jwt_encoder=mock_jwt,
-    )

tests/test_auth.py

@@ -1,107 +0,0 @@
-"""Тесты авторизации через Telegram."""
-
-import datetime
-
-import pytest
-from fastapi import HTTPException
-
-from src import domain, dto, usecase
-from tests.conftest import MockDatabase, MockTelegramWriter
-
-
-@pytest.mark.asyncio
-async def test_new_user_registration(usecases: usecase.Usecase, mock_telegram: MockTelegramWriter) -> None:
-    """Новый пользователь регистрируется через Telegram."""
-    input_data = dto.TelegramLoginInput(telegram_id=123456, username='testuser', chat_id=123456)
-
-    await usecases.telegram_login(input_data)
-
-    # Проверяем, что пользователь создан
-    user = await usecases.database.get_user(telegram_id=123456)
-    assert user is not None
-    assert user.telegram_id == 123456
-    assert user.username == 'testuser'
-
-    # Проверяем, что бот отправил сообщение с кнопкой
-    assert len(mock_telegram.sent_messages) == 1
-    msg = mock_telegram.sent_messages[0]
-    assert msg['button'] is not None
-    assert 'token=' in msg['button']['url']
-
-
-@pytest.mark.asyncio
-async def test_existing_user_login(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
-    """Существующий пользователь получает токен для входа."""
-    # Создаём пользователя
-    user = domain.User(telegram_id=123456, username='testuser')
-    await mock_database.create_user(user)
-
-    input_data = dto.TelegramLoginInput(telegram_id=123456, username='testuser', chat_id=123456)
-    await usecases.telegram_login(input_data)
-
-    # Проверяем, что не создался второй пользователь
-    users_count = len(mock_database.users)
-    assert users_count == 1
-
-
-@pytest.mark.asyncio
-async def test_validate_login_token_success(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
-    """Валидный токен обменивается на JWT."""
-    user = domain.User(telegram_id=123456, username='testuser')
-    await mock_database.create_user(user)
-
-    token = 'test_token_123'
-    expires_at = datetime.datetime.now(datetime.UTC) + datetime.timedelta(minutes=10)
-    await mock_database.create_login_token(user.id, token, expires_at)
-
-    result = await usecases.validate_login_token(dto.ValidateLoginTokenInput(token=token))
-
-    assert result.access_token.startswith('jwt_token_')
-    assert str(user.id) in result.access_token
-
-    # Проверяем, что токен помечен как использованный
-    login_token = await mock_database.get_login_token(token)
-    assert login_token is not None
-    assert login_token.used_at is not None
-
-
-@pytest.mark.asyncio
-async def test_validate_login_token_not_found(usecases: usecase.Usecase) -> None:
-    """Несуществующий токен вызывает ошибку."""
-    with pytest.raises(HTTPException) as exc_info:
-        await usecases.validate_login_token(dto.ValidateLoginTokenInput(token='nonexistent'))
-    assert exc_info.value.status_code == 404
-    assert 'Login token not found' in str(exc_info.value.detail)
-
-
-@pytest.mark.asyncio
-async def test_validate_login_token_already_used(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
-    """Использованный токен вызывает ошибку."""
-    user = domain.User(telegram_id=123456, username='testuser')
-    await mock_database.create_user(user)
-
-    token = 'test_token_123'
-    expires_at = datetime.datetime.now(datetime.UTC) + datetime.timedelta(minutes=10)
-    await mock_database.create_login_token(user.id, token, expires_at)
-    await mock_database.mark_token_as_used(token)
-
-    with pytest.raises(HTTPException) as exc_info:
-        await usecases.validate_login_token(dto.ValidateLoginTokenInput(token=token))
-    assert exc_info.value.status_code == 400
-    assert 'already been used' in str(exc_info.value.detail)
-
-
-@pytest.mark.asyncio
-async def test_validate_login_token_expired(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
-    """Истекший токен вызывает ошибку."""
-    user = domain.User(telegram_id=123456, username='testuser')
-    await mock_database.create_user(user)
-
-    token = 'test_token_123'
-    expires_at = datetime.datetime.now(datetime.UTC) - datetime.timedelta(minutes=1)
-    await mock_database.create_login_token(user.id, token, expires_at)
-
-    with pytest.raises(HTTPException) as exc_info:
-        await usecases.validate_login_token(dto.ValidateLoginTokenInput(token=token))
-    assert exc_info.value.status_code == 400
-    assert 'expired' in str(exc_info.value.detail)

tests/test_creative_text_formatting.py

@@ -1,24 +0,0 @@
-"""Tests for creative text formatting helpers."""
-
-from src.usecase.creative.text_formatting import prepare_creative_text_html
-
-
-def test_placeholder_is_replaced_with_custom_tag() -> None:
-    source = 'Подписывайтесь: {link}!'
-    assert prepare_creative_text_html(source) == 'Подписывайтесь: <a class="tg-link"></a>!'
-
-
-def test_label_placeholder_is_wrapped() -> None:
-    source = 'Жми [сюда]{link} скорее'
-    assert prepare_creative_text_html(source) == 'Жми <a class="tg-link">сюда</a> скорее'
-
-
-def test_placeholder_replacement_is_case_insensitive() -> None:
-    source = 'Первый {LINK}, второй {Link}.'
-    expected = 'Первый <a class="tg-link"></a>, второй <a class="tg-link"></a>.'
-    assert prepare_creative_text_html(source) == expected
-
-
-def test_plain_html_left_untouched() -> None:
-    source = '<b>Жми</b> и <i>делись</i>'
-    assert prepare_creative_text_html(source) == source

tests/test_creatives.py

@@ -1,244 +0,0 @@
-"""Тесты работы с креативами."""
-
-import pytest
-from fastapi import HTTPException
-
-from src import domain, dto, usecase
-from tests.conftest import MockDatabase
-
-
-@pytest.mark.asyncio
-async def test_create_creative_success(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
-    """Создание нового креатива."""
-    user = domain.User(telegram_id=123456, username='testuser')
-    await mock_database.create_user(user)
-
-    target_channel = domain.TargetChannel(
-        telegram_id=-1001234567890,
-        title='Target Channel',
-        username='targetchannel',
-        user_id=user.id,
-        status=domain.TargetChannelStatus.ACTIVE,
-    )
-    await mock_database.upsert_target_channel(target_channel)
-
-    input_data = dto.CreateCreativeInput(
-        name='Test Creative',
-        text='Приглашаю подписаться на канал: {link}',
-        target_channel_id=target_channel.id,
-    )
-
-    result = await usecases.create_creative(input_data, user.id)
-
-    assert result.name == 'Test Creative'
-    assert result.text == 'Приглашаю подписаться на канал: {link}'
-    assert result.target_channel_id == target_channel.id
-    assert result.status == domain.CreativeStatus.ACTIVE
-    assert result.placements_count == 0
-
-
-@pytest.mark.asyncio
-async def test_create_creative_invalid_target_channel(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
-    """Создание креатива для несуществующего целевого канала вызывает ошибку."""
-    user = domain.User(telegram_id=123456, username='testuser')
-    await mock_database.create_user(user)
-
-    import uuid
-
-    fake_target_id = uuid.uuid4()
-
-    input_data = dto.CreateCreativeInput(
-        name='Test Creative',
-        text='Test text',
-        target_channel_id=fake_target_id,
-    )
-
-    with pytest.raises(HTTPException) as exc_info:
-        await usecases.create_creative(input_data, user.id)
-    assert exc_info.value.status_code == 404
-    assert 'Target channel' in str(exc_info.value.detail)
-
-
-@pytest.mark.asyncio
-async def test_get_user_creatives(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
-    """Получение списка креативов пользователя."""
-    user = domain.User(telegram_id=123456, username='testuser')
-    await mock_database.create_user(user)
-
-    target_channel = domain.TargetChannel(
-        telegram_id=-1001234567890,
-        title='Target Channel',
-        username='targetchannel',
-        user_id=user.id,
-        status=domain.TargetChannelStatus.ACTIVE,
-    )
-    await mock_database.upsert_target_channel(target_channel)
-
-    creative1 = domain.Creative(
-        name='Creative 1',
-        text='Text 1',
-        target_channel_id=target_channel.id,
-        user_id=user.id,
-        status=domain.CreativeStatus.ACTIVE,
-    )
-    creative2 = domain.Creative(
-        name='Creative 2',
-        text='Text 2',
-        target_channel_id=target_channel.id,
-        user_id=user.id,
-        status=domain.CreativeStatus.ACTIVE,
-    )
-    await mock_database.create_creative(creative1)
-    await mock_database.create_creative(creative2)
-
-    result = await usecases.get_creatives(dto.GetCreativesInput(user_id=user.id))
-
-    assert len(result.creatives) == 2
-
-
-@pytest.mark.asyncio
-async def test_get_creatives_filtered_by_target_channel(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
-    """Получение креативов для конкретного целевого канала."""
-    user = domain.User(telegram_id=123456, username='testuser')
-    await mock_database.create_user(user)
-
-    target1 = domain.TargetChannel(
-        telegram_id=-1001234567890,
-        title='Target 1',
-        username='target1',
-        user_id=user.id,
-        status=domain.TargetChannelStatus.ACTIVE,
-    )
-    target2 = domain.TargetChannel(
-        telegram_id=-1001234567891,
-        title='Target 2',
-        username='target2',
-        user_id=user.id,
-        status=domain.TargetChannelStatus.ACTIVE,
-    )
-    await mock_database.upsert_target_channel(target1)
-    await mock_database.upsert_target_channel(target2)
-
-    creative1 = domain.Creative(
-        name='Creative 1',
-        text='Text 1',
-        target_channel_id=target1.id,
-        user_id=user.id,
-        status=domain.CreativeStatus.ACTIVE,
-    )
-    creative2 = domain.Creative(
-        name='Creative 2',
-        text='Text 2',
-        target_channel_id=target2.id,
-        user_id=user.id,
-        status=domain.CreativeStatus.ACTIVE,
-    )
-    await mock_database.create_creative(creative1)
-    await mock_database.create_creative(creative2)
-
-    result = await usecases.get_creatives(dto.GetCreativesInput(user_id=user.id, target_channel_id=target1.id))
-
-    assert len(result.creatives) == 1
-    assert result.creatives[0].target_channel_id == target1.id
-
-
-# TODO: Implement archive_creative method
-# @pytest.mark.asyncio
-# async def test_archive_creative(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
-#     """Архивирование креатива."""
-#     user = domain.User(telegram_id=123456, username='testuser')
-#     await mock_database.create_user(user)
-#
-#     target_channel = domain.TargetChannel(
-#         telegram_id=-1001234567890,
-#         title='Target Channel',
-#         username='targetchannel',
-#         user_id=user.id,
-#         status=domain.TargetChannelStatus.ACTIVE,
-#     )
-#     await mock_database.upsert_target_channel(target_channel)
-#
-#     creative = domain.Creative(
-#         name='Test Creative',
-#         text='Test text',
-#         target_channel_id=target_channel.id,
-#         user_id=user.id,
-#         status=domain.CreativeStatus.ACTIVE,
-#     )
-#     await mock_database.create_creative(creative)
-#
-#     result = await usecases.archive_creative(creative.id, user.id)
-#
-#     assert result.status == domain.CreativeStatus.ARCHIVED
-#
-#     # Проверяем, что архивированный креатив не возвращается по умолчанию
-#     creatives_list = await usecases.get_creatives(dto.GetCreativesInput(user_id=user.id))
-#     assert len(creatives_list.creatives) == 0
-#
-#     # Проверяем, что архивированный креатив возвращается с флагом include_archived
-#     creatives_with_archived = await usecases.get_creatives(
-#         dto.GetCreativesInput(user_id=user.id, include_archived=True)
-#     )
-#     assert len(creatives_with_archived.creatives) == 1
-
-
-@pytest.mark.asyncio
-async def test_update_creative(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
-    """Редактирование креатива."""
-    user = domain.User(telegram_id=123456, username='testuser')
-    await mock_database.create_user(user)
-
-    target_channel = domain.TargetChannel(
-        telegram_id=-1001234567890,
-        title='Target Channel',
-        username='targetchannel',
-        user_id=user.id,
-        status=domain.TargetChannelStatus.ACTIVE,
-    )
-    await mock_database.upsert_target_channel(target_channel)
-
-    creative = domain.Creative(
-        name='Old Name',
-        text='Old text',
-        target_channel_id=target_channel.id,
-        user_id=user.id,
-        status=domain.CreativeStatus.ACTIVE,
-    )
-    await mock_database.create_creative(creative)
-
-    update_input = dto.UpdateCreativeInput(name='New Name', text='New text')
-    result = await usecases.update_creative(creative.id, update_input, user.id)
-
-    assert result.name == 'New Name'
-    assert result.text == 'New text'
-
-
-@pytest.mark.asyncio
-async def test_delete_creative(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
-    """Удаление креатива."""
-    user = domain.User(telegram_id=123456, username='testuser')
-    await mock_database.create_user(user)
-
-    target_channel = domain.TargetChannel(
-        telegram_id=-1001234567890,
-        title='Target Channel',
-        username='targetchannel',
-        user_id=user.id,
-        status=domain.TargetChannelStatus.ACTIVE,
-    )
-    await mock_database.upsert_target_channel(target_channel)
-
-    creative = domain.Creative(
-        name='Test Creative',
-        text='Test text',
-        target_channel_id=target_channel.id,
-        user_id=user.id,
-        status=domain.CreativeStatus.ACTIVE,
-    )
-    await mock_database.create_creative(creative)
-
-    await usecases.delete_creative(dto.DeleteCreativeInput(creative_id=creative.id, user_id=user.id))
-
-    # Проверяем, что креатив удалён
-    creatives_list = await usecases.get_creatives(dto.GetCreativesInput(user_id=user.id, include_archived=True))
-    assert len(creatives_list.creatives) == 0

tests/test_external_channels.py

@@ -1,177 +0,0 @@
-"""Тесты каталога внешних каналов."""
-
-import pytest
-from fastapi import HTTPException
-
-from src import domain, dto, usecase
-from tests.conftest import MockDatabase
-
-
-@pytest.mark.asyncio
-async def test_create_external_channel_with_targets(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
-    """Создание внешнего канала с привязкой к целевым каналам."""
-    user = domain.User(telegram_id=123456, username='testuser')
-    await mock_database.create_user(user)
-
-    target_channel = domain.TargetChannel(
-        telegram_id=-1001234567890,
-        title='Target Channel',
-        username='targetchannel',
-        user_id=user.id,
-        status=domain.TargetChannelStatus.ACTIVE,
-    )
-    await mock_database.upsert_target_channel(target_channel)
-
-    input_data = dto.CreateExternalChannelInput(
-        telegram_id=-1009876543210,
-        title='External Channel',
-        username='externalchannel',
-        description='Test external channel',
-        subscribers_count=10000,
-        target_channel_ids=[target_channel.id],
-    )
-
-    result = await usecases.create_external_channel(input_data, user.id)
-
-    assert result.telegram_id == -1009876543210
-    assert result.title == 'External Channel'
-    assert result.subscribers_count == 10000
-
-
-@pytest.mark.asyncio
-async def test_create_external_channel_invalid_target(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
-    """Создание внешнего канала с несуществующим целевым каналом вызывает ошибку."""
-    user = domain.User(telegram_id=123456, username='testuser')
-    await mock_database.create_user(user)
-
-    import uuid
-
-    fake_target_id = uuid.uuid4()
-
-    input_data = dto.CreateExternalChannelInput(
-        telegram_id=-1009876543210,
-        title='External Channel',
-        username='externalchannel',
-        target_channel_ids=[fake_target_id],
-    )
-
-    with pytest.raises(HTTPException) as exc_info:
-        await usecases.create_external_channel(input_data, user.id)
-    assert exc_info.value.status_code == 404
-    assert 'Target channel' in str(exc_info.value.detail)
-
-
-@pytest.mark.asyncio
-async def test_get_external_channels_for_target(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
-    """Получение списка внешних каналов для целевого канала."""
-    user = domain.User(telegram_id=123456, username='testuser')
-    await mock_database.create_user(user)
-
-    target_channel = domain.TargetChannel(
-        telegram_id=-1001234567890,
-        title='Target Channel',
-        username='targetchannel',
-        user_id=user.id,
-        status=domain.TargetChannelStatus.ACTIVE,
-    )
-    await mock_database.upsert_target_channel(target_channel)
-
-    ext_channel = domain.ExternalChannel(
-        telegram_id=-1009876543210,
-        title='External Channel',
-        username='externalchannel',
-        description=None,
-        subscribers_count=10000,
-        user_id=user.id,
-    )
-    await mock_database.create_external_channel(ext_channel)
-    await mock_database.add_external_channel_to_targets(ext_channel.id, [target_channel.id])
-
-    result = await usecases.get_external_channels(
-        dto.GetExternalChannelsInput(target_channel_id=target_channel.id, user_id=user.id)
-    )
-
-    assert len(result.external_channels) == 1
-    assert result.external_channels[0].telegram_id == -1009876543210
-
-
-@pytest.mark.asyncio
-async def test_delete_external_channel(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
-    """Удаление внешнего канала."""
-    user = domain.User(telegram_id=123456, username='testuser')
-    await mock_database.create_user(user)
-
-    target_channel = domain.TargetChannel(
-        telegram_id=-1001234567890,
-        title='Target Channel',
-        username='targetchannel',
-        user_id=user.id,
-        status=domain.TargetChannelStatus.ACTIVE,
-    )
-    await mock_database.upsert_target_channel(target_channel)
-
-    ext_channel = domain.ExternalChannel(
-        telegram_id=-1009876543210,
-        title='External Channel',
-        username='externalchannel',
-        description=None,
-        subscribers_count=10000,
-        user_id=user.id,
-    )
-    await mock_database.create_external_channel(ext_channel)
-    await mock_database.add_external_channel_to_targets(ext_channel.id, [target_channel.id])
-
-    await usecases.delete_external_channel(dto.DeleteExternalChannelInput(channel_id=ext_channel.id, user_id=user.id))
-
-    # Проверяем, что канал удалён
-    channels = await mock_database.get_external_channels_for_target(target_channel.id)
-    assert len(channels) == 0
-
-
-@pytest.mark.asyncio
-async def test_update_external_channel_links(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
-    """Обновление привязок внешнего канала к целевым каналам."""
-    user = domain.User(telegram_id=123456, username='testuser')
-    await mock_database.create_user(user)
-
-    target1 = domain.TargetChannel(
-        telegram_id=-1001234567890,
-        title='Target 1',
-        username='target1',
-        user_id=user.id,
-        status=domain.TargetChannelStatus.ACTIVE,
-    )
-    target2 = domain.TargetChannel(
-        telegram_id=-1001234567891,
-        title='Target 2',
-        username='target2',
-        user_id=user.id,
-        status=domain.TargetChannelStatus.ACTIVE,
-    )
-    await mock_database.upsert_target_channel(target1)
-    await mock_database.upsert_target_channel(target2)
-
-    ext_channel = domain.ExternalChannel(
-        telegram_id=-1009876543210,
-        title='External Channel',
-        username='externalchannel',
-        description=None,
-        subscribers_count=10000,
-        user_id=user.id,
-    )
-    await mock_database.create_external_channel(ext_channel)
-    await mock_database.add_external_channel_to_targets(ext_channel.id, [target1.id])
-
-    # Добавляем связь с target2
-    await usecases.update_external_channel_links(
-        ext_channel.id,
-        dto.UpdateExternalChannelLinksInput(
-            add_target_channel_ids=[target2.id],
-            remove_target_channel_ids=[],
-        ),
-        user.id,
-    )
-
-    # Проверяем, что канал теперь привязан к обоим целевым каналам
-    channels_for_target2 = await mock_database.get_external_channels_for_target(target2.id)
-    assert len(channels_for_target2) == 1

tests/test_placements.py

@@ -1,632 +0,0 @@
-"""Тесты работы с закупами."""
-
-import datetime
-
-import pytest
-from fastapi import HTTPException
-
-from src import domain, dto, usecase
-from tests.conftest import MockDatabase
-
-
-@pytest.mark.asyncio
-async def test_create_placement_with_public_invite_link(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
-    """Создание закупа с публичной пригласительной ссылкой."""
-    user = domain.User(telegram_id=123456, username='testuser')
-    await mock_database.create_user(user)
-
-    target_channel = domain.TargetChannel(
-        telegram_id=-1001234567890,
-        title='Target Channel',
-        username='targetchannel',
-        user_id=user.id,
-        status=domain.TargetChannelStatus.ACTIVE,
-    )
-    await mock_database.upsert_target_channel(target_channel)
-
-    external_channel = domain.ExternalChannel(
-        telegram_id=-1009876543210,
-        title='External Channel',
-        username='externalchannel',
-        description='Ad channel',
-        subscribers_count=50000,
-        user_id=user.id,
-    )
-    await mock_database.create_external_channel(external_channel)
-
-    creative = domain.Creative(
-        name='Summer Sale',
-        text='Подписывайтесь на наш канал по ссылке: {link}',
-        target_channel_id=target_channel.id,
-        user_id=user.id,
-        status=domain.CreativeStatus.ACTIVE,
-    )
-    await mock_database.create_creative(creative)
-
-    placement_date = datetime.datetime.now(datetime.UTC)
-    input_data = dto.CreatePlacementInput(
-        target_channel_id=target_channel.id,
-        external_channel_id=external_channel.id,
-        creative_id=creative.id,
-        placement_date=placement_date,
-        cost=5000.0,
-        comment='Утреннее размещение',
-        ad_post_url='https://t.me/externalchannel/123',
-        invite_link_type=domain.InviteLinkType.PUBLIC,
-    )
-
-    result = await usecases.create_placement(input_data, user.id)
-
-    assert result.target_channel_id == target_channel.id
-    assert result.external_channel_id == external_channel.id
-    assert result.creative_id == creative.id
-    assert result.cost == 5000.0
-    assert result.comment == 'Утреннее размещение'
-    assert result.invite_link_type == domain.InviteLinkType.PUBLIC
-    assert result.invite_link.startswith('https://t.me/+public_link_')
-    assert result.status == domain.PlacementStatus.PENDING  # Ожидает публикации поста
-    assert result.subscriptions_count == 0
-
-    # Проверяем, что счётчик закупов у креатива увеличился
-    updated_creative = await mock_database.get_creative(user.id, creative.id)
-    assert updated_creative is not None
-    assert updated_creative.placements_count == 1
-
-
-@pytest.mark.asyncio
-async def test_create_placement_with_approval_invite_link(
-    usecases: usecase.Usecase, mock_database: MockDatabase
-) -> None:
-    """Создание закупа с пригласительной ссылкой, требующей одобрения."""
-    user = domain.User(telegram_id=123456, username='testuser')
-    await mock_database.create_user(user)
-
-    target_channel = domain.TargetChannel(
-        telegram_id=-1001234567890,
-        title='Target Channel',
-        username='targetchannel',
-        user_id=user.id,
-        status=domain.TargetChannelStatus.ACTIVE,
-    )
-    await mock_database.upsert_target_channel(target_channel)
-
-    external_channel = domain.ExternalChannel(
-        telegram_id=-1009876543210,
-        title='External Channel',
-        username='externalchannel',
-        description=None,
-        subscribers_count=30000,
-        user_id=user.id,
-    )
-    await mock_database.create_external_channel(external_channel)
-
-    creative = domain.Creative(
-        name='Premium Creative',
-        text='Эксклюзивный контент: {link}',
-        target_channel_id=target_channel.id,
-        user_id=user.id,
-        status=domain.CreativeStatus.ACTIVE,
-    )
-    await mock_database.create_creative(creative)
-
-    placement_date = datetime.datetime.now(datetime.UTC)
-    input_data = dto.CreatePlacementInput(
-        target_channel_id=target_channel.id,
-        external_channel_id=external_channel.id,
-        creative_id=creative.id,
-        placement_date=placement_date,
-        invite_link_type=domain.InviteLinkType.APPROVAL,
-    )
-
-    result = await usecases.create_placement(input_data, user.id)
-
-    assert result.invite_link_type == domain.InviteLinkType.APPROVAL
-    assert 'approval_link_' in result.invite_link
-
-
-@pytest.mark.asyncio
-async def test_create_placement_invalid_target_channel(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
-    """Создание закупа для несуществующего целевого канала вызывает ошибку."""
-    user = domain.User(telegram_id=123456, username='testuser')
-    await mock_database.create_user(user)
-
-    import uuid
-
-    fake_target_id = uuid.uuid4()
-    fake_external_id = uuid.uuid4()
-    fake_creative_id = uuid.uuid4()
-
-    input_data = dto.CreatePlacementInput(
-        target_channel_id=fake_target_id,
-        external_channel_id=fake_external_id,
-        creative_id=fake_creative_id,
-        placement_date=datetime.datetime.now(datetime.UTC),
-    )
-
-    with pytest.raises(HTTPException) as exc_info:
-        await usecases.create_placement(input_data, user.id)
-    assert exc_info.value.status_code == 404
-    assert 'Target channel' in str(exc_info.value.detail)
-
-
-@pytest.mark.asyncio
-async def test_get_user_placements(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
-    """Получение списка закупов пользователя."""
-    user = domain.User(telegram_id=123456, username='testuser')
-    await mock_database.create_user(user)
-
-    target_channel = domain.TargetChannel(
-        telegram_id=-1001234567890,
-        title='Target Channel',
-        username='targetchannel',
-        user_id=user.id,
-        status=domain.TargetChannelStatus.ACTIVE,
-    )
-    await mock_database.upsert_target_channel(target_channel)
-
-    external_channel = domain.ExternalChannel(
-        telegram_id=-1009876543210,
-        title='External Channel',
-        username='externalchannel',
-        description=None,
-        subscribers_count=20000,
-        user_id=user.id,
-    )
-    await mock_database.create_external_channel(external_channel)
-
-    creative = domain.Creative(
-        name='Test Creative',
-        text='Test text',
-        target_channel_id=target_channel.id,
-        user_id=user.id,
-        status=domain.CreativeStatus.ACTIVE,
-    )
-    await mock_database.create_creative(creative)
-
-    # Создаём два закупа
-    placement1 = domain.Placement(
-        target_channel_id=target_channel.id,
-        external_channel_id=external_channel.id,
-        creative_id=creative.id,
-        user_id=user.id,
-        placement_date=datetime.datetime.now(datetime.UTC),
-        cost=3000.0,
-        invite_link='https://t.me/+link1',
-        invite_link_type=domain.InviteLinkType.PUBLIC,
-        status=domain.PlacementStatus.ACTIVE,
-    )
-    placement2 = domain.Placement(
-        target_channel_id=target_channel.id,
-        external_channel_id=external_channel.id,
-        creative_id=creative.id,
-        user_id=user.id,
-        placement_date=datetime.datetime.now(datetime.UTC) - datetime.timedelta(days=1),
-        cost=4000.0,
-        invite_link='https://t.me/+link2',
-        invite_link_type=domain.InviteLinkType.PUBLIC,
-        status=domain.PlacementStatus.ACTIVE,
-    )
-    await mock_database.create_placement(placement1)
-    await mock_database.create_placement(placement2)
-
-    result = await usecases.get_placements(dto.GetPlacementsInput(user_id=user.id))
-
-    assert len(result.placements) == 2
-    # Проверяем сортировку по дате размещения (новые первые)
-    assert result.placements[0].id == placement1.id
-
-
-@pytest.mark.asyncio
-async def test_get_placements_filtered_by_target_channel(
-    usecases: usecase.Usecase, mock_database: MockDatabase
-) -> None:
-    """Получение закупов, отфильтрованных по целевому каналу."""
-    user = domain.User(telegram_id=123456, username='testuser')
-    await mock_database.create_user(user)
-
-    target1 = domain.TargetChannel(
-        telegram_id=-1001234567890,
-        title='Target 1',
-        username='target1',
-        user_id=user.id,
-        status=domain.TargetChannelStatus.ACTIVE,
-    )
-    target2 = domain.TargetChannel(
-        telegram_id=-1001234567891,
-        title='Target 2',
-        username='target2',
-        user_id=user.id,
-        status=domain.TargetChannelStatus.ACTIVE,
-    )
-    await mock_database.upsert_target_channel(target1)
-    await mock_database.upsert_target_channel(target2)
-
-    external_channel = domain.ExternalChannel(
-        telegram_id=-1009876543210,
-        title='External Channel',
-        username='externalchannel',
-        description=None,
-        subscribers_count=15000,
-        user_id=user.id,
-    )
-    await mock_database.create_external_channel(external_channel)
-
-    creative1 = domain.Creative(
-        name='Creative 1',
-        text='Text 1',
-        target_channel_id=target1.id,
-        user_id=user.id,
-        status=domain.CreativeStatus.ACTIVE,
-    )
-    creative2 = domain.Creative(
-        name='Creative 2',
-        text='Text 2',
-        target_channel_id=target2.id,
-        user_id=user.id,
-        status=domain.CreativeStatus.ACTIVE,
-    )
-    await mock_database.create_creative(creative1)
-    await mock_database.create_creative(creative2)
-
-    placement1 = domain.Placement(
-        target_channel_id=target1.id,
-        external_channel_id=external_channel.id,
-        creative_id=creative1.id,
-        user_id=user.id,
-        placement_date=datetime.datetime.now(datetime.UTC),
-        invite_link='https://t.me/+link1',
-        invite_link_type=domain.InviteLinkType.PUBLIC,
-        status=domain.PlacementStatus.ACTIVE,
-    )
-    placement2 = domain.Placement(
-        target_channel_id=target2.id,
-        external_channel_id=external_channel.id,
-        creative_id=creative2.id,
-        user_id=user.id,
-        placement_date=datetime.datetime.now(datetime.UTC),
-        invite_link='https://t.me/+link2',
-        invite_link_type=domain.InviteLinkType.PUBLIC,
-        status=domain.PlacementStatus.ACTIVE,
-    )
-    await mock_database.create_placement(placement1)
-    await mock_database.create_placement(placement2)
-
-    result = await usecases.get_placements(dto.GetPlacementsInput(user_id=user.id, target_channel_id=target1.id))
-
-    assert len(result.placements) == 1
-    assert result.placements[0].target_channel_id == target1.id
-
-
-@pytest.mark.asyncio
-async def test_get_placements_filtered_by_creative(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
-    """Получение закупов, отфильтрованных по креативу - для оценки эффективности креатива."""
-    user = domain.User(telegram_id=123456, username='testuser')
-    await mock_database.create_user(user)
-
-    target_channel = domain.TargetChannel(
-        telegram_id=-1001234567890,
-        title='Target Channel',
-        username='targetchannel',
-        user_id=user.id,
-        status=domain.TargetChannelStatus.ACTIVE,
-    )
-    await mock_database.upsert_target_channel(target_channel)
-
-    external_channel = domain.ExternalChannel(
-        telegram_id=-1009876543210,
-        title='External Channel',
-        username='externalchannel',
-        description=None,
-        subscribers_count=25000,
-        user_id=user.id,
-    )
-    await mock_database.create_external_channel(external_channel)
-
-    creative1 = domain.Creative(
-        name='Creative A',
-        text='Вариант A',
-        target_channel_id=target_channel.id,
-        user_id=user.id,
-        status=domain.CreativeStatus.ACTIVE,
-    )
-    creative2 = domain.Creative(
-        name='Creative B',
-        text='Вариант B',
-        target_channel_id=target_channel.id,
-        user_id=user.id,
-        status=domain.CreativeStatus.ACTIVE,
-    )
-    await mock_database.create_creative(creative1)
-    await mock_database.create_creative(creative2)
-
-    # Создаём закупы с разными креативами
-    placement1 = domain.Placement(
-        target_channel_id=target_channel.id,
-        external_channel_id=external_channel.id,
-        creative_id=creative1.id,
-        user_id=user.id,
-        placement_date=datetime.datetime.now(datetime.UTC),
-        invite_link='https://t.me/+link1',
-        invite_link_type=domain.InviteLinkType.PUBLIC,
-        status=domain.PlacementStatus.ACTIVE,
-    )
-    placement2 = domain.Placement(
-        target_channel_id=target_channel.id,
-        external_channel_id=external_channel.id,
-        creative_id=creative2.id,
-        user_id=user.id,
-        placement_date=datetime.datetime.now(datetime.UTC),
-        invite_link='https://t.me/+link2',
-        invite_link_type=domain.InviteLinkType.PUBLIC,
-        status=domain.PlacementStatus.ACTIVE,
-    )
-    await mock_database.create_placement(placement1)
-    await mock_database.create_placement(placement2)
-
-    result = await usecases.get_placements(dto.GetPlacementsInput(user_id=user.id, creative_id=creative1.id))
-
-    assert len(result.placements) == 1
-    assert result.placements[0].creative_id == creative1.id
-
-
-# TODO: Implement archive_placement method
-# @pytest.mark.asyncio
-# async def test_archive_placement(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
-#     """Архивирование закупа - убирает его из активной статистики."""
-#     user = domain.User(telegram_id=123456, username='testuser')
-#     await mock_database.create_user(user)
-#
-#     target_channel = domain.TargetChannel(
-#         telegram_id=-1001234567890,
-#         title='Target Channel',
-#         username='targetchannel',
-#         user_id=user.id,
-#         status=domain.TargetChannelStatus.ACTIVE,
-#     )
-#     await mock_database.upsert_target_channel(target_channel)
-#
-#     external_channel = domain.ExternalChannel(
-#         telegram_id=-1009876543210,
-#         title='External Channel',
-#         username='externalchannel',
-#         description=None,
-#         subscribers_count=18000,
-#         user_id=user.id,
-#     )
-#     await mock_database.create_external_channel(external_channel)
-#
-#     creative = domain.Creative(
-#         name='Test Creative',
-#         text='Test text',
-#         target_channel_id=target_channel.id,
-#         user_id=user.id,
-#         status=domain.CreativeStatus.ACTIVE,
-#     )
-#     await mock_database.create_creative(creative)
-#
-#     placement = domain.Placement(
-#         target_channel_id=target_channel.id,
-#         external_channel_id=external_channel.id,
-#         creative_id=creative.id,
-#         user_id=user.id,
-#         placement_date=datetime.datetime.now(datetime.UTC),
-#         invite_link='https://t.me/+link1',
-#         invite_link_type=domain.InviteLinkType.PUBLIC,
-#         status=domain.PlacementStatus.ACTIVE,
-#     )
-#     await mock_database.create_placement(placement)
-#
-#     result = await usecases.archive_placement(placement.id, user.id)
-#
-#     assert result.status == domain.PlacementStatus.ARCHIVED
-#
-#     # Проверяем, что архивированный закуп не возвращается по умолчанию
-#     placements_list = await usecases.get_placements(dto.GetPlacementsInput(user_id=user.id))
-#     assert len(placements_list.placements) == 0
-#
-#     # Проверяем, что архивированный закуп возвращается с флагом include_archived
-#     placements_with_archived = await usecases.get_placements(
-#         dto.GetPlacementsInput(user_id=user.id, include_archived=True)
-#     )
-#     assert len(placements_with_archived.placements) == 1
-
-
-@pytest.mark.asyncio
-async def test_update_placement(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
-    """Редактирование закупа - обновление стоимости, комментария, даты."""
-    user = domain.User(telegram_id=123456, username='testuser')
-    await mock_database.create_user(user)
-
-    target_channel = domain.TargetChannel(
-        telegram_id=-1001234567890,
-        title='Target Channel',
-        username='targetchannel',
-        user_id=user.id,
-        status=domain.TargetChannelStatus.ACTIVE,
-    )
-    await mock_database.upsert_target_channel(target_channel)
-
-    external_channel = domain.ExternalChannel(
-        telegram_id=-1009876543210,
-        title='External Channel',
-        username='externalchannel',
-        description=None,
-        subscribers_count=22000,
-        user_id=user.id,
-    )
-    await mock_database.create_external_channel(external_channel)
-
-    creative = domain.Creative(
-        name='Test Creative',
-        text='Test text',
-        target_channel_id=target_channel.id,
-        user_id=user.id,
-        status=domain.CreativeStatus.ACTIVE,
-    )
-    await mock_database.create_creative(creative)
-
-    old_date = datetime.datetime.now(datetime.UTC) - datetime.timedelta(days=1)
-    placement = domain.Placement(
-        target_channel_id=target_channel.id,
-        external_channel_id=external_channel.id,
-        creative_id=creative.id,
-        user_id=user.id,
-        placement_date=old_date,
-        cost=3000.0,
-        comment='Старый комментарий',
-        invite_link='https://t.me/+link1',
-        invite_link_type=domain.InviteLinkType.PUBLIC,
-        status=domain.PlacementStatus.ACTIVE,
-    )
-    await mock_database.create_placement(placement)
-
-    new_date = datetime.datetime.now(datetime.UTC)
-    update_input = dto.UpdatePlacementInput(
-        placement_date=new_date,
-        cost=3500.0,
-        comment='Обновлённый комментарий',
-        ad_post_url='https://t.me/externalchannel/456',
-    )
-    result = await usecases.update_placement(placement.id, update_input, user.id)
-
-    assert result.placement_date == new_date
-    assert result.cost == 3500.0
-    assert result.comment == 'Обновлённый комментарий'
-    assert result.ad_post_url == 'https://t.me/externalchannel/456'
-
-
-@pytest.mark.asyncio
-async def test_delete_placement(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
-    """Удаление закупа - уменьшает счётчик закупов у креатива."""
-    user = domain.User(telegram_id=123456, username='testuser')
-    await mock_database.create_user(user)
-
-    target_channel = domain.TargetChannel(
-        telegram_id=-1001234567890,
-        title='Target Channel',
-        username='targetchannel',
-        user_id=user.id,
-        status=domain.TargetChannelStatus.ACTIVE,
-    )
-    await mock_database.upsert_target_channel(target_channel)
-
-    external_channel = domain.ExternalChannel(
-        telegram_id=-1009876543210,
-        title='External Channel',
-        username='externalchannel',
-        description=None,
-        subscribers_count=28000,
-        user_id=user.id,
-    )
-    await mock_database.create_external_channel(external_channel)
-
-    creative = domain.Creative(
-        name='Test Creative',
-        text='Test text',
-        target_channel_id=target_channel.id,
-        user_id=user.id,
-        status=domain.CreativeStatus.ACTIVE,
-        placements_count=1,
-    )
-    await mock_database.create_creative(creative)
-
-    placement = domain.Placement(
-        target_channel_id=target_channel.id,
-        external_channel_id=external_channel.id,
-        creative_id=creative.id,
-        user_id=user.id,
-        placement_date=datetime.datetime.now(datetime.UTC),
-        invite_link='https://t.me/+link1',
-        invite_link_type=domain.InviteLinkType.PUBLIC,
-        status=domain.PlacementStatus.ACTIVE,
-    )
-    await mock_database.create_placement(placement)
-
-    await usecases.delete_placement(dto.DeletePlacementInput(placement_id=placement.id, user_id=user.id))
-
-    # Проверяем, что закуп удалён
-    placements_list = await usecases.get_placements(dto.GetPlacementsInput(user_id=user.id, include_archived=True))
-    assert len(placements_list.placements) == 0
-
-    # Проверяем, что счётчик закупов у креатива уменьшился
-    updated_creative = await mock_database.get_creative(user.id, creative.id)
-    assert updated_creative is not None
-    assert updated_creative.placements_count == 0
-
-
-@pytest.mark.asyncio
-async def test_multiple_placements_same_creative(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
-    """Создание нескольких закупов с одним креативом - для A/B тестирования в разных каналах."""
-    user = domain.User(telegram_id=123456, username='testuser')
-    await mock_database.create_user(user)
-
-    target_channel = domain.TargetChannel(
-        telegram_id=-1001234567890,
-        title='Target Channel',
-        username='targetchannel',
-        user_id=user.id,
-        status=domain.TargetChannelStatus.ACTIVE,
-    )
-    await mock_database.upsert_target_channel(target_channel)
-
-    external1 = domain.ExternalChannel(
-        telegram_id=-1009876543210,
-        title='External 1',
-        username='external1',
-        description=None,
-        subscribers_count=10000,
-        user_id=user.id,
-    )
-    external2 = domain.ExternalChannel(
-        telegram_id=-1009876543211,
-        title='External 2',
-        username='external2',
-        description=None,
-        subscribers_count=20000,
-        user_id=user.id,
-    )
-    await mock_database.create_external_channel(external1)
-    await mock_database.create_external_channel(external2)
-
-    creative = domain.Creative(
-        name='Universal Creative',
-        text='Универсальный текст',
-        target_channel_id=target_channel.id,
-        user_id=user.id,
-        status=domain.CreativeStatus.ACTIVE,
-    )
-    await mock_database.create_creative(creative)
-
-    # Создаём два закупа с одним креативом в разных внешних каналах
-    input1 = dto.CreatePlacementInput(
-        target_channel_id=target_channel.id,
-        external_channel_id=external1.id,
-        creative_id=creative.id,
-        placement_date=datetime.datetime.now(datetime.UTC),
-        cost=2000.0,
-    )
-    input2 = dto.CreatePlacementInput(
-        target_channel_id=target_channel.id,
-        external_channel_id=external2.id,
-        creative_id=creative.id,
-        placement_date=datetime.datetime.now(datetime.UTC),
-        cost=4000.0,
-    )
-
-    result1 = await usecases.create_placement(input1, user.id)
-    result2 = await usecases.create_placement(input2, user.id)
-
-    # Проверяем, что созданы два разных закупа
-    assert result1.id != result2.id
-    assert result1.invite_link != result2.invite_link
-
-    # Проверяем, что счётчик креатива увеличился на 2
-    updated_creative = await mock_database.get_creative(user.id, creative.id)
-    assert updated_creative is not None
-    assert updated_creative.placements_count == 2
-
-    # Проверяем фильтрацию по креативу
-    placements_for_creative = await usecases.get_placements(
-        dto.GetPlacementsInput(user_id=user.id, creative_id=creative.id)
-    )
-    assert len(placements_for_creative.placements) == 2

tests/test_subscriptions.py

@@ -1,350 +0,0 @@
-"""Тесты обработки подписок пользователей через invite_link."""
-
-import datetime
-
-import pytest
-
-from src import domain, usecase
-from tests.conftest import MockDatabase
-
-
-@pytest.mark.asyncio
-async def test_handle_subscription_success(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
-    """Первая подписка пользователя по invite_link успешно создаётся."""
-    user = domain.User(telegram_id=123456, username='testuser')
-    await mock_database.create_user(user)
-
-    target_channel = domain.TargetChannel(
-        telegram_id=-1001234567890,
-        title='Target Channel',
-        username='targetchannel',
-        user_id=user.id,
-        status=domain.TargetChannelStatus.ACTIVE,
-    )
-    await mock_database.upsert_target_channel(target_channel)
-
-    external_channel = domain.ExternalChannel(
-        telegram_id=-1009876543210,
-        title='External Channel',
-        username='externalchannel',
-        description=None,
-        subscribers_count=50000,
-        user_id=user.id,
-    )
-    await mock_database.create_external_channel(external_channel)
-
-    creative = domain.Creative(
-        name='Test Creative',
-        text='Test text',
-        target_channel_id=target_channel.id,
-        user_id=user.id,
-        status=domain.CreativeStatus.ACTIVE,
-    )
-    await mock_database.create_creative(creative)
-
-    invite_link = 'https://t.me/+unique_link_123'
-    placement = domain.Placement(
-        target_channel_id=target_channel.id,
-        external_channel_id=external_channel.id,
-        creative_id=creative.id,
-        user_id=user.id,
-        placement_date=datetime.datetime.now(datetime.UTC),
-        invite_link=invite_link,
-        invite_link_type=domain.InviteLinkType.PUBLIC,
-        status=domain.PlacementStatus.ACTIVE,
-        subscriptions_count=0,
-    )
-    await mock_database.create_placement(placement)
-
-    # Симулируем подписку пользователя
-    subscriber_id = 999888777
-    subscriber_username = 'new_subscriber'
-    await usecases.handle_subscription(
-        user_telegram_id=subscriber_id,
-        username=subscriber_username,
-        invite_link=invite_link,
-    )
-
-    # Проверяем, что подписка создана
-    subscriber = await mock_database.get_subscriber(subscriber_id)
-    assert subscriber is not None
-    assert subscriber.telegram_id == subscriber_id
-    assert subscriber.username == subscriber_username
-
-    subscription = await mock_database.get_subscription_by_subscriber_and_placement(subscriber.id, placement.id)
-    assert subscription is not None
-    assert subscription.subscriber_id == subscriber.id
-    assert subscription.invite_link == invite_link
-
-    # Проверяем, что счётчик подписок у закупа увеличился
-    updated_placement = await mock_database.get_placement(user.id, placement.id)
-    assert updated_placement is not None
-    assert updated_placement.subscriptions_count == 1
-
-
-@pytest.mark.asyncio
-async def test_handle_subscription_duplicate_ignored(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
-    """Повторная подписка того же пользователя игнорируется - не создаёт дубликат."""
-    user = domain.User(telegram_id=123456, username='testuser')
-    await mock_database.create_user(user)
-
-    target_channel = domain.TargetChannel(
-        telegram_id=-1001234567890,
-        title='Target Channel',
-        username='targetchannel',
-        user_id=user.id,
-        status=domain.TargetChannelStatus.ACTIVE,
-    )
-    await mock_database.upsert_target_channel(target_channel)
-
-    external_channel = domain.ExternalChannel(
-        telegram_id=-1009876543210,
-        title='External Channel',
-        username='externalchannel',
-        description=None,
-        subscribers_count=30000,
-        user_id=user.id,
-    )
-    await mock_database.create_external_channel(external_channel)
-
-    creative = domain.Creative(
-        name='Test Creative',
-        text='Test text',
-        target_channel_id=target_channel.id,
-        user_id=user.id,
-        status=domain.CreativeStatus.ACTIVE,
-    )
-    await mock_database.create_creative(creative)
-
-    invite_link = 'https://t.me/+unique_link_456'
-    placement = domain.Placement(
-        target_channel_id=target_channel.id,
-        external_channel_id=external_channel.id,
-        creative_id=creative.id,
-        user_id=user.id,
-        placement_date=datetime.datetime.now(datetime.UTC),
-        invite_link=invite_link,
-        invite_link_type=domain.InviteLinkType.APPROVAL,
-        status=domain.PlacementStatus.ACTIVE,
-        subscriptions_count=0,
-    )
-    await mock_database.create_placement(placement)
-
-    subscriber_id = 888777666
-    subscriber_username = 'duplicate_user'
-
-    # Первая подписка
-    await usecases.handle_subscription(
-        user_telegram_id=subscriber_id,
-        username=subscriber_username,
-        invite_link=invite_link,
-    )
-
-    # Проверяем счётчик
-    updated_placement = await mock_database.get_placement(user.id, placement.id)
-    assert updated_placement is not None
-    assert updated_placement.subscriptions_count == 1
-
-    # Повторная попытка подписки того же пользователя
-    await usecases.handle_subscription(
-        user_telegram_id=subscriber_id,
-        username=subscriber_username,
-        invite_link=invite_link,
-    )
-
-    # Проверяем, что счётчик не увеличился
-    updated_placement_again = await mock_database.get_placement(user.id, placement.id)
-    assert updated_placement_again is not None
-    assert updated_placement_again.subscriptions_count == 1  # Остался 1, не увеличился
-
-    # Проверяем, что в БД только одна подписка этого подписчика
-    subscriber = await mock_database.get_subscriber(subscriber_id)
-    assert subscriber is not None
-    all_subscriptions = [s for s in mock_database.subscriptions.values() if s.subscriber_id == subscriber.id]
-    assert len(all_subscriptions) == 1
-
-
-@pytest.mark.asyncio
-async def test_handle_subscription_invalid_invite_link(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
-    """Подписка по несуществующему invite_link не создаётся."""
-    fake_invite_link = 'https://t.me/+fake_link_999'
-
-    # Пытаемся обработать подписку по несуществующей ссылке
-    await usecases.handle_subscription(
-        user_telegram_id=777666555,
-        username='unknown_user',
-        invite_link=fake_invite_link,
-    )
-
-    # Проверяем, что подписки не создано
-    assert len(mock_database.subscriptions) == 0
-
-
-@pytest.mark.asyncio
-async def test_multiple_users_subscription_same_placement(
-    usecases: usecase.Usecase, mock_database: MockDatabase
-) -> None:
-    """Несколько пользователей подписываются через один закуп - каждый учитывается."""
-    user = domain.User(telegram_id=123456, username='testuser')
-    await mock_database.create_user(user)
-
-    target_channel = domain.TargetChannel(
-        telegram_id=-1001234567890,
-        title='Target Channel',
-        username='targetchannel',
-        user_id=user.id,
-        status=domain.TargetChannelStatus.ACTIVE,
-    )
-    await mock_database.upsert_target_channel(target_channel)
-
-    external_channel = domain.ExternalChannel(
-        telegram_id=-1009876543210,
-        title='External Channel',
-        username='externalchannel',
-        description=None,
-        subscribers_count=40000,
-        user_id=user.id,
-    )
-    await mock_database.create_external_channel(external_channel)
-
-    creative = domain.Creative(
-        name='Viral Creative',
-        text='Viral content',
-        target_channel_id=target_channel.id,
-        user_id=user.id,
-        status=domain.CreativeStatus.ACTIVE,
-    )
-    await mock_database.create_creative(creative)
-
-    invite_link = 'https://t.me/+popular_link_789'
-    placement = domain.Placement(
-        target_channel_id=target_channel.id,
-        external_channel_id=external_channel.id,
-        creative_id=creative.id,
-        user_id=user.id,
-        placement_date=datetime.datetime.now(datetime.UTC),
-        invite_link=invite_link,
-        invite_link_type=domain.InviteLinkType.PUBLIC,
-        status=domain.PlacementStatus.ACTIVE,
-        subscriptions_count=0,
-    )
-    await mock_database.create_placement(placement)
-
-    # Подписываются три разных пользователя
-    users_data = [
-        (111222333, 'user_one'),
-        (444555666, 'user_two'),
-        (777888999, 'user_three'),
-    ]
-
-    for telegram_id, username in users_data:
-        await usecases.handle_subscription(
-            user_telegram_id=telegram_id,
-            username=username,
-            invite_link=invite_link,
-        )
-
-    # Проверяем, что создано 3 подписки
-    placement_subscriptions = [s for s in mock_database.subscriptions.values() if s.placement_id == placement.id]
-    assert len(placement_subscriptions) == 3
-
-    # Проверяем, что счётчик правильный
-    updated_placement = await mock_database.get_placement(user.id, placement.id)
-    assert updated_placement is not None
-    assert updated_placement.subscriptions_count == 3
-
-
-@pytest.mark.asyncio
-async def test_subscription_tracking_across_different_placements(
-    usecases: usecase.Usecase, mock_database: MockDatabase
-) -> None:
-    """Один пользователь может подписаться через разные закупы - каждая подписка учитывается отдельно."""
-    user = domain.User(telegram_id=123456, username='testuser')
-    await mock_database.create_user(user)
-
-    target_channel = domain.TargetChannel(
-        telegram_id=-1001234567890,
-        title='Target Channel',
-        username='targetchannel',
-        user_id=user.id,
-        status=domain.TargetChannelStatus.ACTIVE,
-    )
-    await mock_database.upsert_target_channel(target_channel)
-
-    external_channel = domain.ExternalChannel(
-        telegram_id=-1009876543210,
-        title='External Channel',
-        username='externalchannel',
-        description=None,
-        subscribers_count=25000,
-        user_id=user.id,
-    )
-    await mock_database.create_external_channel(external_channel)
-
-    creative = domain.Creative(
-        name='Test Creative',
-        text='Test text',
-        target_channel_id=target_channel.id,
-        user_id=user.id,
-        status=domain.CreativeStatus.ACTIVE,
-    )
-    await mock_database.create_creative(creative)
-
-    # Создаём два разных закупа с разными invite_link
-    placement1 = domain.Placement(
-        target_channel_id=target_channel.id,
-        external_channel_id=external_channel.id,
-        creative_id=creative.id,
-        user_id=user.id,
-        placement_date=datetime.datetime.now(datetime.UTC),
-        invite_link='https://t.me/+link_a',
-        invite_link_type=domain.InviteLinkType.PUBLIC,
-        status=domain.PlacementStatus.ACTIVE,
-        subscriptions_count=0,
-    )
-    placement2 = domain.Placement(
-        target_channel_id=target_channel.id,
-        external_channel_id=external_channel.id,
-        creative_id=creative.id,
-        user_id=user.id,
-        placement_date=datetime.datetime.now(datetime.UTC),
-        invite_link='https://t.me/+link_b',
-        invite_link_type=domain.InviteLinkType.PUBLIC,
-        status=domain.PlacementStatus.ACTIVE,
-        subscriptions_count=0,
-    )
-    await mock_database.create_placement(placement1)
-    await mock_database.create_placement(placement2)
-
-    subscriber_id = 555444333
-
-    # Пользователь подписывается через первый закуп
-    await usecases.handle_subscription(
-        user_telegram_id=subscriber_id,
-        username='multi_subscriber',
-        invite_link=placement1.invite_link,
-    )
-
-    # Тот же пользователь "подписывается" через второй закуп
-    # (технически невозможно, но тестируем логику)
-    await usecases.handle_subscription(
-        user_telegram_id=subscriber_id,
-        username='multi_subscriber',
-        invite_link=placement2.invite_link,
-    )
-
-    # Проверяем, что у каждого закупа свой счётчик
-    updated_placement1 = await mock_database.get_placement(user.id, placement1.id)
-    updated_placement2 = await mock_database.get_placement(user.id, placement2.id)
-
-    assert updated_placement1 is not None
-    assert updated_placement1.subscriptions_count == 1
-
-    assert updated_placement2 is not None
-    assert updated_placement2.subscriptions_count == 1
-
-    # Проверяем, что создано 2 подписки
-    subscriber = await mock_database.get_subscriber(subscriber_id)
-    assert subscriber is not None
-    user_subscriptions = [s for s in mock_database.subscriptions.values() if s.subscriber_id == subscriber.id]
-    assert len(user_subscriptions) == 2

tests/test_target_channels.py

@@ -1,169 +0,0 @@
-"""Тесты подключения целевых каналов."""
-
-import pytest
-from fastapi import HTTPException
-
-from src import domain, dto, usecase
-from tests.conftest import MockDatabase, MockTelegramWriter
-
-
-@pytest.mark.asyncio
-async def test_connect_new_channel_success(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
-    """Подключение нового канала с правами администратора."""
-    user = domain.User(telegram_id=123456, username='testuser')
-    await mock_database.create_user(user)
-
-    input_data = dto.ConnectTargetChanInput(
-        telegram_id=-1001234567890,
-        title='Test Channel',
-        username='testchannel',
-        user_telegram_id=123456,
-        bot_permissions=dto.ChannelBotPermissions(
-            is_admin=True,
-            can_invite_users=True,
-            can_restrict_members=True,
-        ),
-    )
-
-    result = await usecases.connect_target_chan(input_data)
-
-    assert result.telegram_id == -1001234567890
-    assert result.title == 'Test Channel'
-    assert result.status == domain.TargetChannelStatus.ACTIVE
-    assert result.is_active is True  # проверка обратной совместимости
-
-    # Проверяем, что канал сохранён
-    channel = await mock_database.get_target_channel(user.id, telegram_id=-1001234567890)
-    assert channel is not None
-
-
-@pytest.mark.asyncio
-async def test_connect_channel_without_admin_rights(
-    usecases: usecase.Usecase, mock_database: MockDatabase, mock_telegram: MockTelegramWriter
-) -> None:
-    """Канал без прав администратора не подключается."""
-    user = domain.User(telegram_id=123456, username='testuser')
-    await mock_database.create_user(user)
-
-    input_data = dto.ConnectTargetChanInput(
-        telegram_id=-1001234567890,
-        title='Test Channel',
-        username='testchannel',
-        user_telegram_id=123456,
-        bot_permissions=dto.ChannelBotPermissions(
-            is_admin=False,
-            can_invite_users=False,
-            can_restrict_members=False,
-        ),
-    )
-
-    with pytest.raises(HTTPException) as exc_info:
-        await usecases.connect_target_chan(input_data)
-
-    assert exc_info.value.status_code == 403
-    # Проверяем, что бот отправил предупреждение
-    assert len(mock_telegram.sent_messages) == 1
-    assert 'не является админом' in mock_telegram.sent_messages[0]['text']
-
-
-@pytest.mark.asyncio
-async def test_connect_channel_without_required_permissions(
-    usecases: usecase.Usecase, mock_database: MockDatabase, mock_telegram: MockTelegramWriter
-) -> None:
-    """Канал без необходимых прав не подключается."""
-    user = domain.User(telegram_id=123456, username='testuser')
-    await mock_database.create_user(user)
-
-    input_data = dto.ConnectTargetChanInput(
-        telegram_id=-1001234567890,
-        title='Test Channel',
-        username='testchannel',
-        user_telegram_id=123456,
-        bot_permissions=dto.ChannelBotPermissions(
-            is_admin=True,
-            can_invite_users=False,  # Отсутствует необходимое право
-            can_restrict_members=True,
-        ),
-    )
-
-    with pytest.raises(HTTPException) as exc_info:
-        await usecases.connect_target_chan(input_data)
-
-    assert exc_info.value.status_code == 403
-    assert len(mock_telegram.sent_messages) == 1
-    assert 'не имеет необходимых прав' in mock_telegram.sent_messages[0]['text']
-
-
-@pytest.mark.asyncio
-async def test_connect_channel_user_not_found(usecases: usecase.Usecase, mock_telegram: MockTelegramWriter) -> None:
-    """Подключение канала неавторизованным пользователем вызывает ошибку."""
-    input_data = dto.ConnectTargetChanInput(
-        telegram_id=-1001234567890,
-        title='Test Channel',
-        username='testchannel',
-        user_telegram_id=999999,  # Несуществующий пользователь
-        bot_permissions=dto.ChannelBotPermissions(
-            is_admin=True,
-            can_invite_users=True,
-            can_restrict_members=True,
-        ),
-    )
-
-    with pytest.raises(HTTPException) as exc_info:
-        await usecases.connect_target_chan(input_data)
-
-    assert exc_info.value.status_code == 404
-    assert 'not found' in str(exc_info.value.detail).lower()
-    assert len(mock_telegram.sent_messages) == 1
-    assert 'авторизоваться' in mock_telegram.sent_messages[0]['text']
-
-
-@pytest.mark.asyncio
-async def test_get_user_target_channels(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
-    """Получение списка каналов пользователя."""
-    user = domain.User(telegram_id=123456, username='testuser')
-    await mock_database.create_user(user)
-
-    channel1 = domain.TargetChannel(
-        telegram_id=-1001234567890,
-        title='Channel 1',
-        username='channel1',
-        user_id=user.id,
-        status=domain.TargetChannelStatus.ACTIVE,
-    )
-    channel2 = domain.TargetChannel(
-        telegram_id=-1001234567891,
-        title='Channel 2',
-        username='channel2',
-        user_id=user.id,
-        status=domain.TargetChannelStatus.ACTIVE,
-    )
-    await mock_database.upsert_target_channel(channel1)
-    await mock_database.upsert_target_channel(channel2)
-
-    result = await usecases.get_user_target_chans(dto.GetUserTargetChansInput(user_id=user.id))
-
-    assert len(result.target_channels) == 2
-
-
-@pytest.mark.asyncio
-async def test_disconnect_target_channel(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
-    """Отключение целевого канала."""
-    user = domain.User(telegram_id=123456, username='testuser')
-    await mock_database.create_user(user)
-
-    channel = domain.TargetChannel(
-        telegram_id=-1001234567890,
-        title='Test Channel',
-        username='testchannel',
-        user_id=user.id,
-        status=domain.TargetChannelStatus.ACTIVE,
-    )
-    await mock_database.upsert_target_channel(channel)
-
-    await usecases.disconnect_target_chan(dto.DisconnectTargetChanInput(channel_id=channel.id, user_id=user.id))
-
-    # Проверяем, что канал стал неактивным
-    updated_channel = await mock_database.get_target_channel(user.id, channel_id=channel.id)
-    assert updated_channel is not None
-    assert updated_channel.status == domain.TargetChannelStatus.INACTIVE

tests/test_views.py

@@ -1,299 +0,0 @@
-"""Тесты работы с просмотрами рекламных постов."""
-
-import datetime
-
-import pytest
-
-from src import domain, dto, usecase
-from tests.conftest import MockDatabase
-
-
-@pytest.mark.asyncio
-async def test_update_views_manually(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
-    """Ручное обновление просмотров создаёт снимок и обновляет закуп."""
-    user = domain.User(telegram_id=123456, username='testuser')
-    await mock_database.create_user(user)
-
-    target_channel = domain.TargetChannel(
-        telegram_id=-1001234567890,
-        title='Target Channel',
-        username='targetchannel',
-        user_id=user.id,
-        status=domain.TargetChannelStatus.ACTIVE,
-    )
-    await mock_database.upsert_target_channel(target_channel)
-
-    external_channel = domain.ExternalChannel(
-        telegram_id=-1009876543210,
-        title='External Channel',
-        username='externalchannel',
-        description=None,
-        subscribers_count=40000,
-        user_id=user.id,
-    )
-    await mock_database.create_external_channel(external_channel)
-
-    creative = domain.Creative(
-        name='Test Creative',
-        text='Test text',
-        target_channel_id=target_channel.id,
-        user_id=user.id,
-        status=domain.CreativeStatus.ACTIVE,
-    )
-    await mock_database.create_creative(creative)
-
-    placement = domain.Placement(
-        target_channel_id=target_channel.id,
-        external_channel_id=external_channel.id,
-        creative_id=creative.id,
-        user_id=user.id,
-        placement_date=datetime.datetime.now(datetime.UTC),
-        invite_link='https://t.me/+link3',
-        invite_link_type=domain.InviteLinkType.PUBLIC,
-        status=domain.PlacementStatus.ACTIVE,
-        ad_post_url='https://t.me/externalchannel/456',
-    )
-    await mock_database.create_placement(placement)
-
-    input_data = dto.UpdateViewsManuallyInput(
-        placement_id=placement.id,
-        user_id=user.id,
-        views_count=15000,
-    )
-
-    result = await usecases.update_views_manually(input=input_data)
-
-    # Проверяем возвращённый результат
-    assert result.views_count == 15000
-    assert result.views_availability == domain.PostViewsAvailability.MANUAL
-    assert result.last_views_fetch_at is not None
-
-    # Проверяем, что создана история просмотров
-    histories = [h for h in mock_database.placement_views_histories.values() if h.placement_id == placement.id]
-    assert len(histories) == 1
-    assert histories[0].views_count == 15000
-
-    # Проверяем, что закуп обновлён
-    updated_placement = await mock_database.get_placement(user.id, placement.id)
-    assert updated_placement is not None
-    assert updated_placement.views_count == 15000
-    assert updated_placement.views_availability == domain.PostViewsAvailability.MANUAL
-
-
-@pytest.mark.asyncio
-async def test_get_views_history_empty(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
-    """Получение истории просмотров для закупа без снимков возвращает пустой список."""
-    user = domain.User(telegram_id=123456, username='testuser')
-    await mock_database.create_user(user)
-
-    target_channel = domain.TargetChannel(
-        telegram_id=-1001234567890,
-        title='Target Channel',
-        username='targetchannel',
-        user_id=user.id,
-        status=domain.TargetChannelStatus.ACTIVE,
-    )
-    await mock_database.upsert_target_channel(target_channel)
-
-    external_channel = domain.ExternalChannel(
-        telegram_id=-1009876543210,
-        title='External Channel',
-        username='externalchannel',
-        description=None,
-        subscribers_count=25000,
-        user_id=user.id,
-    )
-    await mock_database.create_external_channel(external_channel)
-
-    creative = domain.Creative(
-        name='Test Creative',
-        text='Test text',
-        target_channel_id=target_channel.id,
-        user_id=user.id,
-        status=domain.CreativeStatus.ACTIVE,
-    )
-    await mock_database.create_creative(creative)
-
-    placement = domain.Placement(
-        target_channel_id=target_channel.id,
-        external_channel_id=external_channel.id,
-        creative_id=creative.id,
-        user_id=user.id,
-        placement_date=datetime.datetime.now(datetime.UTC),
-        invite_link='https://t.me/+link4',
-        invite_link_type=domain.InviteLinkType.PUBLIC,
-        status=domain.PlacementStatus.ACTIVE,
-    )
-    await mock_database.create_placement(placement)
-
-    input_data = dto.GetViewsHistoryInput(
-        placement_id=placement.id,
-        user_id=user.id,
-    )
-
-    result = await usecases.get_views_history(input=input_data)
-
-    assert len(result.histories) == 0
-
-
-@pytest.mark.asyncio
-async def test_get_views_history_with_snapshots(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
-    """Получение истории просмотров возвращает записи в хронологическом порядке."""
-    user = domain.User(telegram_id=123456, username='testuser')
-    await mock_database.create_user(user)
-
-    target_channel = domain.TargetChannel(
-        telegram_id=-1001234567890,
-        title='Target Channel',
-        username='targetchannel',
-        user_id=user.id,
-        status=domain.TargetChannelStatus.ACTIVE,
-    )
-    await mock_database.upsert_target_channel(target_channel)
-
-    external_channel = domain.ExternalChannel(
-        telegram_id=-1009876543210,
-        title='External Channel',
-        username='externalchannel',
-        description=None,
-        subscribers_count=35000,
-        user_id=user.id,
-    )
-    await mock_database.create_external_channel(external_channel)
-
-    creative = domain.Creative(
-        name='Test Creative',
-        text='Test text',
-        target_channel_id=target_channel.id,
-        user_id=user.id,
-        status=domain.CreativeStatus.ACTIVE,
-    )
-    await mock_database.create_creative(creative)
-
-    placement = domain.Placement(
-        target_channel_id=target_channel.id,
-        external_channel_id=external_channel.id,
-        creative_id=creative.id,
-        user_id=user.id,
-        placement_date=datetime.datetime.now(datetime.UTC),
-        invite_link='https://t.me/+link5',
-        invite_link_type=domain.InviteLinkType.PUBLIC,
-        status=domain.PlacementStatus.ACTIVE,
-    )
-    await mock_database.create_placement(placement)
-
-    # Создаём несколько записей истории
-    now = datetime.datetime.now(datetime.UTC)
-    history1 = domain.PlacementViewsHistory(
-        placement_id=placement.id,
-        views_count=1000,
-        fetched_at=now - datetime.timedelta(hours=2),
-    )
-    history2 = domain.PlacementViewsHistory(
-        placement_id=placement.id,
-        views_count=1500,
-        fetched_at=now - datetime.timedelta(hours=1),
-    )
-    history3 = domain.PlacementViewsHistory(
-        placement_id=placement.id,
-        views_count=2000,
-        fetched_at=now,
-    )
-    await mock_database.create_placement_views_history(history1)
-    await mock_database.create_placement_views_history(history2)
-    await mock_database.create_placement_views_history(history3)
-
-    input_data = dto.GetViewsHistoryInput(
-        placement_id=placement.id,
-        user_id=user.id,
-    )
-
-    result = await usecases.get_views_history(input=input_data)
-
-    assert len(result.histories) == 3
-    # Проверяем сортировку по времени (старые первые)
-    assert result.histories[0].views_count == 1000
-    assert result.histories[1].views_count == 1500
-    assert result.histories[2].views_count == 2000
-
-
-@pytest.mark.asyncio
-async def test_get_views_history_with_date_filter(usecases: usecase.Usecase, mock_database: MockDatabase) -> None:
-    """Фильтрация истории просмотров по датам работает корректно."""
-    user = domain.User(telegram_id=123456, username='testuser')
-    await mock_database.create_user(user)
-
-    target_channel = domain.TargetChannel(
-        telegram_id=-1001234567890,
-        title='Target Channel',
-        username='targetchannel',
-        user_id=user.id,
-        status=domain.TargetChannelStatus.ACTIVE,
-    )
-    await mock_database.upsert_target_channel(target_channel)
-
-    external_channel = domain.ExternalChannel(
-        telegram_id=-1009876543210,
-        title='External Channel',
-        username='externalchannel',
-        description=None,
-        subscribers_count=28000,
-        user_id=user.id,
-    )
-    await mock_database.create_external_channel(external_channel)
-
-    creative = domain.Creative(
-        name='Test Creative',
-        text='Test text',
-        target_channel_id=target_channel.id,
-        user_id=user.id,
-        status=domain.CreativeStatus.ACTIVE,
-    )
-    await mock_database.create_creative(creative)
-
-    placement = domain.Placement(
-        target_channel_id=target_channel.id,
-        external_channel_id=external_channel.id,
-        creative_id=creative.id,
-        user_id=user.id,
-        placement_date=datetime.datetime.now(datetime.UTC),
-        invite_link='https://t.me/+link6',
-        invite_link_type=domain.InviteLinkType.PUBLIC,
-        status=domain.PlacementStatus.ACTIVE,
-    )
-    await mock_database.create_placement(placement)
-
-    # Создаём записи с разными датами
-    now = datetime.datetime.now(datetime.UTC)
-    history1 = domain.PlacementViewsHistory(
-        placement_id=placement.id,
-        views_count=1000,
-        fetched_at=now - datetime.timedelta(days=3),
-    )
-    history2 = domain.PlacementViewsHistory(
-        placement_id=placement.id,
-        views_count=1500,
-        fetched_at=now - datetime.timedelta(days=1),
-    )
-    history3 = domain.PlacementViewsHistory(
-        placement_id=placement.id,
-        views_count=2000,
-        fetched_at=now,
-    )
-    await mock_database.create_placement_views_history(history1)
-    await mock_database.create_placement_views_history(history2)
-    await mock_database.create_placement_views_history(history3)
-
-    # Запрашиваем историю за последние 2 дня
-    input_data = dto.GetViewsHistoryInput(
-        placement_id=placement.id,
-        user_id=user.id,
-        from_date=now - datetime.timedelta(days=2),
-    )
-
-    result = await usecases.get_views_history(input=input_data)
-
-    # Должны вернуться только history2 и history3
-    assert len(result.histories) == 2
-    assert result.histories[0].views_count == 1500
-    assert result.histories[1].views_count == 2000