Тесты для бекенда

backend/app/routers/admin.py

@@ -1,4 +1,4 @@
-"""Admin routes"""
+"""Admin router"""
 from fastapi import APIRouter, Depends, HTTPException
 from sqlalchemy.orm import Session
 from typing import List
@@ -6,35 +6,24 @@ from ..database import get_db
 from ..crud import requests, statistics
 from ..schemas.request import Request
 from ..utils.auth import get_current_admin
-from ..utils.loggers import request_logger
 
 router = APIRouter()
 
 @router.get("/statistics")
-async def get_statistics(period: str = "week", db: Session = Depends(get_db)):
-    """Get request statistics"""
-    try:
-        return statistics.get_statistics(db, period)
-    except Exception as e:
-        request_logger.error(f"Error getting statistics: {e}")
-        raise HTTPException(status_code=500, detail="Ошибка при получении статистики")
-
-@router.get("/requests", response_model=List[Request])
-async def get_all_requests(
-    skip: int = 0,
-    limit: int = 100,
+def get_statistics(
     db: Session = Depends(get_db),
     _: dict = Depends(get_current_admin)
 ):
-    """
-    Получить список всех заявок (только для админа)
-    """
-    try:
-        requests_list = requests.get_requests(db, skip=skip, limit=limit)
-        return requests_list
-    except Exception as e:
-        print(f"Error getting requests: {str(e)}")
-        raise HTTPException(status_code=500, detail="Internal server error")
+    """Get system statistics"""
+    return statistics.get_request_statistics(db)
+
+@router.get("/requests", response_model=List[Request])
+def get_all_requests(
+    db: Session = Depends(get_db),
+    _: dict = Depends(get_current_admin)
+):
+    """Get all requests"""
+    return requests.get_requests(db)
 
 @router.get("/requests/{request_id}", response_model=Request)
 async def get_request_by_id(

backend/app/routers/employees.py

@@ -1,47 +1,33 @@
-"""Employees router"""
+"""Employee router"""
 from fastapi import APIRouter, Depends, HTTPException, status
 from sqlalchemy.orm import Session
 from typing import List
 from ..database import get_db
 from ..crud import employees
 from ..schemas.employee import Employee, EmployeeCreate, EmployeeUpdate
-from ..utils.auth import get_current_admin
-from ..utils.auth import get_password_hash
+from ..utils.auth import get_current_admin, get_password_hash
 
 router = APIRouter()
 
-@router.post("", response_model=Employee)
+@router.post("/", response_model=Employee)
 def create_employee(
     employee: EmployeeCreate,
     db: Session = Depends(get_db),
     _: dict = Depends(get_current_admin)
 ):
-    """
-    Создание нового сотрудника (только для админа)
-    """
-    # Хэшируем пароль
+    """Create new employee"""
     hashed_password = get_password_hash(employee.password)
-    
-    # Создаем сотрудника
-    db_employee = employees.create_employee(
-        db=db,
-        employee=employee,
-        hashed_password=hashed_password
-    )
-    return db_employee
+    return employees.create_employee(db, employee, hashed_password)
 
-@router.get("", response_model=List[Employee])
+@router.get("/", response_model=List[Employee])
 def get_employees(
     skip: int = 0,
     limit: int = 100,
     db: Session = Depends(get_db),
     _: dict = Depends(get_current_admin)
 ):
-    """
-    Получение списка всех сотрудников (только для админа)
-    """
-    employees_list = employees.get_employees(db, skip=skip, limit=limit)
-    return employees_list
+    """Get all employees"""
+    return employees.get_employees(db, skip=skip, limit=limit)
 
 @router.get("/{employee_id}", response_model=Employee)
 def get_employee(
@@ -49,10 +35,8 @@ def get_employee(
     db: Session = Depends(get_db),
     _: dict = Depends(get_current_admin)
 ):
-    """
-    Получение информации о сотруднике по ID (только для админа)
-    """
-    db_employee = employees.get_employee(db, employee_id=employee_id)
+    """Get employee by ID"""
+    db_employee = employees.get_employee(db, employee_id)
     if db_employee is None:
         raise HTTPException(status_code=404, detail="Employee not found")
     return db_employee
@@ -64,35 +48,20 @@ def update_employee(
     db: Session = Depends(get_db),
     _: dict = Depends(get_current_admin)
 ):
-    """
-    Обновление информации о сотруднике (только для админа)
-    """
-    db_employee = employees.get_employee(db, employee_id=employee_id)
+    """Update employee data"""
+    db_employee = employees.update_employee(db, employee_id, employee)
     if db_employee is None:
         raise HTTPException(status_code=404, detail="Employee not found")
-        
-    # Если указан новый пароль, хэшируем его
-    if employee.password:
-        employee.password = get_password_hash(employee.password)
-        
-    updated_employee = employees.update_employee(
-        db=db,
-        employee_id=employee_id,
-        employee=employee
-    )
-    return updated_employee
+    return db_employee
 
-@router.delete("/{employee_id}")
+@router.delete("/{employee_id}", response_model=Employee)
 def delete_employee(
     employee_id: int,
     db: Session = Depends(get_db),
     _: dict = Depends(get_current_admin)
 ):
-    """
-    Удаление сотрудника (только для админа)
-    """
-    db_employee = employees.get_employee(db, employee_id=employee_id)
+    """Delete employee"""
+    db_employee = employees.delete_employee(db, employee_id)
     if db_employee is None:
         raise HTTPException(status_code=404, detail="Employee not found")
-    employees.delete_employee(db=db, employee_id=employee_id)
-    return {"message": "Employee deleted successfully"}
+    return db_employee

backend/app/routers/requests.py

@@ -1,107 +1,67 @@
 """Requests router"""
-from fastapi import APIRouter, Depends, HTTPException, status
+from fastapi import APIRouter, Depends, HTTPException, Query
 from sqlalchemy.orm import Session
-from typing import List
+from typing import List, Optional
 from ..database import get_db
 from ..crud import requests
-from ..schemas.request import Request, RequestCreate, RequestUpdate, RequestStatistics
+from ..schemas.request import Request, RequestCreate, RequestUpdate
+from ..models.request import RequestStatus
 from ..utils.auth import get_current_employee, get_current_admin
-from ..utils.telegram import notify_new_request
-from ..utils.loggers import request_logger
 
 router = APIRouter()
 
-@router.post("", response_model=Request)
 @router.post("/", response_model=Request)
-async def create_request(
+def create_request(
     request: RequestCreate,
     db: Session = Depends(get_db),
     current_employee: dict = Depends(get_current_employee)
 ):
-    """
-    Создание новой заявки
-    """
-    # Логируем входящие данные
-    request_logger.info(
-        "Creating new request",
-        extra={
-            "request_data": request.model_dump(),
-            "employee_id": current_employee["id"]
-        }
-    )
-    
-    # Проверяем, что все поля заполнены правильно
-    request_logger.info(f"Request title: {request.title}")
-    request_logger.info(f"Request description: {request.description}")
-    request_logger.info(f"Request priority: {request.priority} (type: {type(request.priority)})")
-    request_logger.info(f"Request status: {request.status} (type: {type(request.status)})")
-    
-    db_request = requests.create_request(db=db, request=request, employee_id=current_employee["id"])
-    
-    # Логируем созданную заявку
-    request_logger.info(
-        "Request created successfully",
-        extra={
-            "request_id": db_request.id,
-            "status": db_request.status,
-            "priority": db_request.priority
-        }
-    )
-    
-    await notify_new_request(db_request.id)
-    return db_request
+    """Create new request"""
+    return requests.create_request(db, request, current_employee["id"])
 
-@router.get("", response_model=List[Request])
-@router.get("/", response_model=List[Request])
+@router.get("/my", response_model=List[Request])
 def get_employee_requests(
-    skip: int = 0,
-    limit: int = 100,
     db: Session = Depends(get_db),
     current_employee: dict = Depends(get_current_employee)
 ):
-    """
-    Получение списка заявок текущего сотрудника
-    """
-    return requests.get_employee_requests(db, employee_id=current_employee["id"], skip=skip, limit=limit)
+    """Get current employee's requests"""
+    return requests.get_employee_requests(db, current_employee["id"])
 
-@router.get("/statistics", response_model=RequestStatistics)
-def get_request_statistics(
+@router.get("/admin", response_model=List[Request])
+def get_all_requests(
+    status: Optional[RequestStatus] = Query(None),
+    skip: int = 0,
+    limit: int = 100,
     db: Session = Depends(get_db),
     _: dict = Depends(get_current_admin)
 ):
-    """
-    Получение статистики по заявкам (только для админа)
-    """
-    return requests.get_statistics(db)
+    """Get all requests (admin only)"""
+    return requests.get_requests(db, status=status, skip=skip, limit=limit)
 
-@router.put("/{request_id}", response_model=Request)
-def update_request(
+@router.patch("/{request_id}/status", response_model=Request)
+def update_request_status(
     request_id: int,
     request_update: RequestUpdate,
     db: Session = Depends(get_db),
     _: dict = Depends(get_current_admin)
 ):
-    """
-    Обновление статуса заявки (только для админа)
-    """
-    db_request = requests.get_request(db, request_id=request_id)
+    """Update request status (admin only)"""
+    db_request = requests.update_request_status(db, request_id, request_update.status)
     if db_request is None:
         raise HTTPException(status_code=404, detail="Request not found")
-    
-    return requests.update_request(db=db, request_id=request_id, request=request_update)
+    return db_request
 
-@router.delete("/{request_id}")
-def delete_request(
-    request_id: int,
+@router.get("/statistics")
+def get_request_statistics(
     db: Session = Depends(get_db),
     _: dict = Depends(get_current_admin)
 ):
-    """
-    Удаление заявки (только для админа)
-    """
-    db_request = requests.get_request(db, request_id=request_id)
-    if db_request is None:
-        raise HTTPException(status_code=404, detail="Request not found")
-    
-    requests.delete_request(db=db, request_id=request_id)
-    return {"message": "Request deleted successfully"}
+    """Get request statistics (admin only)"""
+    stats = requests.get_statistics(db)
+    return {
+        "total": stats["total"],
+        "by_status": {
+            status: count
+            for status, count in stats["by_status"].items()
+        }
+    }

backend/app/routers/statistics.py

@@ -2,35 +2,15 @@
 from fastapi import APIRouter, Depends
 from sqlalchemy.orm import Session
 from ..database import get_db
-from ..models.request import Request, RequestStatus
-from ..utils.loggers import request_logger
+from ..crud import statistics
+from ..utils.auth import get_current_admin
 
 router = APIRouter()
 
 @router.get("/")
-def get_statistics(db: Session = Depends(get_db)):
-    """Get request statistics"""
-    # Получаем общее количество заявок
-    total = db.query(Request).count()
-    request_logger.info(f"Total requests: {total}")
-    
-    # Получаем количество заявок по статусам
-    new_requests = db.query(Request).filter(Request.status == RequestStatus.NEW.value).count()
-    in_progress = db.query(Request).filter(Request.status == RequestStatus.IN_PROGRESS.value).count()
-    completed = db.query(Request).filter(Request.status == RequestStatus.COMPLETED.value).count()
-    rejected = db.query(Request).filter(Request.status == RequestStatus.REJECTED.value).count()
-    
-    request_logger.info(f"Status counts - new: {new_requests}, in_progress: {in_progress}, completed: {completed}, rejected: {rejected}")
-    
-    result = {
-        "total_requests": total,
-        "by_status": {
-            "new": new_requests,
-            "in_progress": in_progress,
-            "completed": completed,
-            "rejected": rejected
-        }
-    }
-    
-    request_logger.info(f"Returning statistics: {result}")
-    return result 
+def get_statistics(
+    db: Session = Depends(get_db),
+    _: dict = Depends(get_current_admin)
+):
+    """Get system statistics"""
+    return statistics.get_request_statistics(db)