Добавления тестов бекенда

backend/app/routers/employees.py

@@ -4,20 +4,29 @@ from sqlalchemy.orm import Session
 from typing import List
 from ..database import get_db
 from ..models.employee import Employee
-from ..schemas.employee import EmployeeCreate, EmployeeResponse
+from ..schemas.employee import EmployeeCreate, EmployeeResponse, EmployeeUpdate
+from ..utils.auth import get_current_admin
 from passlib.context import CryptContext
 
 router = APIRouter()
 pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
 
 @router.get("/", response_model=List[EmployeeResponse])
-def get_employees(db: Session = Depends(get_db)):
+def get_employees(db: Session = Depends(get_db), _: dict = Depends(get_current_admin)):
     """Get all employees"""
     employees = db.query(Employee).all()
     return employees
 
+@router.get("/{employee_id}", response_model=EmployeeResponse)
+def get_employee(employee_id: int, db: Session = Depends(get_db), _: dict = Depends(get_current_admin)):
+    """Get employee by ID"""
+    employee = db.query(Employee).filter(Employee.id == employee_id).first()
+    if not employee:
+        raise HTTPException(status_code=404, detail="Сотрудник не найден")
+    return employee
+
 @router.post("/", response_model=EmployeeResponse)
-def create_employee(employee: EmployeeCreate, db: Session = Depends(get_db)):
+def create_employee(employee: EmployeeCreate, db: Session = Depends(get_db), _: dict = Depends(get_current_admin)):
     """Create new employee"""
     # Хешируем пароль
     hashed_password = pwd_context.hash(employee.password)
@@ -36,4 +45,40 @@ def create_employee(employee: EmployeeCreate, db: Session = Depends(get_db)):
     db.commit()
     db.refresh(db_employee)
     
-    return db_employee
+    return db_employee
+
+@router.put("/{employee_id}", response_model=EmployeeResponse)
+def update_employee(
+    employee_id: int,
+    employee_update: EmployeeUpdate,
+    db: Session = Depends(get_db),
+    _: dict = Depends(get_current_admin)
+):
+    """Update employee data"""
+    db_employee = db.query(Employee).filter(Employee.id == employee_id).first()
+    if not db_employee:
+        raise HTTPException(status_code=404, detail="Сотрудник не найден")
+    
+    # Обновляем данные
+    update_data = employee_update.model_dump(exclude_unset=True)
+    for field, value in update_data.items():
+        setattr(db_employee, field, value)
+    
+    db.commit()
+    db.refresh(db_employee)
+    return db_employee
+
+@router.delete("/{employee_id}")
+def delete_employee(
+    employee_id: int,
+    db: Session = Depends(get_db),
+    _: dict = Depends(get_current_admin)
+):
+    """Delete employee"""
+    db_employee = db.query(Employee).filter(Employee.id == employee_id).first()
+    if not db_employee:
+        raise HTTPException(status_code=404, detail="Сотрудник не найден")
+    
+    db.delete(db_employee)
+    db.commit()
+    return {"message": "Сотрудник успешно удален"}

backend/app/routers/requests.py

@@ -1,57 +1,140 @@
 """Requests router"""
 from fastapi import APIRouter, Depends, HTTPException
 from sqlalchemy.orm import Session
-from typing import List
+from typing import List, Optional
 from ..database import get_db
 from ..models.request import Request, RequestStatus, RequestPriority
-from ..schemas.request import RequestCreate, RequestResponse
-from ..utils.telegram import send_notification
+from ..schemas.request import RequestCreate, RequestResponse, RequestUpdate, RequestStatistics
+from ..utils.auth import get_current_admin, get_current_employee
+from sqlalchemy import func
 
 router = APIRouter()
 
-@router.get("/", response_model=List[RequestResponse])
-def get_requests(db: Session = Depends(get_db)):
-    """Get all requests"""
-    requests = db.query(Request).all()
-    return requests
+def request_to_dict(request: Request) -> dict:
+    """Convert Request model to dictionary"""
+    return {
+        "id": request.id,
+        "title": request.title,
+        "description": request.description,
+        "priority": request.priority,
+        "status": request.status,
+        "employee_id": request.employee_id,
+        "created_at": request.created_at,
+        "updated_at": request.updated_at
+    }
 
 @router.post("/", response_model=RequestResponse)
-def create_request(request: RequestCreate, db: Session = Depends(get_db)):
+def create_request(
+    request: RequestCreate,
+    db: Session = Depends(get_db),
+    current_employee: dict = Depends(get_current_employee)
+):
     """Create new request"""
-    # Создаем новую заявку
-    db_request = Request(
-        employee_id=request.employee_id,
-        department=request.department,
-        request_type=request.request_type,
-        priority=request.priority,
-        description=request.description,
-        status=RequestStatus.NEW
-    )
-    
-    # Сохраняем в базу данных
-    db.add(db_request)
-    db.commit()
-    db.refresh(db_request)
-    
-    # Отправляем уведомление в Telegram
     try:
-        # Получаем данные сотрудника для уведомления
-        employee = db_request.employee
-        notification_data = {
-            'id': db_request.id,
-            'employee_first_name': employee.first_name,
-            'employee_last_name': employee.last_name,
-            'department': db_request.department,
-            'office': employee.office,
-            'request_type': db_request.request_type,
-            'priority': db_request.priority,
-            'description': db_request.description,
-            'status': db_request.status,
-            'created_at': db_request.created_at.isoformat()
-        }
-        send_notification(notification_data)
+        db_request = Request(
+            title=request.title,
+            description=request.description,
+            priority=request.priority,
+            status=RequestStatus.NEW.value,
+            employee_id=current_employee["id"]
+        )
+        
+        db.add(db_request)
+        db.commit()
+        db.refresh(db_request)
+        
+        return request_to_dict(db_request)
     except Exception as e:
-        # Логируем ошибку, но не прерываем выполнение
-        print(f"Error sending notification: {e}")
-    
-    return db_request
+        db.rollback()
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/my", response_model=List[RequestResponse])
+def get_employee_requests(
+    db: Session = Depends(get_db),
+    current_employee: dict = Depends(get_current_employee)
+):
+    """Get employee's requests"""
+    try:
+        requests = db.query(Request).filter(
+            Request.employee_id == current_employee["id"]
+        ).all()
+        
+        # Преобразуем объекты в словари до закрытия сессии
+        return [request_to_dict(request) for request in requests]
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.patch("/{request_id}/status", response_model=RequestResponse)
+def update_request_status(
+    request_id: int,
+    status_update: RequestUpdate,
+    db: Session = Depends(get_db),
+    _: dict = Depends(get_current_admin)
+):
+    """Update request status"""
+    try:
+        db_request = db.query(Request).filter(Request.id == request_id).first()
+        if not db_request:
+            raise HTTPException(status_code=404, detail="Заявка не найдена")
+        
+        db_request.status = status_update.status
+        db.commit()
+        db.refresh(db_request)
+        
+        return request_to_dict(db_request)
+    except HTTPException:
+        raise
+    except Exception as e:
+        db.rollback()
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/admin", response_model=List[RequestResponse])
+def get_all_requests(
+    status: Optional[str] = None,
+    db: Session = Depends(get_db),
+    _: dict = Depends(get_current_admin)
+):
+    """Get all requests with optional status filter"""
+    try:
+        query = db.query(Request)
+        if status:
+            query = query.filter(Request.status == status)
+        requests = query.all()
+        
+        # Преобразуем объекты в словари до закрытия сессии
+        return [request_to_dict(request) for request in requests]
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/statistics")
+def get_request_statistics(
+    db: Session = Depends(get_db),
+    _: dict = Depends(get_current_admin)
+):
+    """Get request statistics"""
+    try:
+        total_requests = db.query(Request).count()
+        
+        # Статистика по статусам
+        status_stats = db.query(
+            Request.status,
+            func.count(Request.id)
+        ).group_by(Request.status).all()
+        
+        # Статистика по приоритетам
+        priority_stats = db.query(
+            Request.priority,
+            func.count(Request.id)
+        ).group_by(Request.priority).all()
+        
+        return {
+            "total_requests": total_requests,
+            "by_status": {
+                status: count for status, count in status_stats
+            },
+            "by_priority": {
+                priority: count for priority, count in priority_stats
+            }
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))