feat: вфыв

services/auth.py

@@ -10,6 +10,7 @@ from starlette import status
 import backend.config
 import constants
 from backend.session import get_session
+from enums.user import UserRole
 from models import User
 from schemas.auth import *
 from services.base import BaseService
@@ -52,8 +53,11 @@ class AuthService(BaseService):
 
         user: Union[User, None] = await self.session.scalar(select(User).where(User.telegram_id == request.id))
         if not user:
-            user = User(telegram_id=request.id,
-                        is_admin=False)
+            user = User(
+                telegram_id=request.id,
+                is_admin=False,
+                role_key=UserRole.user
+            )
             self.session.add(user)
             await self.session.commit()
         access_token = self._generate_jwt_token(user)

services/deal.py

@@ -240,13 +240,21 @@ class DealService(BaseService):
 
     async def update_general_info(self, request: DealUpdateGeneralInfoRequest) -> DealUpdateGeneralInfoResponse:
         try:
-            deal = await self.session.scalar(select(Deal).where(Deal.id == request.deal_id))
+            deal: Deal = await self.session.scalar(select(Deal).where(Deal.id == request.deal_id))
             if not deal:
                 raise HTTPException(status_code=404, detail="Сделка не найдена")
             deal.name = request.data.name
             deal.comment = request.data.comment
             deal.is_deleted = request.data.is_deleted
             deal.is_completed = request.data.is_completed
+
+            # Updating shipping warehouse
+            shipping_warehouse_service = ShippingWarehouseService(self.session)
+            shipping_warehouse = await shipping_warehouse_service.get_by_name(request.data.shipping_warehouse)
+            if not shipping_warehouse and request.data.shipping_warehouse:
+                shipping_warehouse = await shipping_warehouse_service.create_by_name(request.data.shipping_warehouse)
+
+            deal.shipping_warehouse = shipping_warehouse
             await self.session.commit()
             return DealUpdateGeneralInfoResponse(ok=True, message='Данные о сделке успешно обновлены')
         except Exception as e:

services/position.py

@@ -0,0 +1,32 @@
+from typing import Union
+
+from sqlalchemy import select, insert
+
+from models import Position
+from schemas.position import *
+from services.base import BaseService
+
+
+class PositionService(BaseService):
+    async def get_all(self) -> GetAllPositionsResponse:
+        stmt = select(Position).order_by(Position.key)
+        positions = (await self.session.scalars(stmt)).all()
+        positions_schemas = [PositionSchema.model_validate(position) for position in positions]
+        response = GetAllPositionsResponse(positions=positions_schemas)
+        return response
+
+    async def get_by_key(self, key: str) -> Union[Position, None]:
+        stmt = select(Position).where(Position.key == key)
+        return await self.session.scalar(stmt)
+
+
+    async def create(self, request: CreatePositionRequest) -> CreatePositionResponse:
+        try:
+            if await self.get_by_key(request.data.key):
+                return CreatePositionResponse(ok=False, message='Должность с таким ключом уже существует')
+            stmt = insert(Position).values(request.data.model_dump())
+            await self.session.execute(stmt)
+            await self.session.commit()
+            return CreatePositionResponse(ok=True, message='Должность успешно создана')
+        except Exception as e:
+            return CreatePositionResponse(ok=False, message=str(e))

services/role.py

@@ -0,0 +1,14 @@
+from sqlalchemy import select
+
+from models import Role
+from schemas.role import *
+from services.base import BaseService
+
+
+class RoleService(BaseService):
+    async def get_all(self) -> GetAllRolesResponse:
+        stmt = (select(Role).order_by(Role.key))
+        roles = (await self.session.scalars(stmt)).all()
+        return GetAllRolesResponse(
+            roles=RoleSchema.from_orm_list(roles)
+        )

services/user.py

@@ -0,0 +1,47 @@
+from sqlalchemy import select, update, delete, insert
+
+from models import User, user_position
+from services.base import BaseService
+from schemas.user import *
+
+
+class UserService(BaseService):
+    async def get_all(self) -> GetAllUsersResponse:
+        stmt = (
+            select(User)
+            .order_by(User.id.desc())
+            # .where(User.is_deleted == False)
+        )
+        users = (await self.session.scalars(stmt)).all()
+        users_schemas = [UserSchema.model_validate(user) for user in users]
+        return GetAllUsersResponse(users=users_schemas)
+
+    async def get_by_id(self, user_id: int) -> Optional[User]:
+        return await self.session.scalar(select(User).where(User.id == user_id))
+
+    async def update(self, request: UpdateUserRequest) -> UpdateUserResponse:
+        try:
+            if not self.get_by_id(request.data.id):
+                return UpdateUserResponse(ok=False, message='Указанный пользователь не найден')
+            base_fields = request.data.model_dump_parent()
+            stmt = update(User).values(**base_fields).where(User.id == request.data.id)
+            await self.session.execute(stmt)
+            await self.session.flush()
+
+            # Updating position
+            stmt = delete(user_position).where(user_position.c.user_id == request.data.id)
+            await self.session.execute(stmt)
+            await self.session.flush()
+
+            if not request.data.position_key:
+                await self.session.commit()
+                return UpdateUserResponse(ok=True, message='Пользователь успешно обновлен')
+            stmt = insert(user_position).values(**{
+                'user_id': request.data.id,
+                'position_key': request.data.position_key
+            })
+            await self.session.execute(stmt)
+            await self.session.commit()
+            return UpdateUserResponse(ok=True, message='Пользователь успешно обновлен')
+        except Exception as e:
+            pass