feat: parser, refactoring

src/adapter/postgres.py

@@ -67,12 +67,6 @@ class Postgres(DatabaseBase):
         result = await self.session.execute(q)
         return result.scalar_one_or_none()
 
-    async def create_target_channel(self, channel: domain.TargetChannel) -> domain.TargetChannel:
-        self.session.add(channel)
-        await self.session.flush()
-        await self.session.refresh(channel)
-        return channel
-
     async def upsert_target_channel(self, channel: domain.TargetChannel) -> domain.TargetChannel:
         existing = await self.get_target_channel(user_id=channel.user_id, telegram_id=channel.telegram_id)
 
@@ -302,14 +296,6 @@ class Postgres(DatabaseBase):
         await self.session.execute(q)
         await self.session.flush()
 
-    async def check_creative_in_use(self, creative_id: uuid.UUID) -> bool:
-        q = select(domain.Placement).where(
-            domain.Placement.creative_id == creative_id,
-            domain.Placement.status == domain.PlacementStatus.ACTIVE,
-        )
-        result = await self.session.execute(q)
-        return result.scalar_one_or_none() is not None
-
     async def get_placement_by_invite_link(self, invite_link: str) -> domain.Placement | None:
         q = (
             select(domain.Placement)
@@ -323,6 +309,50 @@ class Postgres(DatabaseBase):
         result = await self.session.execute(q)
         return result.scalar_one_or_none()
 
+    async def get_placement_by_id(self, placement_id: uuid.UUID) -> domain.Placement | None:
+        return await self.session.get(domain.Placement, 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 self.session.get(domain.Placement, 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 self.session.flush()
+        await self.session.refresh(placement)
+        return placement
+
+    async def update_placement_from_post_deleted(self, placement_id: uuid.UUID) -> domain.Placement:
+        placement = await self.session.get(domain.Placement, placement_id)
+        if not placement:
+            raise ValueError(f'Placement {placement_id} not found')
+
+        placement.status = domain.PlacementStatus.DELETED
+
+        await self.session.flush()
+        await self.session.refresh(placement)
+        return placement
+
+    async def update_placement_views(self, placement_id: uuid.UUID, views_count: int) -> domain.Placement:
+        placement = await self.session.get(domain.Placement, 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 self.session.flush()
+        await self.session.refresh(placement)
+        return placement
+
     async def get_subscriber(self, telegram_id: int) -> domain.Subscriber | None:
         q = select(domain.Subscriber).where(domain.Subscriber.telegram_id == telegram_id)
         result = await self.session.execute(q)
@@ -429,20 +459,6 @@ class Postgres(DatabaseBase):
         result = await self.session.execute(q)
         return list(result.scalars().all())
 
-    async def get_active_placements_with_urls(self) -> list[domain.Placement]:
-        q = (
-            select(domain.Placement)
-            .where(
-                domain.Placement.status == domain.PlacementStatus.ACTIVE,
-                domain.Placement.ad_post_url.isnot(None),
-                domain.Placement.views_availability != domain.PostViewsAvailability.MANUAL,
-            )
-            .order_by(domain.Placement.created_at.asc())
-        )
-
-        result = await self.session.execute(q)
-        return list(result.scalars().all())
-
     async def get_telegram_state(self, telegram_id: int) -> domain.TelegramState | None:
         q = select(domain.TelegramState).where(domain.TelegramState.telegram_id == telegram_id)
         result = await self.session.execute(q)