feat: projects and boards

routers/__init__.py

@@ -1,5 +1,6 @@
 from .auth import auth_router
 from .deal import deal_router
+from .group import deal_group_router
 from .client import client_router
 from .service import service_router
 from .product import product_router
@@ -20,3 +21,6 @@ from .transaction import transaction_router
 from .shipping import shipping_router
 from .department import department_router
 from .residues import residues_router
+from .project import project_router
+from .board import board_router
+from .status import status_router

routers/board.py

@@ -0,0 +1,79 @@
+from typing import Annotated
+
+from fastapi import APIRouter, Depends
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from backend.session import get_session
+from schemas.board import *
+from services.auth import guest_user, authorized_user
+from services.board import BoardService
+
+board_router = APIRouter(
+    prefix="/board",
+    tags=["board"],
+    dependencies=[Depends(guest_user)]
+)
+
+
+@board_router.get(
+    "/{project_id}",
+    response_model=GetBoardsResponse,
+    operation_id="get_boards",
+)
+async def get_boards(
+        session: Annotated[AsyncSession, Depends(get_session)],
+        project_id: int,
+):
+    return await BoardService(session).get_boards(project_id)
+
+
+@board_router.post(
+    '/',
+    response_model=CreateBoardResponse,
+    operation_id="create_board",
+    dependencies=[Depends(authorized_user)]
+)
+async def create_board(
+        session: Annotated[AsyncSession, Depends(get_session)],
+        request: CreateBoardRequest,
+):
+    return await BoardService(session).create_board(request)
+
+
+@board_router.patch(
+    '/',
+    response_model=UpdateBoardResponse,
+    operation_id="update_board",
+    dependencies=[Depends(authorized_user)]
+)
+async def update_board(
+        session: Annotated[AsyncSession, Depends(get_session)],
+        request: UpdateBoardRequest,
+):
+    return await BoardService(session).update_board(request)
+
+
+@board_router.patch(
+    '/order',
+    response_model=UpdateBoardOrderResponse,
+    operation_id="update_board_order",
+    dependencies=[Depends(authorized_user)]
+)
+async def update_board_order(
+        session: Annotated[AsyncSession, Depends(get_session)],
+        request: UpdateBoardOrderRequest,
+):
+    return await BoardService(session).update_board_order(request)
+
+
+@board_router.delete(
+    '/{board_id}',
+    response_model=DeleteBoardResponse,
+    operation_id="delete_board",
+    dependencies=[Depends(authorized_user)]
+)
+async def delete_board(
+        session: Annotated[AsyncSession, Depends(get_session)],
+        board_id: int,
+):
+    return await BoardService(session).delete_board(board_id)

routers/deal.py

@@ -24,17 +24,6 @@ deal_router = APIRouter(
 
 
 # region Deal
-@deal_router.post(
-    '/create',
-    dependencies=[Depends(authorized_user)]
-)
-async def create(
-        request: DealCreateRequest,
-        session: Annotated[AsyncSession, Depends(get_session)],
-        user: Annotated[User, Depends(get_current_user)]
-):
-    return await DealService(session).create(request, user)
-
 
 @deal_router.post(
     '/delete',
@@ -151,9 +140,10 @@ async def get_deal_by_id(
 )
 async def update_general_info(
         request: DealUpdateGeneralInfoRequest,
-        session: Annotated[AsyncSession, Depends(get_session)]
+        session: Annotated[AsyncSession, Depends(get_session)],
+        user: CurrentUserDependency,
 ):
-    return await DealService(session).update_general_info(request)
+    return await DealService(session).update_general_info(request, user)
 
 
 @deal_router.post(
@@ -494,71 +484,3 @@ async def get_deal_products_barcodes_pdf(
 
 
 # endregion
-
-# region Deal groups
-@deal_router.post(
-    '/add-to-group',
-    response_model=DealAddToGroupResponse,
-    operation_id='add_deal_to_group',
-    dependencies=[Depends(authorized_user)]
-)
-async def add_to_group(
-        request: DealAddToGroupRequest,
-        session: SessionDependency,
-        user: CurrentUserDependency
-):
-    return await DealService(session).add_to_group(user, request)
-
-@deal_router.post(
-    '/create-group',
-    response_model=DealCreateGroupResponse,
-    operation_id='create_deal_group',
-    dependencies=[Depends(authorized_user)]
-)
-async def create_group(
-        request: DealCreateGroupRequest,
-        session: SessionDependency,
-        user: CurrentUserDependency
-):
-    return await DealService(session).create_group(user, request)
-
-
-@deal_router.post(
-    '/remove-from-group',
-    response_model=DealRemoveFromGroupResponse,
-    operation_id='remove_deal_from_group',
-    dependencies=[Depends(authorized_user)]
-)
-async def remove_from_group(
-        request: DealRemoveFromGroupRequest,
-        session: SessionDependency,
-):
-    return await DealService(session).remove_from_group( request)
-
-# route to update group name
-@deal_router.post(
-    '/group/update',
-    response_model=DealGroupUpdateResponse,
-    operation_id='update_deal_group',
-    dependencies=[Depends(authorized_user)]
-)
-async def update_group(
-        request: DealGroupUpdateRequest,
-        session: SessionDependency,
-):
-    return await DealService(session).update_group(request)
-
-# route to change group status
-@deal_router.post(
-    '/group/change-status',
-    response_model=DealGroupChangeStatusResponse,
-    operation_id='change_deal_group_status',
-    dependencies=[Depends(authorized_user)]
-)
-async def change_group_status(
-        request: DealGroupChangeStatusRequest,
-        session: SessionDependency,
-        user: CurrentUserDependency
-):
-    return await DealService(session).change_group_status(user,request)
-# endregion

routers/group.py

@@ -0,0 +1,79 @@
+from fastapi import APIRouter, Depends
+
+from backend.dependecies import SessionDependency, CurrentUserDependency
+from schemas.group import *
+from services.auth import authorized_user
+from services.deal_group import DealGroupService
+
+deal_group_router = APIRouter(
+    prefix='/deal-group',
+    tags=['deal-group'],
+)
+
+
+@deal_group_router.patch(
+    '/',
+    response_model=DealGroupUpdateResponse,
+    operation_id='update_deal_group',
+    dependencies=[Depends(authorized_user)]
+)
+async def update_group(
+        request: DealGroupUpdateRequest,
+        session: SessionDependency,
+):
+    return await DealGroupService(session).update_group(request)
+
+
+@deal_group_router.post(
+    '/',
+    response_model=DealCreateGroupResponse,
+    operation_id='create_deal_group',
+    dependencies=[Depends(authorized_user)]
+)
+async def create_group(
+        request: DealCreateGroupRequest,
+        session: SessionDependency,
+        user: CurrentUserDependency
+):
+    return await DealGroupService(session).create_group(user, request)
+
+
+@deal_group_router.patch(
+    '/change-status',
+    response_model=DealGroupChangeStatusResponse,
+    operation_id='change_status',
+    dependencies=[Depends(authorized_user)]
+)
+async def change_status(
+        request: DealGroupChangeStatusRequest,
+        session: SessionDependency,
+        user: CurrentUserDependency
+):
+    return await DealGroupService(session).change_group_status(user,request)
+
+
+@deal_group_router.post(
+    '/deal',
+    response_model=DealAddToGroupResponse,
+    operation_id='add_deal',
+    dependencies=[Depends(authorized_user)]
+)
+async def add_deal(
+        request: DealAddToGroupRequest,
+        session: SessionDependency,
+        user: CurrentUserDependency
+):
+    return await DealGroupService(session).add_deal(user, request)
+
+
+@deal_group_router.delete(
+    '/deal',
+    response_model=DealRemoveFromGroupResponse,
+    operation_id='remove_deal',
+    dependencies=[Depends(authorized_user)]
+)
+async def remove_deal(
+        request: DealRemoveFromGroupRequest,
+        session: SessionDependency,
+):
+    return await DealGroupService(session).remove_deal(request)

routers/project.py

@@ -0,0 +1,65 @@
+from typing import Annotated
+
+from fastapi import APIRouter, Depends
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from backend.session import get_session
+from schemas.project import *
+from services.auth import guest_user, authorized_user
+from services.project import ProjectService
+
+project_router = APIRouter(
+    prefix="/project",
+    tags=["project"],
+    dependencies=[Depends(guest_user)]
+)
+
+
+@project_router.get(
+    "/",
+    response_model=GetProjectsResponse,
+    operation_id="get_projects",
+)
+async def get_projects(
+        session: Annotated[AsyncSession, Depends(get_session)],
+):
+    return await ProjectService(session).get_projects()
+
+
+@project_router.post(
+    '/',
+    response_model=CreateProjectResponse,
+    operation_id="create_project",
+    dependencies=[Depends(authorized_user)]
+)
+async def create_project(
+        session: Annotated[AsyncSession, Depends(get_session)],
+        request: CreateProjectRequest,
+):
+    return await ProjectService(session).create_project(request)
+
+
+@project_router.patch(
+    '/',
+    response_model=UpdateProjectResponse,
+    operation_id="update_project",
+    dependencies=[Depends(authorized_user)]
+)
+async def update_project(
+        session: Annotated[AsyncSession, Depends(get_session)],
+        request: UpdateProjectRequest,
+):
+    return await ProjectService(session).update_project(request)
+
+
+@project_router.delete(
+    '/{project_id}',
+    response_model=DeleteProjectResponse,
+    operation_id="delete_project",
+    dependencies=[Depends(authorized_user)]
+)
+async def delete_project(
+        session: Annotated[AsyncSession, Depends(get_session)],
+        project_id: int,
+):
+    return await ProjectService(session).delete_project(project_id)

routers/status.py

@@ -0,0 +1,67 @@
+from typing import Annotated
+
+from fastapi import APIRouter, Depends
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from backend.session import get_session
+from schemas.status import *
+from services.auth import guest_user, authorized_user
+from services.status import StatusService
+
+status_router = APIRouter(
+    prefix="/status",
+    tags=["status"],
+    dependencies=[Depends(guest_user)]
+)
+
+
+@status_router.post(
+    '/',
+    response_model=CreateStatusResponse,
+    operation_id="create_status",
+    dependencies=[Depends(authorized_user)]
+)
+async def create_status(
+        session: Annotated[AsyncSession, Depends(get_session)],
+        request: CreateStatusRequest,
+):
+    return await StatusService(session).create_status(request)
+
+
+@status_router.patch(
+    '/',
+    response_model=UpdateStatusResponse,
+    operation_id="update_status",
+    dependencies=[Depends(authorized_user)]
+)
+async def update_status(
+        session: Annotated[AsyncSession, Depends(get_session)],
+        request: UpdateStatusRequest,
+):
+    return await StatusService(session).update_status(request)
+
+
+@status_router.patch(
+    '/order',
+    response_model=UpdateStatusOrderResponse,
+    operation_id="update_status_order",
+    dependencies=[Depends(authorized_user)]
+)
+async def update_status_order(
+        session: Annotated[AsyncSession, Depends(get_session)],
+        request: UpdateStatusOrderRequest,
+):
+    return await StatusService(session).update_status_order(request)
+
+
+@status_router.delete(
+    '/{status_id}',
+    response_model=DeleteStatusResponse,
+    operation_id="delete_status",
+    dependencies=[Depends(authorized_user)]
+)
+async def delete_status(
+        session: Annotated[AsyncSession, Depends(get_session)],
+        status_id: int,
+):
+    return await StatusService(session).delete_status(status_id)