root/tgex-backend
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: доменный нейминг изменен

Browse Source
This commit is contained in:
Artem Tsyrulnikov
2025-11-13 01:18:04 +03:00
parent a48d5e67cb
commit bba37fbb21
51 changed files with 1144 additions and 1154 deletions
Download Patch File Download Diff File Expand all files Collapse all files

54
src/usecase/__init__.py
View File

@@ -15,11 +15,11 @@ from .external_channel.delete_external_channel import delete_external_channel
from .external_channel.get_external_channels import get_external_channels
from .external_channel.update_external_channel import update_external_channel
from .external_channel.update_external_channel_links import update_external_channel_links
from .purchase.create_purchase import create_purchase
from .purchase.delete_purchase import delete_purchase
from .purchase.get_purchase import get_purchase
from .purchase.get_purchases import get_purchases
from .purchase.update_purchase import update_purchase
from .placement.create_placement import create_placement
from .placement.delete_placement import delete_placement
from .placement.get_placement import get_placement
from .placement.get_placements import get_placements
from .placement.update_placement import update_placement
from .subscription.handle_subscription import handle_subscription
from .target_channel.connect_target_chan import connect_target_chan
from .target_channel.disconnect_target_chan import disconnect_target_chan
@@ -95,13 +95,13 @@ class Database(typing.Protocol):
async def delete_creative(self, creative_id: UUID) -> None: ...
async def get_purchase(self, user_id: UUID, purchase_id: UUID) -> domain.Purchase | None: ...
async def get_placement(self, user_id: UUID, placement_id: UUID) -> domain.Placement | None: ...
async def create_purchase(self, purchase: domain.Purchase) -> domain.Purchase: ...
async def create_placement(self, placement: domain.Placement) -> domain.Placement: ...
async def update_purchase(self, purchase: domain.Purchase) -> domain.Purchase: ...
async def update_placement(self, placement: domain.Placement) -> domain.Placement: ...
async def get_user_purchases(
async def get_user_placements(
self,
user_id: UUID,
*,
@@ -109,31 +109,39 @@ class Database(typing.Protocol):
external_channel_id: UUID | None = None,
creative_id: UUID | None = None,
include_archived: bool = False,
) -> list[domain.Purchase]: ...
) -> list[domain.Placement]: ...
async def delete_purchase(self, purchase_id: UUID) -> None: ...
async def delete_placement(self, placement_id: UUID) -> None: ...
async def check_creative_in_use(self, creative_id: UUID) -> bool: ...
async def get_purchase_by_invite_link(self, invite_link: str) -> domain.Purchase | None: ...
async def get_placement_by_invite_link(self, invite_link: str) -> domain.Placement | None: ...
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) -> domain.Subscriber: ...
async def create_subscription(self, subscription: domain.Subscription) -> domain.Subscription: ...
async def get_subscription_by_user_and_purchase(
self, user_telegram_id: int, purchase_id: UUID
async def get_subscription_by_subscriber_and_placement(
self, subscriber_id: UUID, placement_id: UUID
) -> domain.Subscription | None: ...
async def create_views_snapshot(self, snapshot: domain.ViewsSnapshot) -> domain.ViewsSnapshot: ...
async def create_placement_views_history(
self, history: domain.PlacementViewsHistory
) -> domain.PlacementViewsHistory: ...
async def get_views_history(
self,
purchase_id: UUID,
placement_id: UUID,
*,
from_date: datetime.datetime | None = None,
to_date: datetime.datetime | None = None,
) -> list[domain.ViewsSnapshot]: ...
) -> list[domain.PlacementViewsHistory]: ...
async def get_active_purchases_with_urls(self) -> list[domain.Purchase]: ... # Для worker
async def get_active_placements_with_urls(self) -> list[domain.Placement]: ... # Для worker
class TelegramBotWriter(typing.Protocol):
@@ -178,11 +186,11 @@ class Usecase:
create_creative = create_creative
update_creative = update_creative
delete_creative = delete_creative
get_purchases = get_purchases
get_purchase = get_purchase
create_purchase = create_purchase
update_purchase = update_purchase
delete_purchase = delete_purchase
get_placements = get_placements
get_placement = get_placement
create_placement = create_placement
update_placement = update_placement
delete_placement = delete_placement
handle_subscription = handle_subscription
fetch_views = fetch_views_manually
run_views_worker_cycle = run_views_worker_cycle

2
src/usecase/creative/create_creative.py
View File

@@ -37,5 +37,5 @@ async def create_creative(self: 'Usecase', input: dto.CreateCreativeInput, user_
target_channel_title=created.target_channel.title,
created_at=created.created_at,
status=created.status,
purchases_count=created.purchases_count,
placements_count=created.placements_count,
)

4
src/usecase/creative/delete_creative.py
View File

@@ -16,8 +16,8 @@ async def delete_creative(self: 'Usecase', input: dto.DeleteCreativeInput) -> No
log.warning('User %s attempted to delete unavailable creative %s', input.user_id, input.creative_id)
raise domain.CreativeNotFound(input.creative_id)
if creative.purchases_count > 0:
log.warning('Creative %s is used in purchases and cannot be deleted', input.creative_id)
if creative.placements_count > 0:
log.warning('Creative %s is used in placements and cannot be deleted', input.creative_id)
raise domain.CreativeInUse(input.creative_id)
await self.database.delete_creative(input.creative_id)

2
src/usecase/creative/get_creative.py
View File

@@ -24,5 +24,5 @@ async def get_creative(self: 'Usecase', input: dto.GetCreativeInput) -> dto.Crea
target_channel_title=creative.target_channel.title,
created_at=creative.created_at,
status=creative.status,
purchases_count=creative.purchases_count,
placements_count=creative.placements_count,
)

2
src/usecase/creative/get_creatives.py
View File

@@ -22,7 +22,7 @@ async def get_creatives(self: 'Usecase', input: dto.GetCreativesInput) -> dto.Ge
target_channel_title=creative.target_channel.title,
created_at=creative.created_at,
status=creative.status,
purchases_count=creative.purchases_count,
placements_count=creative.placements_count,
)
for creative in creatives
]

2
src/usecase/creative/update_creative.py
View File

@@ -36,5 +36,5 @@ async def update_creative(
target_channel_title=updated.target_channel.title,
created_at=updated.created_at,
status=updated.status,
purchases_count=updated.purchases_count,
placements_count=updated.placements_count,
)

18
src/usecase/purchase/create_purchase.py → src/usecase/placement/create_placement.py
View File

@@ -10,13 +10,13 @@ if TYPE_CHECKING:
log = logging.getLogger(__name__)
async def create_purchase(self: 'Usecase', input: dto.CreatePurchaseInput, user_id: uuid.UUID) -> dto.PurchaseOutput:
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(
'User %s attempted to create purchase 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)
@@ -24,14 +24,14 @@ async def create_purchase(self: 'Usecase', input: dto.CreatePurchaseInput, user_
external_channel = await self.database.get_external_channel(user_id, channel_id=input.external_channel_id)
if not external_channel:
log.warning(
'User %s attempted to create purchase for unavailable external %s', user_id, input.external_channel_id
'User %s attempted to create placement for unavailable external %s', user_id, input.external_channel_id
)
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 purchase for unavailable creative %s', user_id, input.creative_id)
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
@@ -42,7 +42,7 @@ async def create_purchase(self: 'Usecase', input: dto.CreatePurchaseInput, user_
)
# Создаём закуп
purchase = domain.Purchase(
placement = domain.Placement(
target_channel_id=input.target_channel_id,
external_channel_id=input.external_channel_id,
creative_id=input.creative_id,
@@ -53,17 +53,17 @@ async def create_purchase(self: 'Usecase', input: dto.CreatePurchaseInput, user_
ad_post_url=input.ad_post_url,
invite_link_type=input.invite_link_type,
invite_link=invite_link,
status=domain.PurchaseStatus.ACTIVE,
status=domain.PlacementStatus.ACTIVE,
)
created = await self.database.create_purchase(purchase)
created = await self.database.create_placement(placement)
# Увеличиваем счётчик закупов у креатива
creative.purchases_count += 1
creative.placements_count += 1
await self.database.update_creative(creative)
# Формируем ответ внутри транзакции, пока объекты в сессии
return dto.PurchaseOutput(
return dto.PlacementOutput(
id=created.id,
target_channel_id=created.target_channel_id,
target_channel_title=target_channel.title,

26
src/usecase/placement/delete_placement.py Normal file
View File

@@ -0,0 +1,26 @@
import logging
from typing import TYPE_CHECKING
from src import domain, dto
if TYPE_CHECKING:
from .. import Usecase
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:
creative = await self.database.get_creative(input.user_id, placement.creative_id)
if creative and creative.placements_count > 0:
creative.placements_count -= 1
await self.database.update_creative(creative)
await self.database.delete_placement(input.placement_id)

39
src/usecase/placement/get_placement.py Normal file
View File

@@ -0,0 +1,39 @@
import logging
from typing import TYPE_CHECKING
from src import domain, dto
if TYPE_CHECKING:
from .. import Usecase
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)
raise domain.PlacementNotFound(input.placement_id)
return dto.PlacementOutput(
id=placement.id,
target_channel_id=placement.target_channel_id,
target_channel_title=placement.target_channel.title,
external_channel_id=placement.external_channel_id,
external_channel_title=placement.external_channel.title,
creative_id=placement.creative_id,
creative_name=placement.creative.name,
placement_date=placement.placement_date,
cost=placement.cost,
comment=placement.comment,
ad_post_url=placement.ad_post_url,
invite_link_type=placement.invite_link_type,
invite_link=placement.invite_link,
status=placement.status,
subscriptions_count=placement.subscriptions_count,
views_count=placement.views_count,
views_availability=placement.views_availability,
last_views_fetch_at=placement.last_views_fetch_at,
created_at=placement.created_at,
)

44
src/usecase/placement/get_placements.py Normal file
View File

@@ -0,0 +1,44 @@
from typing import TYPE_CHECKING
from src import dto
if TYPE_CHECKING:
from .. import Usecase
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,
external_channel_id=input.external_channel_id,
creative_id=input.creative_id,
include_archived=input.include_archived,
)
return dto.GetPlacementsOutput(
placements=[
dto.PlacementOutput(
id=placement.id,
target_channel_id=placement.target_channel_id,
target_channel_title=placement.target_channel.title,
external_channel_id=placement.external_channel_id,
external_channel_title=placement.external_channel.title,
creative_id=placement.creative_id,
creative_name=placement.creative.name,
placement_date=placement.placement_date,
cost=placement.cost,
comment=placement.comment,
ad_post_url=placement.ad_post_url,
invite_link_type=placement.invite_link_type,
invite_link=placement.invite_link,
status=placement.status,
subscriptions_count=placement.subscriptions_count,
views_count=placement.views_count,
views_availability=placement.views_availability,
last_views_fetch_at=placement.last_views_fetch_at,
created_at=placement.created_at,
)
for placement in placements
]
)

28
src/usecase/purchase/update_purchase.py → src/usecase/placement/update_placement.py
View File

@@ -10,30 +10,30 @@ if TYPE_CHECKING:
log = logging.getLogger(__name__)
async def update_purchase(
self: 'Usecase', purchase_id: uuid.UUID, input: dto.UpdatePurchaseInput, user_id: uuid.UUID
) -> dto.PurchaseOutput:
async def update_placement(
self: 'Usecase', placement_id: uuid.UUID, input: dto.UpdatePlacementInput, user_id: uuid.UUID
) -> dto.PlacementOutput:
async with self.database.transaction():
purchase = await self.database.get_purchase(user_id, purchase_id)
if not purchase:
log.warning('Purchase %s not found for user %s', purchase_id, user_id)
raise domain.PurchaseNotFound(purchase_id)
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:
purchase.placement_date = input.placement_date
placement.placement_date = input.placement_date
if input.cost is not None:
purchase.cost = input.cost
placement.cost = input.cost
if input.comment is not None:
purchase.comment = input.comment
placement.comment = input.comment
if input.ad_post_url is not None:
purchase.ad_post_url = input.ad_post_url
placement.ad_post_url = input.ad_post_url
if input.status is not None:
purchase.status = input.status
placement.status = input.status
updated = await self.database.update_purchase(purchase)
updated = await self.database.update_placement(placement)
return dto.PurchaseOutput(
return dto.PlacementOutput(
id=updated.id,
target_channel_id=updated.target_channel_id,
target_channel_title=updated.target_channel.title,

26
src/usecase/purchase/delete_purchase.py
View File

@@ -1,26 +0,0 @@
import logging
from typing import TYPE_CHECKING
from src import domain, dto
if TYPE_CHECKING:
from .. import Usecase
log = logging.getLogger(__name__)
async def delete_purchase(self: 'Usecase', input: dto.DeletePurchaseInput) -> None:
async with self.database.transaction():
purchase = await self.database.get_purchase(input.user_id, input.purchase_id)
if not purchase:
log.warning('Purchase %s not found for user %s', input.purchase_id, input.user_id)
raise domain.PurchaseNotFound(input.purchase_id)
# Уменьшаем счётчик закупов у креатива, если закуп был активным
if purchase.status == domain.PurchaseStatus.ACTIVE:
creative = await self.database.get_creative(input.user_id, purchase.creative_id)
if creative and creative.purchases_count > 0:
creative.purchases_count -= 1
await self.database.update_creative(creative)
await self.database.delete_purchase(input.purchase_id)

39
src/usecase/purchase/get_purchase.py
View File

@@ -1,39 +0,0 @@
import logging
from typing import TYPE_CHECKING
from src import domain, dto
if TYPE_CHECKING:
from .. import Usecase
log = logging.getLogger(__name__)
async def get_purchase(self: 'Usecase', input: dto.GetPurchaseInput) -> dto.PurchaseOutput:
async with self.database.transaction():
purchase = await self.database.get_purchase(input.user_id, input.purchase_id)
if not purchase:
log.warning('Purchase %s not found for user %s', input.purchase_id, input.user_id)
raise domain.PurchaseNotFound(input.purchase_id)
return dto.PurchaseOutput(
id=purchase.id,
target_channel_id=purchase.target_channel_id,
target_channel_title=purchase.target_channel.title,
external_channel_id=purchase.external_channel_id,
external_channel_title=purchase.external_channel.title,
creative_id=purchase.creative_id,
creative_name=purchase.creative.name,
placement_date=purchase.placement_date,
cost=purchase.cost,
comment=purchase.comment,
ad_post_url=purchase.ad_post_url,
invite_link_type=purchase.invite_link_type,
invite_link=purchase.invite_link,
status=purchase.status,
subscriptions_count=purchase.subscriptions_count,
views_count=purchase.views_count,
views_availability=purchase.views_availability,
last_views_fetch_at=purchase.last_views_fetch_at,
created_at=purchase.created_at,
)

44
src/usecase/purchase/get_purchases.py
View File

@@ -1,44 +0,0 @@
from typing import TYPE_CHECKING
from src import dto
if TYPE_CHECKING:
from .. import Usecase
async def get_purchases(self: 'Usecase', input: dto.GetPurchasesInput) -> dto.GetPurchasesOutput:
async with self.database.transaction():
purchases = await self.database.get_user_purchases(
input.user_id,
target_channel_id=input.target_channel_id,
external_channel_id=input.external_channel_id,
creative_id=input.creative_id,
include_archived=input.include_archived,
)
return dto.GetPurchasesOutput(
purchases=[
dto.PurchaseOutput(
id=purchase.id,
target_channel_id=purchase.target_channel_id,
target_channel_title=purchase.target_channel.title,
external_channel_id=purchase.external_channel_id,
external_channel_title=purchase.external_channel.title,
creative_id=purchase.creative_id,
creative_name=purchase.creative.name,
placement_date=purchase.placement_date,
cost=purchase.cost,
comment=purchase.comment,
ad_post_url=purchase.ad_post_url,
invite_link_type=purchase.invite_link_type,
invite_link=purchase.invite_link,
status=purchase.status,
subscriptions_count=purchase.subscriptions_count,
views_count=purchase.views_count,
views_availability=purchase.views_availability,
last_views_fetch_at=purchase.last_views_fetch_at,
created_at=purchase.created_at,
)
for purchase in purchases
]
)

41
src/usecase/subscription/handle_subscription.py
View File

@@ -14,6 +14,8 @@ async def handle_subscription(
user_telegram_id: int,
username: str | None,
invite_link: str,
first_name: str | None = None,
last_name: str | None = None,
) -> None:
"""
Обрабатывает подписку пользователя в целевой канал.
@@ -23,37 +25,48 @@ async def handle_subscription(
"""
async with self.database.transaction():
# Находим закуп по пригласительной ссылке
purchase = await self.database.get_purchase_by_invite_link(invite_link)
if not purchase:
log.warning('Purchase not found for invite_link: %s', invite_link)
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)
return
# Создаём или обновляем подписчика
subscriber = domain.Subscriber(
telegram_id=user_telegram_id,
username=username,
first_name=first_name,
last_name=last_name,
)
subscriber = await self.database.upsert_subscriber(subscriber)
# Проверяем, не создана ли уже подписка для этого пользователя
existing_subscription = await self.database.get_subscription_by_user_and_purchase(user_telegram_id, purchase.id)
existing_subscription = await self.database.get_subscription_by_subscriber_and_placement(
subscriber.id, placement.id
)
if existing_subscription:
log.info(
'Subscription already exists for user %s and purchase %s',
user_telegram_id,
purchase.id,
'Subscription already exists for subscriber %s and placement %s',
subscriber.id,
placement.id,
)
return
# Создаём запись о подписке
subscription = domain.Subscription(
purchase_id=purchase.id,
user_telegram_id=user_telegram_id,
username=username,
placement_id=placement.id,
subscriber_id=subscriber.id,
invite_link=invite_link,
)
await self.database.create_subscription(subscription)
# Увеличиваем счётчик подписок у закупа
purchase.subscriptions_count += 1
await self.database.update_purchase(purchase)
placement.subscriptions_count += 1
await self.database.update_placement(placement)
log.info(
'Subscription created: user %s subscribed via purchase %s (invite_link: %s)',
'Subscription created: subscriber %s (telegram_id: %s) subscribed via placement %s (invite_link: %s)',
subscriber.id,
user_telegram_id,
purchase.id,
placement.id,
invite_link,
)

40
src/usecase/views/fetch_views_manually.py
View File

@@ -12,52 +12,52 @@ log = logging.getLogger(__name__)
async def fetch_views_manually(self: 'Usecase', input: dto.FetchViewsInputManually) -> dto.FetchViewsManuallyOutput:
async with self.database.transaction():
purchase = await self.database.get_purchase(input.user_id, input.purchase_id)
if not purchase:
raise domain.PurchaseNotFound(input.purchase_id)
placement = await self.database.get_placement(input.user_id, input.placement_id)
if not placement:
raise domain.PlacementNotFound(input.placement_id)
if not purchase.ad_post_url:
if not placement.ad_post_url:
return dto.FetchViewsManuallyOutput(
purchase_id=purchase.id,
placement_id=placement.id,
views_count=None,
views_availability=domain.PostViewsAvailability.UNAVAILABLE,
fetched_at=datetime.datetime.now(datetime.UTC),
error_message='No ad_post_url specified',
)
views_count = await self.telegram_parser.get_post_views(purchase.ad_post_url)
views_count = await self.telegram_parser.get_post_views(placement.ad_post_url)
fetched_at = datetime.datetime.now(datetime.UTC)
if views_count:
purchase.views_count = views_count
purchase.views_availability = domain.PostViewsAvailability.AVAILABLE
purchase.last_views_fetch_at = fetched_at
await self.database.update_purchase(purchase)
placement.views_count = views_count
placement.views_availability = domain.PostViewsAvailability.AVAILABLE
placement.last_views_fetch_at = fetched_at
await self.database.update_placement(placement)
snapshot = domain.ViewsSnapshot(
purchase_id=purchase.id,
history = domain.PlacementViewsHistory(
placement_id=placement.id,
views_count=views_count,
fetched_at=fetched_at,
)
await self.database.create_views_snapshot(snapshot)
await self.database.create_placement_views_history(history)
log.info('Views fetched for purchase %s: %d', purchase.id, views_count)
log.info('Views fetched for placement %s: %d', placement.id, views_count)
return dto.FetchViewsManuallyOutput(
purchase_id=purchase.id,
placement_id=placement.id,
views_count=views_count,
views_availability=domain.PostViewsAvailability.AVAILABLE,
fetched_at=fetched_at,
)
purchase.views_availability = domain.PostViewsAvailability.UNAVAILABLE
purchase.last_views_fetch_at = fetched_at
await self.database.update_purchase(purchase)
placement.views_availability = domain.PostViewsAvailability.UNAVAILABLE
placement.last_views_fetch_at = fetched_at
await self.database.update_placement(placement)
log.warning('Failed to fetch views for purchase %s', purchase.id)
log.warning('Failed to fetch views for placement %s', placement.id)
return dto.FetchViewsManuallyOutput(
purchase_id=purchase.id,
placement_id=placement.id,
views_count=None,
views_availability=domain.PostViewsAvailability.UNAVAILABLE,
fetched_at=fetched_at,

28
src/usecase/views/get_views_history.py
View File

@@ -12,26 +12,26 @@ log = logging.getLogger(__name__)
async def get_views_history(self: 'Usecase', input: dto.GetViewsHistoryInput) -> dto.GetViewsHistoryOutput:
"""Получить историю просмотров для закупа."""
async with self.database.transaction():
purchase = await self.database.get_purchase(input.user_id, input.purchase_id)
if not purchase:
log.warning('Purchase %s not found for user %s', input.purchase_id, input.user_id)
raise domain.PurchaseNotFound(input.purchase_id)
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)
snapshots = await self.database.get_views_history(
input.purchase_id,
histories = await self.database.get_views_history(
input.placement_id,
from_date=input.from_date,
to_date=input.to_date,
)
return dto.GetViewsHistoryOutput(
snapshots=[
dto.ViewsSnapshotOutput(
id=snapshot.id,
purchase_id=snapshot.purchase_id,
views_count=snapshot.views_count,
fetched_at=snapshot.fetched_at,
created_at=snapshot.created_at,
histories=[
dto.PlacementViewsHistoryOutput(
id=history.id,
placement_id=history.placement_id,
views_count=history.views_count,
fetched_at=history.fetched_at,
created_at=history.created_at,
)
for snapshot in snapshots
for history in histories
]
)

39
src/usecase/views/run_views_worker_cycle.py
View File

@@ -1,6 +1,7 @@
import asyncio
import datetime
import logging
import uuid
from typing import TYPE_CHECKING, cast
from aiolimiter import AsyncLimiter
@@ -13,53 +14,55 @@ if TYPE_CHECKING:
log = logging.getLogger(__name__)
async def _process_purchase(self: 'Usecase', purchase_id, user_id, ad_post_url: str):
async def _process_placement(
self: 'Usecase', placement_id: uuid.UUID, user_id: uuid.UUID, ad_post_url: str
) -> None:
views_count = await self.telegram_parser.get_post_views(ad_post_url)
fetched_at = datetime.datetime.now(datetime.UTC)
async with self.database.transaction():
p = await self.database.get_purchase(user_id=user_id, purchase_id=purchase_id)
p = await self.database.get_placement(user_id=user_id, placement_id=placement_id)
if not p:
log.error('Purchase %s not found', purchase_id)
log.error('Placement %s not found', placement_id)
return
p.last_views_fetch_at = fetched_at
if not views_count:
p.views_availability = domain.PostViewsAvailability.UNAVAILABLE
await self.database.update_purchase(p)
log.warning('Failed to fetch views for %s', purchase_id)
await self.database.update_placement(p)
log.warning('Failed to fetch views for %s', placement_id)
return
p.views_count = views_count
p.views_availability = domain.PostViewsAvailability.AVAILABLE
await self.database.update_purchase(p)
await self.database.update_placement(p)
snapshot = domain.ViewsSnapshot(
purchase_id=purchase_id,
history = domain.PlacementViewsHistory(
placement_id=placement_id,
views_count=views_count,
fetched_at=fetched_at,
)
await self.database.create_views_snapshot(snapshot)
await self.database.create_placement_views_history(history)
log.info('Updated purchase %s: %d', purchase_id, views_count)
log.info('Updated placement %s: %d', placement_id, views_count)
async def run_views_worker_cycle(self: 'Usecase', interval_seconds: int) -> None:
async with self.database.transaction():
purchases = await self.database.get_active_purchases_with_urls()
placements = await self.database.get_active_placements_with_urls()
if not purchases:
log.debug('ViewsWorkerCycle: No purchases to process')
if not placements:
log.debug('ViewsWorkerCycle: No placements to process')
return
limiter = AsyncLimiter(max_rate=len(purchases), time_period=interval_seconds)
log.info('Processing %d purchases for %d seconds', len(purchases), interval_seconds)
limiter = AsyncLimiter(max_rate=len(placements), time_period=interval_seconds)
log.info('Processing %d placements for %d seconds', len(placements), interval_seconds)
async def process(p):
async def process(p: domain.Placement) -> None:
async with limiter:
try:
await _process_purchase(self, p.id, p.user_id, cast(str, p.ad_post_url))
await _process_placement(self, p.id, p.user_id, cast(str, p.ad_post_url))
except Exception:
log.exception('Error updating views for %s', p.id)
await asyncio.gather(*(process(p) for p in purchases))
await asyncio.gather(*(process(p) for p in placements))

66
src/usecase/views/update_views_manually.py
View File

@@ -10,47 +10,47 @@ if TYPE_CHECKING:
log = logging.getLogger(__name__)
async def update_views_manually(self: 'Usecase', input: dto.UpdateViewsManuallyInput) -> dto.PurchaseOutput:
async def update_views_manually(self: 'Usecase', input: dto.UpdateViewsManuallyInput) -> dto.PlacementOutput:
async with self.database.transaction():
purchase = await self.database.get_purchase(input.user_id, input.purchase_id)
if not purchase:
log.warning('Purchase %s not found for user %s', input.purchase_id, input.user_id)
raise domain.PurchaseNotFound(input.purchase_id)
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)
purchase.views_count = input.views_count
purchase.views_availability = domain.PostViewsAvailability.MANUAL
purchase.last_views_fetch_at = fetched_at
await self.database.update_purchase(purchase)
placement.views_count = input.views_count
placement.views_availability = domain.PostViewsAvailability.MANUAL
placement.last_views_fetch_at = fetched_at
await self.database.update_placement(placement)
snapshot = domain.ViewsSnapshot(
purchase_id=purchase.id,
history = domain.PlacementViewsHistory(
placement_id=placement.id,
views_count=input.views_count,
fetched_at=fetched_at,
)
await self.database.create_views_snapshot(snapshot)
await self.database.create_placement_views_history(history)
log.info('Views manually updated for purchase %s: %d', purchase.id, input.views_count)
log.info('Views manually updated for placement %s: %d', placement.id, input.views_count)
return dto.PurchaseOutput(
id=purchase.id,
target_channel_id=purchase.target_channel_id,
target_channel_title=purchase.target_channel.title,
external_channel_id=purchase.external_channel_id,
external_channel_title=purchase.external_channel.title,
creative_id=purchase.creative_id,
creative_name=purchase.creative.name,
placement_date=purchase.placement_date,
cost=purchase.cost,
comment=purchase.comment,
ad_post_url=purchase.ad_post_url,
invite_link_type=purchase.invite_link_type,
invite_link=purchase.invite_link,
status=purchase.status,
subscriptions_count=purchase.subscriptions_count,
views_count=purchase.views_count,
views_availability=purchase.views_availability,
last_views_fetch_at=purchase.last_views_fetch_at,
created_at=purchase.created_at,
return dto.PlacementOutput(
id=placement.id,
target_channel_id=placement.target_channel_id,
target_channel_title=placement.target_channel.title,
external_channel_id=placement.external_channel_id,
external_channel_title=placement.external_channel.title,
creative_id=placement.creative_id,
creative_name=placement.creative.name,
placement_date=placement.placement_date,
cost=placement.cost,
comment=placement.comment,
ad_post_url=placement.ad_post_url,
invite_link_type=placement.invite_link_type,
invite_link=placement.invite_link,
status=placement.status,
subscriptions_count=placement.subscriptions_count,
views_count=placement.views_count,
views_availability=placement.views_availability,
last_views_fetch_at=placement.last_views_fetch_at,
created_at=placement.created_at,
)