othr

routers/deal.py

@@ -24,6 +24,15 @@ async def create(
     return await DealService(session).create(request, user)
 
 
+@deal_router.post('/quickCreate', response_model=DealQuickCreateResponse)
+async def quick_create(
+        request: DealQuickCreateRequest,
+        session: Annotated[AsyncSession, Depends(get_session)],
+        user: Annotated[User, Depends(get_current_user)]
+):
+    return await DealService(session).quick_create(request, user)
+
+
 @deal_router.post('/changeStatus', response_model=DealChangeStatusResponse)
 async def change_status(
         request: DealChangeStatusRequest,

schemas/client.py

@@ -12,5 +12,10 @@ class ClientSearchRequest(CustomModel):
     name: str
 
 
+class ClientCreateRequest(CustomModel):
+    name: str
+    address: str
+
+
 class ClientSearchResponse(CustomModel):
     clients: List[ClientSchema]

schemas/deal.py

@@ -17,6 +17,18 @@ class DealCreateRequest(CustomModel):
     name: str
 
 
+class DealQuickCreateRequest(CustomModel):
+    name: str
+    client_name: str
+    client_address: str
+    comment: str
+    acceptance_date: datetime.datetime
+
+
+class DealQuickCreateResponse(CustomModel):
+    deal_id: int
+
+
 class DealCreateResponse(CustomModel):
     ok: bool
 

services/client.py

@@ -1,3 +1,6 @@
+import datetime
+from typing import Union
+
 from sqlalchemy import select
 
 from models import Client
@@ -6,6 +9,17 @@ from schemas.client import *
 
 
 class ClientService(BaseService):
+
+    async def get_by_name(self, name: str) -> Union[Client, None]:
+        client = await self.session.scalar(select(Client).where(Client.name == name))
+        return client
+
+    async def create_client_raw(self, name: str, address: str) -> Client:
+        client = Client(name=name, address=address, created_at=datetime.datetime.now())
+        self.session.add(client)
+        await self.session.flush()
+        return client
+
     async def search_clients(self, request: ClientSearchRequest) -> ClientSearchResponse:
         query = await self.session.scalars(select(Client)
                                            .where(Client.name.ilike(f'%{request.name}%')))

services/deal.py

@@ -1,18 +1,35 @@
 import datetime
+from typing import Type, Union
 
 from sqlalchemy import select
 
-from models import User
+from models import User, Deal
 from models.deal import *
 from schemas.deal import *
 from services.base import BaseService
+from services.client import ClientService
 
 
 class DealService(BaseService):
 
-    async def _get_deal_by_id(self, deal_id) -> Deal:
+    async def _get_deal_by_id(self, deal_id) -> Union[Deal, None]:
         return await self.session.get(Deal, deal_id)
 
+    async def change_status(self, deal: Deal, status: DealStatus, user: User,
+                            deadline: datetime.datetime = None) -> DealStatusHistory:
+        deadline = deadline
+        status_change = DealStatusHistory(
+            deal_id=deal.id,
+            user_id=user.id,
+            changed_at=datetime.datetime.now(),
+            from_status=deal.current_status,
+            to_status=status,
+            next_status_deadline=deadline
+        )
+        self.session.add(status_change)
+        await self.session.flush()
+        return status_change
+
     async def create(self, request: DealCreateRequest, user: User) -> DealCreateResponse:
         deal = Deal(
             name=request.name,
@@ -23,32 +40,33 @@ class DealService(BaseService):
         await self.session.flush()
 
         # Append status history
-        status_change = DealStatusHistory(
+        await self.change_status(deal, DealStatus.AWAITING_ACCEPTANCE, user)
-            deal_id=request.deal_id,
-            user_id=user.id,
-            changed_at=datetime.datetime.now(),
-            from_status=deal.current_status,
-            to_status=DealStatus.CREATED.AWAITING_ACCEPTANCE
-        )
-        self.session.add(status_change)
 
         await self.session.commit()
         return DealCreateResponse(ok=True)
 
-    async def change_status(self, request: DealChangeStatusRequest, user: User) -> DealChangeStatusResponse:
+    async def quick_create(self, request: DealQuickCreateRequest, user: User) -> DealQuickCreateResponse:
+        client_service = ClientService(self.session)
+        client = await client_service.get_by_name(request.client_name)
+        if not client:
+            client = await client_service.create_client_raw(request.client_name, request.client_address)
+        deal = Deal(
+            name=request.name,
+            created_at=datetime.datetime.now(),
+            client_id=client.id,
+            current_status=DealStatus.CREATED
+        )
+        self.session.add(deal)
+        await self.session.flush()
+        await self.change_status(deal, DealStatus.AWAITING_ACCEPTANCE, user, deadline=request.acceptance_date)
+        await self.session.commit()
+        return DealQuickCreateResponse(deal_id=deal.id)
+
+    async def change_status_manual(self, request: DealChangeStatusRequest, user: User) -> DealChangeStatusResponse:
         # Changing current status
         deal = await self._get_deal_by_id(request.deal_id)
-        from_status = deal.current_status
+        if not deal:
-        deal.current_status = request.new_status
+            return DealChangeStatusResponse(ok=False)
-
+        await self.change_status(deal, DealStatus(request.new_status), user)
-        # Append status history
-        status_change = DealStatusHistory(
-            deal_id=request.deal_id,
-            user_id=user.id,
-            changed_at=datetime.datetime.now(),
-            from_status=from_status,
-            to_status=request.new_status
-        )
-        self.session.add(status_change)
         await self.session.commit()
         return DealChangeStatusResponse(ok=True)