feat: billing guest access

2024-08-08 07:49:53 +03:00
parent a7c4fabed0
commit 97f835ffde
30 changed files with 682 additions and 140 deletions
--- a/routers/init.py
+++ b/routers/init.py
@@ -11,3 +11,4 @@ from .role import role_router
 from .marketplace import marketplace_router
 from .payroll import payroll_router
 from .time_tracking import time_tracking_router
+from .billing import billing_router
--- a/routers/barcode.py
+++ b/routers/barcode.py
@@ -4,19 +4,14 @@ from fastapi import APIRouter, Depends
 from sqlalchemy.ext.asyncio import AsyncSession

 from backend.session import get_session
-from schemas.barcode import (GetBarcodeTemplateByIdResponse,
-                             GetBarcodeTemplateByIdRequest,
-                             BarcodeTemplateCreateResponse,
-                             BarcodeTemplateCreateRequest, GetAllBarcodeTemplateAttributesResponse,
-                             CreateBarcodeTemplateAttributeResponse, CreateBarcodeTemplateAttributeRequest,
-                             BarcodeTemplateUpdateResponse, BarcodeTemplateUpdateRequest,
-                             GetAllBarcodeTemplatesResponse, BarcodeTemplateDeleteRequest,
-                             BarcodeTemplateDeleteResponse, GetAllBarcodeTemplateSizesResponse)
+from schemas.barcode import *
+from services.auth import authorized_user, guest_user
 from services.barcode import BarcodeService

 barcode_router = APIRouter(
    prefix='/barcode',
    tags=['barcode'],
+    dependencies=[Depends(guest_user)]
 )


--- a/routers/billing.py
+++ b/routers/billing.py
@@ -0,0 +1,51 @@
+from fastapi import APIRouter
+
+from backend.dependecies import SessionDependency, CurrentUserDependency
+from external.billing import BillStatusUpdateRequest
+from schemas.billing import *
+from services.billing import BillingService
+
+billing_router = APIRouter(
+    prefix='/billing',
+    tags=['billing']
+)
+
+
+@billing_router.post(
+    '/webhook'
+)
+async def webhook(
+        request: BillStatusUpdateRequest,
+        session: SessionDependency
+):
+    try:
+        await BillingService(session).process_update(request)
+        return {'ok': True}
+    except Exception as e:
+        print(e)
+        return {'ok': False}
+
+
+@billing_router.post(
+    '/create-deal-bill',
+    operation_id='create_deal_bill',
+    response_model=CreateDealBillResponse
+)
+async def create_deal_bill(
+        session: SessionDependency,
+        request: CreateDealBillRequest,
+        user: CurrentUserDependency
+):
+    return await BillingService(session).create_deal_billing(user, request)
+
+
+@billing_router.get(
+    '/deal-bill-request/{deal_id}',
+    response_model=GetDealBillById,
+    operation_id='get_deal_bill_by_id'
+)
+async def get_deal_bill_by_id(
+        deal_id: int,
+        session: SessionDependency
+):
+    return await BillingService(session).get_deal_bill_by_id(deal_id)
--- a/routers/client.py
+++ b/routers/client.py
@@ -6,13 +6,13 @@ from sqlalchemy.ext.asyncio import AsyncSession
 from backend.session import get_session
 from models import User
 from schemas.client import *
-from services.auth import get_current_user
+from services.auth import get_current_user, authorized_user
 from services.client import ClientService

 client_router = APIRouter(
    prefix="/client",
    tags=['client'],
-    dependencies=[Depends(get_current_user)]
+    dependencies=[Depends(authorized_user)]
 )


--- a/routers/deal.py
+++ b/routers/deal.py
@@ -3,22 +3,24 @@ from typing import Annotated
 from fastapi import APIRouter, Depends
 from sqlalchemy.ext.asyncio import AsyncSession

-from backend.dependecies import SessionDependency
+from backend.dependecies import SessionDependency, CurrentUserDependency
 from backend.session import get_session
 from models import User
 from schemas.deal import *
-from services.auth import get_current_user
+from services.auth import get_current_user, authorized_user, guest_user
 from services.deal import DealService

 deal_router = APIRouter(
    prefix='/deal',
    tags=['deal'],
-    dependencies=[Depends(get_current_user)]
 )


 # region Deal
-@deal_router.post('/create')
+@deal_router.post(
+    '/create',
+    dependencies=[Depends(authorized_user)]
+)
 async def create(
        request: DealCreateRequest,
        session: Annotated[AsyncSession, Depends(get_session)],
@@ -30,7 +32,8 @@ async def create(
@deal_router.post(
    '/delete',
    response_model=DealDeleteResponse,
-    operation_id='deleteDeal'
+    operation_id='deleteDeal',
+    dependencies=[Depends(authorized_user)]
 )
 async def delete(
        request: DealDeleteRequest,
@@ -39,7 +42,11 @@ async def delete(
    return await DealService(session).delete(request)


-@deal_router.post('/quickCreate', response_model=DealQuickCreateResponse)
+@deal_router.post(
+    '/quickCreate',
+    response_model=DealQuickCreateResponse,
+    dependencies=[Depends(authorized_user)]
+)
 async def quick_create(
        request: DealQuickCreateRequest,
        session: Annotated[AsyncSession, Depends(get_session)],
@@ -48,7 +55,11 @@ async def quick_create(
    return await DealService(session).quick_create(request, user)


-@deal_router.post('/changeStatus', response_model=DealChangeStatusResponse)
+@deal_router.post(
+    '/changeStatus',
+    response_model=DealChangeStatusResponse,
+    dependencies=[Depends(authorized_user)]
+)
 async def change_status(
        request: DealChangeStatusRequest,
        session: Annotated[AsyncSession, Depends(get_session)],
@@ -57,10 +68,12 @@ async def change_status(
    return await DealService(session).change_status_manual(request, user)


-@deal_router.get('/summaries',
-                 response_model=DealSummaryResponse,
-                 operation_id='getDealSummaries'
-                 )
+@deal_router.get(
+    '/summaries',
+    response_model=DealSummaryResponse,
+    operation_id='getDealSummaries',
+    dependencies=[Depends(authorized_user)]
+)
 async def get_summary(
        session: Annotated[AsyncSession, Depends(get_session)]
 ):
@@ -70,7 +83,8 @@ async def get_summary(
@deal_router.post(
    '/summaries/reorder',
    response_model=DealSummaryResponse,
-    operation_id='reorderDealSummaries'
+    operation_id='reorderDealSummaries',
+    dependencies=[Depends(authorized_user)]
 )
 async def reorder(
        session: Annotated[AsyncSession, Depends(get_session)],
@@ -83,7 +97,8 @@ async def reorder(
@deal_router.get(
    '/get-all',
    response_model=DealGetAllResponse,
-    operation_id='getAllDeals'
+    operation_id='getAllDeals',
+    dependencies=[Depends(authorized_user)]
 )
 async def get_all(
        session: Annotated[AsyncSession, Depends(get_session)]
@@ -95,19 +110,22 @@ async def get_all(
@deal_router.get(
    '/get/{deal_id}',
    response_model=DealSchema,
-    operation_id='getDealById'
+    operation_id='getDealById',
+    dependencies=[Depends(guest_user)]
 )
 async def get_deal_by_id(
        deal_id: int,
+        user: CurrentUserDependency,
        session: Annotated[AsyncSession, Depends(get_session)]
 ):
-    return await DealService(session).get_by_id(deal_id)
+    return await DealService(session).get_by_id(user, deal_id)


@deal_router.post(
    '/update-general-info',
    response_model=DealUpdateGeneralInfoResponse,
-    operation_id='updateDealGeneralInfo'
+    operation_id='updateDealGeneralInfo',
+    dependencies=[Depends(authorized_user)]
 )
 async def update_general_info(
        request: DealUpdateGeneralInfoRequest,
@@ -115,16 +133,34 @@ async def update_general_info(
 ):
    return await DealService(session).update_general_info(request)

+
@deal_router.post(
    '/add-kit',
    response_model=DealAddKitResponse,
    operation_id='add_kit_to_deal'
+
 )
 async def add_kit_to_deal(
-        session:SessionDependency,
-        request:DealAddKitRequest
+        session: SessionDependency,
+        request: DealAddKitRequest
 ):
    return await DealService(session).add_kit_to_deal(request)
+
+
+@deal_router.post(
+    '/create-guest-url',
+    response_model=DealCreateGuestUrlResponse,
+    operation_id='create_deal_guest_url',
+    dependencies=[Depends(authorized_user)]
+)
+async def create_guest_url(
+        session: SessionDependency,
+        request: DealCreateGuestUrlRequest,
+        user: CurrentUserDependency
+):
+    return DealService(session).create_guest_url(user, request)
+
+
 # endregion

 # region Deal services
@@ -132,11 +168,12 @@ async def add_kit_to_deal(
@deal_router.post(
    '/services/add/multiple',
    response_model=DealAddServicesResponse,
-    operation_id='addMultipleDealServices'
+    operation_id='addMultipleDealServices',
+    dependencies=[Depends(guest_user)]
 )
 async def services_add(
        request: DealAddServicesRequest,
-        session: Annotated[AsyncSession, Depends(get_session)]
+        session: Annotated[AsyncSession, Depends(get_session)],
 ):
    return await DealService(session).add_services(request)

@@ -144,73 +181,86 @@ async def services_add(
@deal_router.post(
    '/services/add',
    response_model=DealAddServiceResponse,
-    operation_id='addDealService'
+    operation_id='addDealService',
+    dependencies=[Depends(guest_user)]
 )
 async def services_add(
        request: DealAddServiceRequest,
-        session: Annotated[AsyncSession, Depends(get_session)]
+        session: Annotated[AsyncSession, Depends(get_session)],
+        user: CurrentUserDependency
 ):
-    return await DealService(session).add_service(request)
+    return await DealService(session).add_service(user, request)


@deal_router.post(
    '/services/update-quantity',
    response_model=DealUpdateServiceQuantityResponse,
-    operation_id='updateDealServiceQuantity'
+    operation_id='updateDealServiceQuantity',
+    dependencies=[Depends(guest_user)]
 )
 async def services_update_quantity(
        request: DealUpdateServiceQuantityRequest,
-        session: Annotated[AsyncSession, Depends(get_session)]
+        session: Annotated[AsyncSession, Depends(get_session)],
+        user: CurrentUserDependency
+
 ):
-    return await DealService(session).update_service_quantity(request)
+    return await DealService(session).update_service_quantity(user, request)


@deal_router.post(
    '/services/update',
    response_model=DealUpdateServiceResponse,
-    operation_id='updateDealService'
+    operation_id='updateDealService',
+    dependencies=[Depends(guest_user)]
 )
 async def services_update(
        request: DealUpdateServiceRequest,
-        session: Annotated[AsyncSession, Depends(get_session)]
+        session: Annotated[AsyncSession, Depends(get_session)],
+        user: CurrentUserDependency
 ):
-    return await DealService(session).update_service(request)
+    return await DealService(session).update_service(user, request)


@deal_router.post(
    '/services/delete',
    response_model=DealDeleteServiceResponse,
-    operation_id='deleteDealService'
+    operation_id='deleteDealService',
+    dependencies=[Depends(guest_user)]
 )
 async def services_delete(
        request: DealDeleteServiceRequest,
-        session: Annotated[AsyncSession, Depends(get_session)]
+        session: Annotated[AsyncSession, Depends(get_session)],
+        user: CurrentUserDependency
 ):
-    return await DealService(session).delete_service(request)
+    return await DealService(session).delete_service(user, request)


@deal_router.post(
    '/services/delete/multiple',
    response_model=DealDeleteServicesResponse,
-    operation_id='deleteMultipleDealServices'
+    operation_id='deleteMultipleDealServices',
+    dependencies=[Depends(guest_user)]
 )
 async def services_delete(
        request: DealDeleteServicesRequest,
-        session: Annotated[AsyncSession, Depends(get_session)]
+        session: Annotated[AsyncSession, Depends(get_session)],
+        user: CurrentUserDependency
 ):
-    return await DealService(session).delete_services(request)
+    return await DealService(session).delete_services(user, request)


@deal_router.post(
    '/services/copy',
    response_model=DealServicesCopyResponse,
-    operation_id='copy_product_services'
+    operation_id='copy_product_services',
+    dependencies=[Depends(guest_user)]
 )
 async def services_copy(
        session: SessionDependency,
-        request: DealServicesCopyRequest
+        request: DealServicesCopyRequest,
+        user: CurrentUserDependency
 ):
-    return await DealService(session).copy_services(request)
+    return await DealService(session).copy_services(user, request)


 # endregion
@@ -219,63 +269,84 @@ async def services_copy(
@deal_router.post(
    '/products/update-quantity',
    response_model=DealUpdateProductQuantityResponse,
-    operation_id='updateDealProductQuantity')
+    operation_id='updateDealProductQuantity',
+    dependencies=[Depends(guest_user)]
+)
 async def products_update(
        request: DealUpdateProductQuantityRequest,
-        session: Annotated[AsyncSession, Depends(get_session)]):
-    return await DealService(session).update_product_quantity(request)
+        session: Annotated[AsyncSession, Depends(get_session)],
+        user: CurrentUserDependency
+):
+    return await DealService(session).update_product_quantity(user, request)


@deal_router.post(
    '/products/add',
    response_model=DealAddProductResponse,
-    operation_id='addDealProduct')
+    operation_id='addDealProduct',
+    dependencies=[Depends(guest_user)]
+)
 async def products_add(
        request: DealAddProductRequest,
-        session: Annotated[AsyncSession, Depends(get_session)]):
-    return await DealService(session).add_product(request)
+        session: Annotated[AsyncSession, Depends(get_session)],
+        user: CurrentUserDependency
+):
+    return await DealService(session).add_product(user, request)


@deal_router.post(
    '/products/delete',
    response_model=DealDeleteProductResponse,
-    operation_id='deleteDealProduct')
+    operation_id='deleteDealProduct',
+    dependencies=[Depends(guest_user)]
+)
 async def products_delete(
        request: DealDeleteProductRequest,
-        session: Annotated[AsyncSession, Depends(get_session)]):
-    return await DealService(session).delete_product(request)
+        session: Annotated[AsyncSession, Depends(get_session)],
+        user: CurrentUserDependency
+
+):
+    return await DealService(session).delete_product(user, request)


@deal_router.post(
    '/products/delete/multiple',
    response_model=DealDeleteProductsResponse,
-    operation_id='deleteMultipleDealProducts')
+    operation_id='deleteMultipleDealProducts',
+    dependencies=[Depends(guest_user)]
+)
 async def products_delete(
        request: DealDeleteProductsRequest,
-        session: Annotated[AsyncSession, Depends(get_session)]):
-    return await DealService(session).delete_products(request)
+        session: Annotated[AsyncSession, Depends(get_session)],
+        user: CurrentUserDependency
+):
+    return await DealService(session).delete_products(user, request)


@deal_router.post(
    '/product/update',
    response_model=DealUpdateProductResponse,
-    operation_id='updateDealProduct'
+    operation_id='updateDealProduct',
+    dependencies=[Depends(guest_user)]
 )
 async def products_update(
        request: DealUpdateProductRequest,
-        session: Annotated[AsyncSession, Depends(get_session)]
+        session: Annotated[AsyncSession, Depends(get_session)],
+        user: CurrentUserDependency
 ):
-    return await DealService(session).update_product(request)
+    return await DealService(session).update_product(user, request)


@deal_router.post(
    '/product/add-kit',
    response_model=DealProductAddKitResponse,
-    operation_id='add_kit_to_deal_product'
+    operation_id='add_kit_to_deal_product',
+    dependencies=[Depends(guest_user)]
 )
 async def add_kit_to_deal_product(
        session: SessionDependency,
-        request: DealProductAddKitRequest
+        request: DealProductAddKitRequest,
+        user: CurrentUserDependency
 ):
-    return await DealService(session).add_kit_to_deal_product(request)
+    return await DealService(session).add_kit_to_deal_product(user, request)
 # endregion
--- a/routers/marketplace.py
+++ b/routers/marketplace.py
@@ -1,12 +1,14 @@
-from fastapi import APIRouter
+from fastapi import APIRouter, Depends

 from backend.dependecies import SessionDependency
 from schemas.marketplace import *
+from services.auth import authorized_user
 from services.marketplace import MarketplaceService

 marketplace_router = APIRouter(
    prefix="/marketplace",
-    tags=["marketplace"]
+    tags=["marketplace"],
+    dependencies=[Depends(authorized_user)]
 )


--- a/routers/payroll.py
+++ b/routers/payroll.py
@@ -1,4 +1,4 @@
-from fastapi import APIRouter
+from fastapi import APIRouter, Depends

 from backend.dependecies import SessionDependency, PaginationDependency, CurrentUserDependency
 from schemas.finances import CreatePayRateRequest, UpdatePayRateRequest, DeletePayRateRequest, \
@@ -6,11 +6,13 @@ from schemas.finances import CreatePayRateRequest, UpdatePayRateRequest, DeleteP
    DeletePayRateResponse
 from schemas.payment_record import GetPaymentRecordsResponse, CreatePaymentRecordResponse, CreatePaymentRecordRequest, \
    DeletePaymentRecordResponse, DeletePaymentRecordRequest
+from services.auth import authorized_user
 from services.payroll import PayrollService

 payroll_router = APIRouter(
    prefix="/payroll",
-    tags=["payroll"]
+    tags=["payroll"],
+    dependencies=[Depends(authorized_user)]
 )


--- a/routers/position.py
+++ b/routers/position.py
@@ -1,12 +1,14 @@
-from fastapi import APIRouter
+from fastapi import APIRouter, Depends

 from backend.dependecies import SessionDependency
 from schemas.position import *
+from services.auth import authorized_user
 from services.position import PositionService

 position_router = APIRouter(
    prefix="/position",
-    tags=["position"]
+    tags=["position"],
+    dependencies=[Depends(authorized_user)]
 )


--- a/routers/product.py
+++ b/routers/product.py
@@ -6,18 +6,20 @@ from fastapi import APIRouter, Depends, UploadFile
 from sqlalchemy.ext.asyncio import AsyncSession

 import utils.dependecies
+from backend.dependecies import CurrentUserDependency
 from backend.session import get_session
 from schemas.barcode import GetProductBarcodeResponse, GetProductBarcodeRequest, GetProductBarcodePdfResponse, \
    GetProductBarcodePdfRequest
 from schemas.base import PaginationSchema
 from schemas.product import *
+from services.auth import guest_user
 from services.barcode import BarcodeService
 from services.product import ProductService

 product_router = APIRouter(
    prefix="/product",
    tags=["product"],
-    # dependencies=[Depends(get_current_user)]
+    dependencies=[Depends(guest_user)]
 )


@@ -28,7 +30,7 @@ product_router = APIRouter(
 )
 async def create_product(
        request: ProductCreateRequest,
-        session: Annotated[AsyncSession, Depends(get_session)]
+        session: Annotated[AsyncSession, Depends(get_session)],
 ):
    return await ProductService(session).create(request)

@@ -146,9 +148,7 @@ async def get_product_barcode_pdf(
        filename=filename,
        mime_type='application/pdf'
    )
-    # return StreamingResponse(content=pdf_buffer,
-    #                          media_type='application/pdf',
-    #                          headers={"Content-Disposition": f"inline; filename={filename}"})
+


@product_router.post(
--- a/routers/role.py
+++ b/routers/role.py
@@ -1,12 +1,14 @@
-from fastapi import APIRouter
+from fastapi import APIRouter, Depends

 from backend.dependecies import SessionDependency
 from schemas.role import *
+from services.auth import authorized_user
 from services.role import RoleService

 role_router = APIRouter(
    prefix='/role',
-    tags=['role']
+    tags=['role'],
+    dependencies=[Depends(authorized_user)]
 )


--- a/routers/service.py
+++ b/routers/service.py
@@ -6,22 +6,23 @@ from sqlalchemy.ext.asyncio import AsyncSession
 import enums.service
 from backend.dependecies import SessionDependency
 from backend.session import get_session
-from schemas.base import BaseEnumSchema, BaseEnumListSchema
+from schemas.base import BaseEnumListSchema
 from schemas.service import *
-from services.auth import get_current_user
+from services.auth import guest_user, authorized_user
 from services.service import ServiceService

 service_router = APIRouter(
    prefix="/service",
    tags=['service'],
-    dependencies=[Depends(get_current_user)]
 )


@service_router.get(
    '/get-all',
    response_model=ServiceGetAllResponse,
-    operation_id="get_all_services"
+    operation_id="get_all_services",
+    dependencies=[Depends(guest_user)]
+
 )
 async def get_all(
        session: Annotated[AsyncSession, Depends(get_session)]
@@ -32,7 +33,8 @@ async def get_all(
@service_router.post(
    '/create',
    response_model=ServiceCreateResponse,
-    operation_id="create_service"
+    operation_id="create_service",
+    dependencies=[Depends(authorized_user)]
 )
 async def create(
        session: Annotated[AsyncSession, Depends(get_session)],
@@ -44,7 +46,8 @@ async def create(
@service_router.post(
    '/update',
    response_model=ServiceUpdateResponse,
-    operation_id="update_service"
+    operation_id="update_service",
+    dependencies=[Depends(authorized_user)]
 )
 async def update(
        session: Annotated[AsyncSession, Depends(get_session)],
@@ -56,7 +59,8 @@ async def update(
@service_router.post(
    '/delete',
    response_model=ServiceDeleteResponse,
-    operation_id="delete_service"
+    operation_id="delete_service",
+    dependencies=[Depends(authorized_user)]
 )
 async def delete(
        session: Annotated[AsyncSession, Depends(get_session)],
@@ -68,7 +72,8 @@ async def delete(
@service_router.get(
    '/categories/get-all',
    response_model=ServiceGetAllCategoriesResponse,
-    operation_id="get_all_service_categories"
+    operation_id="get_all_service_categories",
+    dependencies=[Depends(guest_user)]
 )
 async def get_all_categories(
        session: Annotated[AsyncSession, Depends(get_session)]
@@ -79,7 +84,8 @@ async def get_all_categories(
@service_router.post(
    '/categories/create',
    response_model=ServiceCreateCategoryResponse,
-    operation_id="create_service_category"
+    operation_id="create_service_category",
+    dependencies=[Depends(authorized_user)]
 )
 async def create_category(
        session: Annotated[AsyncSession, Depends(get_session)],
@@ -91,7 +97,8 @@ async def create_category(
@service_router.get(
    '/types/get-all',
    response_model=BaseEnumListSchema,
-    operation_id="get_all_service_types"
+    operation_id="get_all_service_types",
+    dependencies=[Depends(guest_user)]
 )
 async def get_all_service_types(
 ):
@@ -104,7 +111,8 @@ async def get_all_service_types(
@service_router.get(
    '/kits/get-all',
    response_model=GetAllServicesKitsResponse,
-    operation_id='get_all_services_kits'
+    operation_id='get_all_services_kits',
+    dependencies=[Depends(guest_user)]
 )
 async def get_all_services_kits(
        session: SessionDependency
@@ -115,7 +123,8 @@ async def get_all_services_kits(
@service_router.post(
    '/kits/create',
    response_model=CreateServicesKitResponse,
-    operation_id='create_services_kit'
+    operation_id='create_services_kit',
+    dependencies=[Depends(authorized_user)]
 )
 async def create_services_kit(
        session: SessionDependency,
@@ -127,7 +136,8 @@ async def create_services_kit(
@service_router.post(
    '/kits/update',
    response_model=UpdateServicesKitResponse,
-    operation_id='update_services_kit'
+    operation_id='update_services_kit',
+    dependencies=[Depends(authorized_user)]
 )
 async def update_services_kit(
        session: SessionDependency,
--- a/routers/shipping_warehouse.py
+++ b/routers/shipping_warehouse.py
@@ -5,13 +5,13 @@ from sqlalchemy.ext.asyncio import AsyncSession

 from backend.session import get_session
 from schemas.shipping_warehouse import GetAllShippingWarehousesResponse
-from services.auth import get_current_user
+from services.auth import authorized_user
 from services.shipping_warehouse import ShippingWarehouseService

 shipping_warehouse_router = APIRouter(
    prefix="/shipping-warehouse",
    tags=["shipping-warehouse"],
-    dependencies=[Depends(get_current_user)]
+    dependencies=[Depends(authorized_user)]
 )


--- a/routers/time_tracking.py
+++ b/routers/time_tracking.py
@@ -1,12 +1,14 @@
-from fastapi import APIRouter
+from fastapi import APIRouter, Depends

 from backend.dependecies import SessionDependency, CurrentUserDependency
 from schemas.time_tracking import *
+from services.auth import authorized_user
 from services.time_tracking import TimeTrackingService

 time_tracking_router = APIRouter(
    prefix="/time-tracking",
-    tags=["time-tracking"]
+    tags=["time-tracking"],
+    dependencies=[Depends(authorized_user)]
 )


--- a/routers/user.py
+++ b/routers/user.py
@@ -1,12 +1,14 @@
-from fastapi import APIRouter
+from fastapi import APIRouter, Depends

 from backend.dependecies import SessionDependency
 from schemas.user import *
+from services.auth import authorized_user
 from services.user import UserService

 user_router = APIRouter(
    prefix="/user",
-    tags=["user"]
+    tags=["user"],
+    dependencies=[Depends(authorized_user)]
 )