fix: identify StarsPurchase (#4)

Author: emptybutton

…cation/player/complete_stars_purshase.py …layer/complete_stars_purshase_payment.pysrc/ttt/application/player/complete_stars_purshase.py renamed to src/ttt/application/player/complete_stars_purshase_payment.py src/ttt/application/player/complete_stars_purshase.py renamed to src/ttt/application/player/complete_stars_purshase_payment.py

@@ -8,12 +8,12 @@
 )
 from ttt.application.player.ports.player_views import PlayerViews
 from ttt.application.player.ports.players import Players
-from ttt.entities.finance.payment.payment import PaymentAlreadyCompletedError
+from ttt.entities.finance.payment.payment import PaymentIsNotInProcessError
 from ttt.entities.tools.tracking import Tracking
 
 
 @dataclass(frozen=True, unsafe_hash=False)
-class CompleteStarsPurshase:
+class CompleteStarsPurshasePayment:
     clock: Clock
     inbox: PaidStarsPurchasePaymentInbox
     players: Players
@@ -32,13 +32,13 @@ async def __call__(self) -> None:
 
                 tracking = Tracking()
                 try:
-                    player.complete_stars_purchase(
+                    player.complete_stars_purchase_payment(
                         paid_payment.purshase_id,
                         paid_payment.success,
                         current_datetime,
                         tracking,
                     )
-                except (PaymentAlreadyCompletedError):
+                except (PaymentIsNotInProcessError):
                     ...
                 else:
                     await self.map_(tracking)

src/ttt/application/player/ports/player_views.py

@@ -74,12 +74,12 @@ async def render_selected_emoji_removed_view(
     ) -> None: ...
 
     @abstractmethod
-    async def render_wait_rubles_to_start_stars_purshase_view(
+    async def render_wait_stars_to_start_stars_purshase_view(
         self, location: PlayerLocation, /,
     ) -> None: ...
 
     @abstractmethod
-    async def render_non_exchangeable_rubles_for_stars_view(
+    async def render_invalid_stars_for_stars_purchase_view(
         self, location: PlayerLocation, /,
     ) -> None: ...
 

src/ttt/application/player/ports/stars_purchase_payment_gateway.py

@@ -1,5 +1,6 @@
 from abc import ABC, abstractmethod
 from collections.abc import AsyncIterable
+from uuid import UUID
 
 from ttt.application.player.dto.common import PaidStarsPurchasePayment
 from ttt.entities.core.player.location import PlayerLocation
@@ -8,13 +9,22 @@
 
 class StarsPurchasePaymentGateway(ABC):
     @abstractmethod
-    async def process_payment(
+    async def send_invoice(
         self,
         purshase: StarsPurchase,
         location: PlayerLocation,
-    ) -> None:
+    ) -> None: ...
+
+    @abstractmethod
+    async def start_payment(self, payment_id: UUID) -> None: ...
+
+    @abstractmethod
+    async def stop_payment_due_to_dublicate(self, payment_id: UUID) -> None:
         ...
 
+    @abstractmethod
+    async def stop_payment_due_to_error(self, payment_id: UUID) -> None: ...
+
     @abstractmethod
     def paid_payment_stream(self) -> AsyncIterable[PaidStarsPurchasePayment]:
         ...

…layer/initiate_stars_purchase_payment.py …plication/player/start_stars_purchase.pysrc/ttt/application/player/initiate_stars_purchase_payment.py renamed to src/ttt/application/player/start_stars_purchase.py src/ttt/application/player/initiate_stars_purchase_payment.py renamed to src/ttt/application/player/start_stars_purchase.py

@@ -12,14 +12,16 @@
     StarsPurchasePaymentGateway,
 )
 from ttt.entities.core.player.location import PlayerLocation
-from ttt.entities.core.player.stars_purchase import StarsPurchase
-from ttt.entities.core.stars import NonExchangeableRublesForStarsError
-from ttt.entities.finance.rubles import Rubles
+from ttt.entities.core.player.stars_purchase import (
+    InvalidStarsForStarsPurchaseError,
+    StarsPurchase,
+)
+from ttt.entities.core.stars import Stars
 from ttt.entities.tools.tracking import Tracking
 
 
 @dataclass(frozen=True, unsafe_hash=False)
-class InitiateStarsPurchasePayment:
+class StartStarsPurchase:
     fsm: PlayerFsm
     transaction: Transaction
     players: Players
@@ -29,39 +31,33 @@ class InitiateStarsPurchasePayment:
     payment_gateway: StarsPurchasePaymentGateway
     map_: Map
 
-    async def __call__(
-        self, location: PlayerLocation, rubles: Rubles,
-    ) -> None:
+    async def __call__(self, location: PlayerLocation, stars: Stars) -> None:
         async with self.transaction:
-            player, purchase_id, payment_id, current_datetime = await gather(
+            player, purchase_id = await gather(
                 self.players.player_with_id(location.player_id),
                 self.uuids.random_uuid(),
-                self.uuids.random_uuid(),
-                self.clock.current_datetime(),
             )
 
             tracking = Tracking()
             try:
-                player.initiate_stars_purchase_payment(
+                player.start_stars_purchase(
                     purchase_id,
                     location.chat_id,
-                    payment_id,
-                    rubles,
-                    current_datetime,
+                    stars,
                     tracking,
                 )
-            except NonExchangeableRublesForStarsError:
+            except InvalidStarsForStarsPurchaseError:
                 await self.fsm.set(None)
                 await (
                     self.player_views
-                    .render_non_exchangeable_rubles_for_stars_view(location)
+                    .render_invalid_stars_for_stars_purchase_view(location)
                 )
                 return
 
             await self.map_(tracking)
             await self.fsm.set(None)
             await gather(*[
-                self.payment_gateway.process_payment(it, location)
+                self.payment_gateway.send_invoice(it, location)
                 for it in tracking.new
                 if isinstance(it, StarsPurchase)
             ])

src/ttt/application/player/start_stars_purchase_payment.py

@@ -0,0 +1,50 @@
+from asyncio import gather
+from dataclasses import dataclass
+from uuid import UUID
+
+from ttt.application.common.ports.clock import Clock
+from ttt.application.common.ports.map import Map
+from ttt.application.common.ports.transaction import Transaction
+from ttt.application.common.ports.uuids import UUIDs
+from ttt.application.player.ports.players import Players
+from ttt.application.player.ports.stars_purchase_payment_gateway import (
+    StarsPurchasePaymentGateway,
+)
+from ttt.entities.core.player.player import NoPurchaseError
+from ttt.entities.finance.payment.payment import PaymentIsAlreadyBeingMadeError
+from ttt.entities.tools.tracking import Tracking
+
+
+@dataclass(frozen=True, unsafe_hash=False)
+class StartStarsPurchasePayment:
+    transaction: Transaction
+    uuids: UUIDs
+    clock: Clock
+    players: Players
+    payment_gateway: StarsPurchasePaymentGateway
+    map_: Map
+
+    async def __call__(self, player_id: int, purchase_id: UUID) -> None:
+        async with self.transaction:
+            player, payment_id, current_datetime = await gather(
+                self.players.player_with_id(player_id),
+                self.uuids.random_uuid(),
+                self.clock.current_datetime(),
+            )
+
+            tracking = Tracking()
+            try:
+                player.process_stars_purchase_payment(
+                    purchase_id, payment_id, current_datetime, tracking,
+                )
+            except PaymentIsAlreadyBeingMadeError:
+                await self.payment_gateway.stop_payment_due_to_dublicate(
+                    payment_id,
+                )
+            except NoPurchaseError:
+                await self.payment_gateway.stop_payment_due_to_error(
+                    payment_id,
+                )
+            else:
+                await self.map_(tracking)
+                await self.payment_gateway.start_payment(payment_id)

…layer/start_stars_purshase_completion.py …art_stars_purshase_payment_completion.pysrc/ttt/application/player/start_stars_purshase_completion.py renamed to src/ttt/application/player/start_stars_purshase_payment_completion.py src/ttt/application/player/start_stars_purshase_completion.py renamed to src/ttt/application/player/start_stars_purshase_payment_completion.py

@@ -10,7 +10,7 @@
 
 
 @dataclass(frozen=True, unsafe_hash=False)
-class StartStarsPurshaseCompletion:
+class StartStarsPurshasePaymentCompletion:
     inbox: PaidStarsPurchasePaymentInbox
     payment_gateway: StarsPurchasePaymentGateway
     player_views: PlayerViews

…r/wait_rubles_to_start_stars_purshase.py …er/wait_stars_to_start_stars_purshase.pysrc/ttt/application/player/wait_rubles_to_start_stars_purshase.py renamed to src/ttt/application/player/wait_stars_to_start_stars_purshase.py src/ttt/application/player/wait_rubles_to_start_stars_purshase.py renamed to src/ttt/application/player/wait_stars_to_start_stars_purshase.py

@@ -6,12 +6,12 @@
 
 
 @dataclass(frozen=True, unsafe_hash=False)
-class WaitRublesToStartStarsPurshase:
+class WaitStarsToStartStarsPurshase:
     fsm: PlayerFsm
     player_views: PlayerViews
 
     async def __call__(self, location: PlayerLocation) -> None:
         await (
             self.player_views
-            .render_wait_rubles_to_start_stars_purshase_view(location)
+            .render_wait_stars_to_start_stars_purshase_view(location)
         )

src/ttt/entities/core/player/player.py

@@ -9,6 +9,7 @@
 from ttt.entities.core.player.stars_purchase import StarsPurchase
 from ttt.entities.core.player.win import Win
 from ttt.entities.core.stars import Stars
+from ttt.entities.finance.payment.payment import cancel_payment, complete_payment
 from ttt.entities.finance.payment.success import PaymentSuccess
 from ttt.entities.finance.rubles import Rubles
 from ttt.entities.math.random import Random, deviated_int
@@ -185,48 +186,60 @@ def remove_selected_emoji(self, tracking: Tracking) -> None:
         self.selected_emoji_id = None
         tracking.register_mutated(self)
 
-    def initiate_stars_purchase_payment(  # noqa: PLR0913, PLR0917
+    def start_stars_purchase(
         self,
         purchase_id: UUID,
         purchase_chat_id: int,
-        payment_id: UUID,
-        paid_rubles: Rubles,
-        current_datetime: datetime,
+        purchase_stars: Stars,
         tracking: Tracking,
     ) -> None:
         """
-        :raises ttt.entities.core.stars.NonExchangeableRublesForStarsError:
+        :raises ttt.entities.core.stars.InvalidStarsForStarsPurchaseError:
         """
 
-        stars_purchase = StarsPurchase.initiate_payment(
+        stars_purchase = StarsPurchase.start(
             purchase_id,
             PlayerLocation(self.id, purchase_chat_id),
-            payment_id,
-            paid_rubles,
-            current_datetime,
+            purchase_stars,
             tracking,
         )
         self.stars_purchases.append(stars_purchase)
 
-    def complete_stars_purchase(
+    def process_stars_purchase_payment(
         self,
         purchase_id: UUID,
-        payment_success: PaymentSuccess,
+        payment_id: UUID,
         current_datetime: datetime,
         tracking: Tracking,
     ) -> None:
         """
         :raises ttt.entities.player.player.NoPurchaseError:
-        :raises ttt.entities.finance.payment.payment.PaymentAlreadyCompletedError:
+        :raises ttt.entities.finance.payment.payment.PaymentIsAlreadyBeingMadeError:
         """  # noqa: E501
 
         purchase = self._stars_purchase(purchase_id)
+        purchase.start_payment(payment_id, current_datetime, tracking)
 
-        self.account = self.account.map(
-            lambda stars: stars + purchase.new_stars,
-        )
+    def complete_stars_purchase_payment(
+        self,
+        purchase_id: UUID,
+        payment_success: PaymentSuccess,
+        current_datetime: datetime,
+        tracking: Tracking,
+    ) -> None:
+        """
+        :raises ttt.entities.player.player.NoPurchaseError:
+        :raises ttt.entities.finance.payment.payment.NoPaymentError:
+        :raises ttt.entities.finance.payment.payment.PaymentIsNotInProcessError:
+        """
+
+        purchase = self._stars_purchase(purchase_id)
+
+        self.account = self.account.map(lambda stars: stars + purchase.stars)
         tracking.register_mutated(self)
-        purchase.payment.complete(payment_success, current_datetime, tracking)
+        complete_payment(
+            purchase.payment, payment_success, current_datetime, tracking,
+        )
 
     def cancel_stars_purchase(
         self,
@@ -236,11 +249,12 @@ def cancel_stars_purchase(
     ) -> None:
         """
         :raises ttt.entities.player.player.NoPurchaseError:
-        :raises ttt.entities.finance.payment.payment.PaymentAlreadyCompletedError:
-        """  # noqa: E501
+        :raises ttt.entities.finance.payment.payment.NoPaymentError:
+        :raises ttt.entities.finance.payment.payment.PaymentIsNotInProcessError:
+        """
 
         purchase = self._stars_purchase(purchase_id)
-        purchase.payment.cancel(current_datetime, tracking)
+        cancel_payment(purchase.payment, current_datetime, tracking)
 
     def _stars_purchase(self, purchase_id: UUID) -> StarsPurchase:
         """