update

common/auth.py

@@ -0,0 +1,48 @@
+from fastapi.security import OAuth2PasswordBearer
+from fastapi import HTTPException, Depends
+from datetime import datetime, timedelta, timezone
+from typing import Optional
+from pydantic import BaseModel
+import jwt
+import os
+
+# Секретный ключ для JWT
+SECRET_KEY = os.environ.get("JWT_SECRET", "ooooooh_thats_my_super_secret_key")
+ALGORITHM = "HS256"
+ACCESS_TOKEN_EXPIRE_MINUTES = 30
+
+# Захардкоженные пользователи
+USERS = [
+    {"username": "admin", "password": "admin123"},
+    {"username": "user", "password": "user123"},
+]
+
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/auth/login")
+
+class LoginRequest(BaseModel):
+    username: str
+    password: str
+    grant_type: str
+
+def create_access_token(data: dict, expires_delta: Optional[timedelta] = None):
+    to_encode = data.copy()
+    if expires_delta:
+        expire = datetime.now(timezone.utc) + expires_delta
+    else:
+        expire = datetime.now(timezone.utc) + timedelta(minutes=15)
+    to_encode.update({"exp": expire})
+    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
+    return encoded_jwt
+
+async def get_current_user(token: str = Depends(oauth2_scheme)):
+    try:
+        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
+        username: str = payload.get("sub")
+        if username is None:
+            raise HTTPException(status_code=401, detail="Invalid token")
+        user = next((u for u in USERS if u["username"] == username), None)
+        if user is None:
+            raise HTTPException(status_code=401, detail="User not found")
+        return user
+    except jwt.PyJWTError:
+        raise HTTPException(status_code=401, detail="Invalid token")

main.py

@@ -20,6 +20,7 @@ from routes.entity import router as entity_router
 from routes.llm import router as llm_router
 from routes.llm_config import router as llm_config_router
 from routes.llm_prompt import router as llm_prompt_router
+from routes.auth import router as auth_router
 
 # from main_before import config
 
@@ -73,12 +74,13 @@ app.include_router(document_router)
 app.include_router(llm_config_router)
 app.include_router(llm_prompt_router)
 app.include_router(entity_router)
+app.include_router(auth_router)
 
 if __name__ == "__main__":
     uvicorn.run(
         "main:app",
         host="localhost",
-        port=8885,
+        port=7860,
         reload=False,
         workers=1
     )

requirements.txt

@@ -23,4 +23,4 @@ elasticsearch==8.17.2
 uvicorn==0.34.0
 python-multipart==0.0.20
 python-dotenv==1.1.0
-
+pyjwt==2.10.1

routes/auth.py

@@ -0,0 +1,32 @@
+from typing import Optional
+from fastapi import APIRouter, Form, HTTPException
+from datetime import timedelta
+import common.auth as auth
+
+router = APIRouter(prefix="/auth", tags=["Auth"])
+
+@router.post("/login")
+async def login(username: Optional[str] = Form(default=None),
+                password: Optional[str] = Form(default=None),
+                request: Optional[auth.LoginRequest] = None):
+    
+    # Если данные пришли через Form Data
+    if username is not None and password is not None:
+        final_username = username
+        final_password = password
+    # Если данные пришли через JSON
+    elif request is not None:
+        final_username = request.username
+        final_password = request.password
+    else:
+        raise HTTPException(status_code=400, detail="Не указаны логин и пароль")
+
+    user = next((u for u in auth.USERS if u["username"] == final_username), None)
+    if not user or user["password"] != final_password:
+        raise HTTPException(status_code=401, detail="Неверный логин или пароль")
+    
+    access_token_expires = timedelta(minutes=auth.ACCESS_TOKEN_EXPIRE_MINUTES)
+    access_token = auth.create_access_token(
+        data={"sub": user["username"]}, expires_delta=access_token_expires
+    )
+    return {"access_token": access_token, "token_type": "bearer"}

routes/dataset.py

@@ -4,16 +4,19 @@ from typing import Annotated
 from fastapi import (APIRouter, BackgroundTasks, Depends, HTTPException,
                      Response, UploadFile)
 
+from common import auth
 import common.dependencies as DI
 from components.services.dataset import DatasetService
 from schemas.dataset import (Dataset, DatasetExpanded, DatasetProcessing,
                              SortQuery, SortQueryList)
 
-router = APIRouter(prefix='/datasets')
+router = APIRouter(prefix='/datasets', tags=['Datasets'])
 logger = logging.getLogger(__name__)
     
 @router.get('/')
-async def get_datasets(dataset_service: Annotated[DatasetService, Depends(DI.get_dataset_service)]) -> list[Dataset]:
+async def get_datasets(dataset_service: Annotated[DatasetService, Depends(DI.get_dataset_service)],
+                                 current_user: Annotated[any, Depends(auth.get_current_user)]
+) -> list[Dataset]:
     logger.info("Handling GET request to /datasets")
     try:
         result = dataset_service.get_datasets()
@@ -25,7 +28,9 @@ async def get_datasets(dataset_service: Annotated[DatasetService, Depends(DI.get
 
 
 @router.get('/processing')
-async def get_processing(dataset_service: Annotated[DatasetService, Depends(DI.get_dataset_service)]) -> DatasetProcessing:
+async def get_processing(dataset_service: Annotated[DatasetService, Depends(DI.get_dataset_service)],
+                                 current_user: Annotated[any, Depends(auth.get_current_user)]
+) -> DatasetProcessing:
     logger.info("Handling GET request to /datasets/processing")
     try:
         result = dataset_service.get_processing()
@@ -54,7 +59,8 @@ def try_create_default_dataset(dataset_service: DatasetService):
             )
             
 @router.get('/try_init_default_dataset')
-async def try_init_default_dataset(dataset_service: Annotated[DatasetService, Depends(DI.get_dataset_service)]):
+async def try_init_default_dataset(dataset_service: Annotated[DatasetService, Depends(DI.get_dataset_service)],
+                                 current_user: Annotated[any, Depends(auth.get_current_user)]):
     logger.info(f"Handling GET request try_init_default_dataset")
     try_create_default_dataset(dataset_service)
     try:
@@ -68,6 +74,7 @@ async def try_init_default_dataset(dataset_service: Annotated[DatasetService, De
 async def get_dataset(
     dataset_id: int,
     dataset_service: Annotated[DatasetService, Depends(DI.get_dataset_service)],
+    current_user: Annotated[any, Depends(auth.get_current_user)],
     page: int = 1,
     page_size: int = 20,
     search: str = '',
@@ -103,7 +110,9 @@ async def get_dataset(
 
 
 @router.post('/{parent_id}/edit')
-async def create_draft(parent_id: int, dataset_service: Annotated[DatasetService, Depends(DI.get_dataset_service)]) -> Dataset:
+async def create_draft(parent_id: int, dataset_service: Annotated[DatasetService, Depends(DI.get_dataset_service)],
+                        current_user: Annotated[any, Depends(auth.get_current_user)]
+) -> Dataset:
     logger.info(f"Handling POST request to /datasets/{parent_id}/edit")
     try:
         result = dataset_service.create_draft(parent_id)
@@ -115,7 +124,10 @@ async def create_draft(parent_id: int, dataset_service: Annotated[DatasetService
 
 
 @router.post('/{dataset_id}')
-async def make_active(dataset_id: int, dataset_service: Annotated[DatasetService, Depends(DI.get_dataset_service)], background_tasks: BackgroundTasks) -> DatasetExpanded:
+async def make_active(dataset_id: int, dataset_service: Annotated[DatasetService, Depends(DI.get_dataset_service)],
+                    background_tasks: BackgroundTasks,
+                    current_user: Annotated[any, Depends(auth.get_current_user)]
+) -> DatasetExpanded:
     logger.info(f"Handling POST request to /datasets/{dataset_id}/activate")
     try:
         result = dataset_service.activate_dataset(dataset_id, background_tasks)
@@ -127,7 +139,10 @@ async def make_active(dataset_id: int, dataset_service: Annotated[DatasetService
 
 
 @router.delete('/{dataset_id}')
-async def delete_dataset(dataset_id: int, dataset_service:  Annotated[DatasetService, Depends(DI.get_dataset_service)]) -> None:
+async def delete_dataset(dataset_id: int, 
+                        dataset_service:  Annotated[DatasetService, Depends(DI.get_dataset_service)],
+                        current_user: Annotated[any, Depends(auth.get_current_user)]
+) -> None:
     logger.info(f"Handling DELETE request to /datasets/{dataset_id}")
     try:
         dataset_service.delete_dataset(dataset_id)
@@ -139,7 +154,10 @@ async def delete_dataset(dataset_id: int, dataset_service:  Annotated[DatasetSer
 
 
 @router.post('/')
-async def upload_zip(file: UploadFile, dataset_service:  Annotated[DatasetService, Depends(DI.get_dataset_service)]) -> DatasetExpanded:
+async def upload_zip(file: UploadFile, 
+                    dataset_service: Annotated[DatasetService, Depends(DI.get_dataset_service)],
+                    current_user: Annotated[any, Depends(auth.get_current_user)]
+) -> DatasetExpanded:
     logger.info(f"Handling POST request to /datasets/upload with file {file.filename}")
     try:
         result = dataset_service.upload_zip(file)

routes/document.py

@@ -1,19 +1,24 @@
 import logging
+from typing import Annotated
 
 from fastapi import APIRouter, Response, UploadFile, Depends
 from fastapi.responses import FileResponse
 
+from common import auth
 from schemas.document import Document
 from components.services.document import DocumentService
 import common.dependencies as DI
 
-router = APIRouter(prefix='/datasets/{dataset_id}/documents')
+router = APIRouter(prefix='/datasets/{dataset_id}/documents', tags=['Documents'])
 logger = logging.getLogger(__name__)
 
 
 @router.get('/{document_id}')
-async def get_document(document_id: int, dataset_id: int | None = None, 
-                       document_service: DocumentService = Depends(DI.get_document_service)) -> FileResponse:
+async def get_document(document_id: int, 
+                        document_service: Annotated[DocumentService, Depends(DI.get_document_service)],
+                        current_user: Annotated[any, Depends(auth.get_current_user)], 
+                        dataset_id: int | None = None
+) -> FileResponse:
     logger.info(f"Handling GET request to /documents/{document_id}")
     try:
         result = document_service.get_document(document_id, dataset_id)
@@ -30,13 +35,17 @@ async def get_document(document_id: int, dataset_id: int | None = None,
 
 
 @router.delete('/{document_id}')
-async def delete_document(dataset_id: int, document_id: int, 
-                       document_service: DocumentService = Depends(DI.get_document_service)) -> None:
+async def delete_document(dataset_id: int, document_id: int,
+                        document_service: Annotated[DocumentService, Depends(DI.get_document_service)],
+                        current_user: Annotated[any, Depends(auth.get_current_user)]
+) -> None:
     document_service.delete_document(dataset_id, document_id)
     return Response(status_code=200)
 
 
 @router.post('/')
 async def add_document(dataset_id: int, file: UploadFile, 
-                       document_service: DocumentService = Depends(DI.get_document_service)) -> Document:
+                        document_service: Annotated[DocumentService, Depends(DI.get_document_service)],
+                        current_user: Annotated[any, Depends(auth.get_current_user)]
+) -> Document:
     return document_service.add_document(dataset_id, file)

routes/entity.py

@@ -4,6 +4,7 @@ import numpy as np
 from fastapi import APIRouter, Depends, HTTPException
 from sqlalchemy.orm import Session
 
+from common import auth
 import common.dependencies as DI
 from components.dbo.chunk_repository import ChunkRepository
 from components.services.entity import EntityService
@@ -13,13 +14,14 @@ from schemas.entity import (EntityNeighborsRequest, EntityNeighborsResponse,
                             EntitySearchWithTextResponse, EntityTextRequest,
                             EntityTextResponse)
 
-router = APIRouter(prefix="/entity", tags=["entity"])
+router = APIRouter(prefix="/entity", tags=["Entity"])
 
 
 @router.post("/search", response_model=EntitySearchResponse)
 async def search_entities(
     request: EntitySearchRequest,
-    entity_service: EntityService = Depends(DI.get_entity_service),
+    entity_service: Annotated[EntityService, Depends(DI.get_entity_service)],
+    current_user: Annotated[any, Depends(auth.get_current_user)]
 ) -> EntitySearchResponse:
     """
     Поиск похожих сущностей по векторному сходству (только ID).
@@ -69,7 +71,8 @@ async def search_entities(
 @router.post("/search/with_text", response_model=EntitySearchWithTextResponse)
 async def search_entities_with_text(
     request: EntitySearchWithTextRequest,
-    entity_service: EntityService = Depends(DI.get_entity_service),
+    entity_service: Annotated[EntityService, Depends(DI.get_entity_service)],
+    current_user: Annotated[any, Depends(auth.get_current_user)]
 ) -> EntitySearchWithTextResponse:
     """
     Поиск похожих сущностей по векторному сходству с возвратом текстов.
@@ -129,7 +132,8 @@ async def search_entities_with_text(
 @router.post("/text", response_model=EntityTextResponse)
 async def build_entity_text(
     request: EntityTextRequest,
-    entity_service: EntityService = Depends(DI.get_entity_service),
+    entity_service: Annotated[EntityService, Depends(DI.get_entity_service)],
+    current_user: Annotated[any, Depends(auth.get_current_user)]
 ) -> EntityTextResponse:
     """
     Сборка текста из сущностей.
@@ -170,7 +174,8 @@ async def build_entity_text(
 @router.post("/neighbors", response_model=EntityNeighborsResponse)
 async def get_neighboring_chunks(
     request: EntityNeighborsRequest,
-    entity_service: EntityService = Depends(DI.get_entity_service),
+    entity_service: Annotated[EntityService, Depends(DI.get_entity_service)],
+    current_user: Annotated[any, Depends(auth.get_current_user)]
 ) -> EntityNeighborsResponse:
     """
     Получение соседних чанков для заданных сущностей.
@@ -213,6 +218,7 @@ async def get_neighboring_chunks(
 async def get_entity_info(
     dataset_id: int,
     db: Annotated[Session, Depends(DI.get_db)],
+    current_user: Annotated[any, Depends(auth.get_current_user)]
 ) -> dict:
     """
     Получить информацию о сущностях в датасете.

routes/llm.py

@@ -15,7 +15,7 @@ from components.llm.utils import append_llm_response_to_history
 from components.services.llm_config import LLMConfigService
 from components.services.llm_prompt import LlmPromptService
 
-router = APIRouter(prefix='/llm')
+router = APIRouter(prefix='/llm', tags=['LLM chat'])
 logger = logging.getLogger(__name__)
 
 conf = DI.get_config()

routes/llm_config.py

@@ -1,20 +1,24 @@
 import logging
+from typing import Annotated
 
 from fastapi import APIRouter, Response, UploadFile, Depends
 from fastapi.responses import FileResponse
 
+import common.auth as auth
 from schemas.llm_config import LLMConfig as LLMConfigScheme, LLMConfigCreateScheme
 from components.dbo.models.llm_config import LLMConfig as LLMConfigSQL
 from components.services.llm_config import LLMConfigService
 import common.dependencies as DI
 from schemas.llm_config import LLMConfig
 
-router = APIRouter(prefix='/llm_config')
+router = APIRouter(prefix='/llm_config', tags=['LLM parameters'])
 logger = logging.getLogger(__name__)
 
 
 @router.get('/')
-async def get_llm_config_list(llm_config_service: LLMConfigService = Depends(DI.get_llm_config_service)) -> list[LLMConfig]:
+async def get_llm_config_list(llm_config_service: Annotated[LLMConfigService, Depends(DI.get_llm_config_service)],
+                            current_user: Annotated[any, Depends(auth.get_current_user)]
+                            ) -> list[LLMConfig]:
     logger.info("Handling GET request to /llm_config/{config_id}}")
     try:
         config = llm_config_service.get_list()
@@ -24,9 +28,9 @@ async def get_llm_config_list(llm_config_service: LLMConfigService = Depends(DI.
         raise e
     
 @router.get('/default')
-async def get_llm_default_config(llm_config_service: 
-                        LLMConfigService = Depends(DI.get_llm_config_service)
-                        ) -> LLMConfig:
+async def get_llm_default_config(llm_config_service: Annotated[LLMConfigService, Depends(DI.get_llm_config_service)],
+                                 current_user: Annotated[any, Depends(auth.get_current_user)]
+                            ) -> LLMConfig:
     logger.info("Handling GET request to /llm_config/default/")
     try:
         config = llm_config_service.get_default()
@@ -41,7 +45,8 @@ async def get_llm_default_config(llm_config_service:
 
 @router.get('/{config_id}')
 async def get_llm_config(config_id: int, 
-                        llm_config_service: LLMConfigService = Depends(DI.get_llm_config_service)
+                        llm_config_service: Annotated[LLMConfigService, Depends(DI.get_llm_config_service)],
+                        current_user: Annotated[any, Depends(auth.get_current_user)]
                         ) -> LLMConfig:
     logger.info("Handling GET request to /llm_config/{config_id}}")
     try:
@@ -57,7 +62,8 @@ async def get_llm_config(config_id: int,
 
 @router.put('/default/{config_id}')
 async def set_as_default_config(config_id: int, 
-                        llm_config_service: LLMConfigService = Depends(DI.get_llm_config_service)):
+                        llm_config_service: Annotated[LLMConfigService, Depends(DI.get_llm_config_service)],
+                        current_user: Annotated[any, Depends(auth.get_current_user)]):
     logger.info("Handling PUT request to /llm_config/default/{config_id}")
     try:
         llm_config_service.set_as_default(config_id)
@@ -72,7 +78,8 @@ async def set_as_default_config(config_id: int,
 
 @router.delete('/{config_id}')
 async def delete_config(config_id: int, 
-                        llm_config_service: LLMConfigService = Depends(DI.get_llm_config_service)):
+                        llm_config_service: Annotated[LLMConfigService, Depends(DI.get_llm_config_service)],
+                        current_user: Annotated[any, Depends(auth.get_current_user)]):
     logger.info("Handling DELETE request to /llm_config/{config_id}")
     try:
         llm_config_service.delete(config_id)
@@ -87,7 +94,8 @@ async def delete_config(config_id: int,
 
 @router.post('/')
 async def create_config(data: LLMConfigCreateScheme, 
-                       llm_config_service: LLMConfigService = Depends(DI.get_llm_config_service)):
+                        llm_config_service: Annotated[LLMConfigService, Depends(DI.get_llm_config_service)],
+                        current_user: Annotated[any, Depends(auth.get_current_user)]):
     logger.info("Handling POST request to /llm_config")
     try:
         new_config = llm_config_service.create(data)
@@ -102,7 +110,8 @@ async def create_config(data: LLMConfigCreateScheme,
 
 @router.put('/{config_id}')
 async def update_config(config_id: int, file: LLMConfigScheme, 
-                       llm_config_service: LLMConfigService = Depends(DI.get_llm_config_service)):
+                       llm_config_service: Annotated[LLMConfigService, Depends(DI.get_llm_config_service)],
+                       current_user: Annotated[any, Depends(auth.get_current_user)]):
     logger.info("Handling PUT request to /llm_config/{config_id}")
     try:
         updated_config = llm_config_service.update(config_id, file)

routes/llm_prompt.py

@@ -1,18 +1,22 @@
 import logging
+from typing import Annotated
 
 from fastapi import APIRouter, Response, UploadFile, Depends
 from fastapi.responses import FileResponse
 
+from common import auth
 from schemas.llm_prompt import LlmPromptCreateSchema, LlmPromptSchema
 from components.services.llm_prompt import LlmPromptService
 import common.dependencies as DI
 
-router = APIRouter(prefix='/llm_prompt')
+router = APIRouter(prefix='/llm_prompt', tags=['Prompt settings'])
 logger = logging.getLogger(__name__)
 
 
 @router.get('/')
-async def get_llm_prompt_list(llm_prompt_service: LlmPromptService = Depends(DI.get_llm_prompt_service)) -> list[LlmPromptSchema]:
+async def get_llm_prompt_list(llm_prompt_service: Annotated[LlmPromptService, Depends(DI.get_llm_prompt_service)],
+                                 current_user: Annotated[any, Depends(auth.get_current_user)]
+) -> list[LlmPromptSchema]:
     logger.info("Handling GET request to /llm_prompt/{prompt_id}}")
     try:
         prompt = llm_prompt_service.get_list()
@@ -22,9 +26,9 @@ async def get_llm_prompt_list(llm_prompt_service: LlmPromptService = Depends(DI.
         raise e
     
 @router.get('/default')
-async def get_llm_default_prompt(llm_prompt_service: 
-                        LlmPromptService = Depends(DI.get_llm_prompt_service)
-                        ) -> LlmPromptSchema:
+async def get_llm_default_prompt(llm_prompt_service: Annotated[LlmPromptService, Depends(DI.get_llm_prompt_service)],
+                                 current_user: Annotated[any, Depends(auth.get_current_user)]
+) -> LlmPromptSchema:
     logger.info("Handling GET request to /llm_prompt/default/")
     try:
         prompt = llm_prompt_service.get_default()
@@ -39,8 +43,9 @@ async def get_llm_default_prompt(llm_prompt_service:
 
 @router.get('/{prompt_id}')
 async def get_llm_prompt(prompt_id: int, 
-                        llm_prompt_service: LlmPromptService = Depends(DI.get_llm_prompt_service)
-                        ) -> LlmPromptSchema:
+                        llm_prompt_service: Annotated[LlmPromptService, Depends(DI.get_llm_prompt_service)],
+                        current_user: Annotated[any, Depends(auth.get_current_user)]
+) -> LlmPromptSchema:
     logger.info("Handling GET request to /llm_prompt/{prompt_id}}")
     try:
         prompt = llm_prompt_service.get_by_id(prompt_id)
@@ -55,7 +60,8 @@ async def get_llm_prompt(prompt_id: int,
 
 @router.put('/default/{prompt_id}')
 async def set_as_default_prompt(prompt_id: int, 
-                        llm_prompt_service: LlmPromptService = Depends(DI.get_llm_prompt_service)):
+                        llm_prompt_service: Annotated[LlmPromptService, Depends(DI.get_llm_prompt_service)],
+                        current_user: Annotated[any, Depends(auth.get_current_user)]):
     logger.info("Handling PUT request to /llm_prompt/default/{prompt_id}")
     try:
         llm_prompt_service.set_as_default(prompt_id)
@@ -70,7 +76,8 @@ async def set_as_default_prompt(prompt_id: int,
 
 @router.delete('/{prompt_id}')
 async def delete_prompt(prompt_id: int, 
-                        llm_prompt_service: LlmPromptService = Depends(DI.get_llm_prompt_service)):
+                        llm_prompt_service: Annotated[LlmPromptService, Depends(DI.get_llm_prompt_service)],
+                        current_user: Annotated[any, Depends(auth.get_current_user)]):
     logger.info("Handling DELETE request to /llm_prompt/{prompt_id}")
     try:
         llm_prompt_service.delete(prompt_id)
@@ -85,7 +92,8 @@ async def delete_prompt(prompt_id: int,
 
 @router.post('/')
 async def create_prompt(data: LlmPromptCreateSchema, 
-                       llm_prompt_service: LlmPromptService = Depends(DI.get_llm_prompt_service)):
+                       llm_prompt_service: Annotated[LlmPromptService, Depends(DI.get_llm_prompt_service)],
+                       current_user: Annotated[any, Depends(auth.get_current_user)]):
     logger.info("Handling POST request to /llm_prompt")
     try:
         new_prompt = llm_prompt_service.create(data)
@@ -100,7 +108,8 @@ async def create_prompt(data: LlmPromptCreateSchema,
 
 @router.put('/{prompt_id}')
 async def update_prompt(prompt_id: int, file: LlmPromptSchema, 
-                       llm_prompt_service: LlmPromptService = Depends(DI.get_llm_prompt_service)):
+                       llm_prompt_service: Annotated[LlmPromptService, Depends(DI.get_llm_prompt_service)],
+                       current_user: Annotated[any, Depends(auth.get_current_user)]):
     logger.info("Handling PUT request to /llm_prompt/{prompt_id}")
     try:
         updated_prompt = llm_prompt_service.update(prompt_id, file)

routes/log.py

@@ -6,6 +6,7 @@ from fastapi import APIRouter, Depends, Query
 from sqlalchemy.orm import aliased
 from starlette import status
 
+from common import auth
 from common.common import configure_logging
 from common.exceptions import LogNotFoundException
 from components.dbo.models.feedback import Feedback
@@ -14,7 +15,7 @@ from schemas.log import LogCreate
 import common.dependencies as DI
 from sqlalchemy.orm import sessionmaker
 
-router = APIRouter()
+router = APIRouter(tags=['Logs'])
 
 logger = logging.getLogger(__name__)
 configure_logging()
@@ -22,9 +23,10 @@ configure_logging()
 
 @router.get('/logs', status_code=status.HTTP_200_OK)
 async def get_all_logs(
-    db: Annotated[sessionmaker, Depends(DI.get_db)],
+    db: Annotated[sessionmaker, Depends(DI.get_db)], 
+    current_user: Annotated[any, Depends(auth.get_current_user)],
     date_start: Optional[datetime] = Query(None, alias="date_start"),
-    date_end: Optional[datetime] = Query(None, alias="date_end"), 
+    date_end: Optional[datetime] = Query(None, alias="date_end")
 ):
     logger.info(f'GET /logs: start')
     logger.info(f'GET /logs: start_date={date_start}, end_date={date_end}')
@@ -86,7 +88,8 @@ async def get_all_logs(
 
 
 @router.get('/log/{log_id}', status_code=status.HTTP_200_OK)
-async def get_log(db: Annotated[sessionmaker, Depends(DI.get_db)], log_id):
+async def get_log(db: Annotated[sessionmaker, Depends(DI.get_db)], 
+    current_user: Annotated[any, Depends(auth.get_current_user)], log_id):
     log = db.query(Log).filter(Log.id == log_id).first()
     if log is None:
         raise LogNotFoundException(log_id)