починка сотрудников

backend/app/crud/employees.py

@@ -1,22 +1,23 @@
 """Employee CRUD operations"""
 from sqlalchemy.orm import Session
+from typing import Optional, List
 from ..models.employee import Employee
 from ..schemas.employee import EmployeeCreate, EmployeeUpdate
 from ..utils.loggers import auth_logger
 
-def get_employees(db: Session, skip: int = 0, limit: int = 100):
+def get_employees(db: Session, skip: int = 0, limit: int = 100) -> List[Employee]:
     """Get all employees"""
     return db.query(Employee).offset(skip).limit(limit).all()
 
-def get_employee(db: Session, employee_id: int):
+def get_employee(db: Session, employee_id: int) -> Optional[Employee]:
     """Get employee by ID"""
     return db.query(Employee).filter(Employee.id == employee_id).first()
 
-def get_employee_by_last_name(db: Session, last_name: str):
+def get_employee_by_last_name(db: Session, last_name: str) -> Optional[Employee]:
     """Get employee by last name"""
     return db.query(Employee).filter(Employee.last_name == last_name).first()
 
-def create_employee(db: Session, employee: EmployeeCreate, hashed_password: str):
+def create_employee(db: Session, employee: EmployeeCreate, hashed_password: str) -> Employee:
     """Create new employee"""
     try:
         db_employee = Employee(
@@ -31,26 +32,38 @@ def create_employee(db: Session, employee: EmployeeCreate, hashed_password: str)
         db.refresh(db_employee)
         return db_employee
     except Exception as e:
-        db.rollback()
         auth_logger.error(f"Error creating employee: {e}")
+        db.rollback()
         raise
 
-def update_employee(db: Session, employee_id: int, employee: EmployeeUpdate):
+def update_employee(db: Session, employee_id: int, employee: EmployeeUpdate) -> Optional[Employee]:
+    """Update employee"""
     db_employee = get_employee(db, employee_id)
     if not db_employee:
         return None
         
-    update_data = employee.model_dump(exclude_unset=True)
+    for field, value in employee.model_dump(exclude_unset=True).items():
-    for field, value in update_data.items():
         setattr(db_employee, field, value)
         
-    db.commit()
+    try:
-    db.refresh(db_employee)
+        db.commit()
-    return db_employee
+        db.refresh(db_employee)
+        return db_employee
+    except Exception as e:
+        auth_logger.error(f"Error updating employee: {e}")
+        db.rollback()
+        raise
 
-def delete_employee(db: Session, employee_id: int):
+def delete_employee(db: Session, employee_id: int) -> Optional[Employee]:
+    """Delete employee"""
     db_employee = get_employee(db, employee_id)
     if db_employee:
-        db.delete(db_employee)
+        try:
-        db.commit()
+            db.delete(db_employee)
-    return db_employee
+            db.commit()
+            return db_employee
+        except Exception as e:
+            auth_logger.error(f"Error deleting employee: {e}")
+            db.rollback()
+            raise
+    return None

backend/app/main.py

@@ -20,7 +20,7 @@ app.add_middleware(
 
 # Include routers
 app.include_router(auth.router, prefix="/api/auth", tags=["auth"])
-app.include_router(employees.router, prefix="/api/employees", tags=["employees"])
+app.include_router(employees.router)
 app.include_router(requests.router, prefix="/api/requests", tags=["requests"])
 app.include_router(admin.router, prefix="/api/admin", tags=["admin"])
 app.include_router(statistics.router, prefix="/api/statistics", tags=["statistics"])

backend/app/models/employee.py

@@ -16,4 +16,4 @@ class Employee(Base):
     created_at = Column(DateTime(timezone=True), server_default=func.now())
 
     # Определяем отношение к Request
-    requests = relationship("Request", back_populates="employee")
+    requests = relationship("Request", back_populates="employee", cascade="all, delete-orphan")

backend/app/routers/employees.py

@@ -11,66 +11,107 @@ from ..utils.auth import get_current_admin, get_password_hash
 # Настройка логирования
 logger = logging.getLogger(__name__)
 
-router = APIRouter()
+router = APIRouter(prefix="/api/employees", tags=["employees"])
 
-@router.post("/", response_model=Employee)
+@router.post("/", response_model=Employee, status_code=status.HTTP_201_CREATED)
-def create_employee(
+async def create_employee(
     employee: EmployeeCreate,
     db: Session = Depends(get_db),
     _: dict = Depends(get_current_admin)
 ):
     """Create new employee"""
-    logger.info(f"Creating employee: {employee}")
+    try:
-    hashed_password = get_password_hash(employee.password)
+        logger.info(f"Creating employee: {employee}")
-    return employees.create_employee(db, employee, hashed_password)
+        hashed_password = get_password_hash(employee.password)
+        return employees.create_employee(db, employee, hashed_password)
+    except Exception as e:
+        logger.error(f"Error creating employee: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Error creating employee"
+        )
 
 @router.get("/", response_model=List[Employee])
-def get_employees(
+async def get_employees(
     skip: int = 0,
     limit: int = 100,
     db: Session = Depends(get_db),
     _: dict = Depends(get_current_admin)
 ):
     """Get all employees"""
-    logger.info("Getting all employees")
+    try:
-    return employees.get_employees(db, skip=skip, limit=limit)
+        logger.info("Getting all employees")
+        return employees.get_employees(db, skip=skip, limit=limit)
+    except Exception as e:
+        logger.error(f"Error getting employees: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Error getting employees"
+        )
 
 @router.get("/{employee_id}/", response_model=Employee)
-def get_employee(
+async def get_employee(
     employee_id: int,
     db: Session = Depends(get_db),
     _: dict = Depends(get_current_admin)
 ):
     """Get employee by ID"""
-    logger.info(f"Getting employee by ID: {employee_id}")
+    try:
-    db_employee = employees.get_employee(db, employee_id)
+        logger.info(f"Getting employee by ID: {employee_id}")
-    if db_employee is None:
+        db_employee = employees.get_employee(db, employee_id)
-        raise HTTPException(status_code=404, detail="Employee not found")
+        if db_employee is None:
-    return db_employee
+            raise HTTPException(status_code=404, detail="Employee not found")
+        return db_employee
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error getting employee: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Error getting employee"
+        )
 
 @router.put("/{employee_id}/", response_model=Employee)
-def update_employee(
+async def update_employee(
     employee_id: int,
     employee: EmployeeUpdate,
     db: Session = Depends(get_db),
     _: dict = Depends(get_current_admin)
 ):
     """Update employee data"""
-    logger.info(f"Updating employee {employee_id}: {employee}")
+    try:
-    db_employee = employees.update_employee(db, employee_id, employee)
+        logger.info(f"Updating employee {employee_id}: {employee}")
-    if db_employee is None:
+        db_employee = employees.update_employee(db, employee_id, employee)
-        raise HTTPException(status_code=404, detail="Employee not found")
+        if db_employee is None:
-    return db_employee
+            raise HTTPException(status_code=404, detail="Employee not found")
+        return db_employee
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error updating employee: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Error updating employee"
+        )
 
 @router.delete("/{employee_id}/", response_model=Employee)
-def delete_employee(
+async def delete_employee(
     employee_id: int,
     db: Session = Depends(get_db),
     _: dict = Depends(get_current_admin)
 ):
     """Delete employee"""
-    logger.info(f"Deleting employee: {employee_id}")
+    try:
-    db_employee = employees.delete_employee(db, employee_id)
+        logger.info(f"Deleting employee: {employee_id}")
-    if db_employee is None:
+        db_employee = employees.delete_employee(db, employee_id)
-        raise HTTPException(status_code=404, detail="Employee not found")
+        if db_employee is None:
-    return db_employee
+            raise HTTPException(status_code=404, detail="Employee not found")
+        return db_employee
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error deleting employee: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Error deleting employee"
+        )

backend/app/schemas/employee.py

@@ -1,6 +1,7 @@
 """Employee schemas"""
 from pydantic import BaseModel, ConfigDict
 from datetime import datetime
+from typing import Optional
 
 class EmployeeBase(BaseModel):
     first_name: str
@@ -14,7 +15,10 @@ class EmployeeCreate(EmployeeBase):
     password: str
 
 class EmployeeUpdate(EmployeeBase):
-    pass
+    first_name: Optional[str] = None
+    last_name: Optional[str] = None
+    department: Optional[str] = None
+    office: Optional[str] = None
 
 class Employee(EmployeeBase):
     id: int