Создание чата9testt

backend/app/api/endpoints/admin.py

@@ -1,4 +1,4 @@
-"""Admin router"""
+"""Admin endpoints."""
 from fastapi import APIRouter, Depends, HTTPException, status
 from sqlalchemy.orm import Session
 from sqlalchemy import func
@@ -19,7 +19,7 @@ def get_statistics(
     current_user: User = Depends(get_current_user),
     db: Session = Depends(get_db)
 ):
-    """Get system statistics"""
+    """Get system statistics."""
     if not current_user.is_admin:
         raise HTTPException(
             status_code=status.HTTP_403_FORBIDDEN,
@@ -66,7 +66,7 @@ def get_all_requests(
     current_user: User = Depends(get_current_user),
     db: Session = Depends(get_db)
 ):
-    """Get all requests (admin only)"""
+    """Get all requests (admin only)."""
     if not current_user.is_admin:
         raise HTTPException(
             status_code=status.HTTP_403_FORBIDDEN,
@@ -83,7 +83,7 @@ def update_request_status(
     current_user: User = Depends(get_current_user),
     db: Session = Depends(get_db)
 ):
-    """Update request status (admin only)"""
+    """Update request status (admin only)."""
     if not current_user.is_admin:
         raise HTTPException(
             status_code=status.HTTP_403_FORBIDDEN,
@@ -106,7 +106,7 @@ def get_all_users(
     current_user: User = Depends(get_current_user),
     db: Session = Depends(get_db)
 ):
-    """Get all users (admin only)"""
+    """Get all users (admin only)."""
     if not current_user.is_admin:
         raise HTTPException(
             status_code=status.HTTP_403_FORBIDDEN,

backend/app/api/endpoints/auth.py

@@ -1,4 +1,4 @@
-"""Authentication router"""
+"""Authentication endpoints."""
 from datetime import timedelta
 from typing import Any
 from fastapi import APIRouter, Depends, HTTPException, status
@@ -14,6 +14,7 @@ from app.database import get_db
 from app.core.config import settings
 from app.models.user import User
 from app.schemas.token import Token
+from app.schemas.user import User as UserSchema
 
 router = APIRouter()
 
@@ -22,9 +23,7 @@ def login(
     db: Session = Depends(get_db),
     form_data: OAuth2PasswordRequestForm = Depends()
 ) -> Any:
-    """
-    OAuth2 compatible token login, get an access token for future requests
-    """
+    """OAuth2 compatible token login, get an access token for future requests."""
     user = authenticate_user(db, form_data.username, form_data.password)
     if not user:
         raise HTTPException(
@@ -49,10 +48,8 @@ def login(
         "token_type": "bearer"
     }
 
-@router.get("/me", response_model=Any)
+@router.get("/me", response_model=UserSchema)
 def read_users_me(current_user: User = Depends(get_current_user)):
-    """
-    Get current user.
-    """
+    """Get current user."""
     return current_user
 

backend/app/api/endpoints/chat.py

@@ -1,137 +1,74 @@
-from fastapi import APIRouter, Depends, HTTPException, WebSocket, UploadFile, File
+from fastapi import APIRouter, Depends, HTTPException, WebSocket, status
 from sqlalchemy.orm import Session
 from typing import List
-import os
-import aiofiles
-import uuid
-
 from app.database import get_db
-from app.models.user import User
 from app.core.auth import get_current_user
-from app.schemas.chat import Chat, Message, ChatFile
-from app.websockets.chat import handle_chat_connection
+from app.core.ws_auth import get_current_user_ws
+from app.models.user import User
+from app.schemas.chat import (
+    Chat, ChatCreate,
+    Message, MessageCreate,
+    ChatFile, ChatFileCreate
+)
 
 router = APIRouter()
 
-# Путь для сохранения файлов
-UPLOAD_DIR = "uploads/chat_files"
-os.makedirs(UPLOAD_DIR, exist_ok=True)
-
 @router.websocket("/ws")
-async def websocket_endpoint(websocket: WebSocket, db: Session = Depends(get_db)):
-    await handle_chat_connection(websocket, db)
-
-@router.post("/files/")
-async def upload_file(
-    file: UploadFile = File(...),
-    current_user: User = Depends(get_current_user),
+async def chat_websocket(
+    websocket: WebSocket,
     db: Session = Depends(get_db)
 ):
+    user = await get_current_user_ws(websocket, db)
+    if not user:
+        return
+    
+    await websocket.accept()
     try:
-        # Генерируем уникальное имя файла
-        file_extension = os.path.splitext(file.filename)[1]
-        unique_filename = f"{uuid.uuid4()}{file_extension}"
-        file_path = os.path.join(UPLOAD_DIR, unique_filename)
-
-        # Сохраняем файл
-        async with aiofiles.open(file_path, 'wb') as out_file:
-            content = await file.read()
-            await out_file.write(content)
-
-        return {
-            "filename": file.filename,
-            "saved_path": file_path,
-            "size": len(content)
-        }
+        while True:
+            data = await websocket.receive_text()
+            # Обработка сообщений
+            await websocket.send_text(f"Message received: {data}")
     except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
+        print(f"Error: {e}")
+    finally:
+        await websocket.close()
 
-@router.get("/messages/", response_model=List[Message])
-def get_messages(
+@router.post("/", response_model=Chat)
+def create_chat(
+    chat: ChatCreate,
     current_user: User = Depends(get_current_user),
     db: Session = Depends(get_db)
 ):
-    # Получаем чат пользователя
-    chat = db.query(Chat).filter(
-        (Chat.employee_id == current_user.id) |
-        (Chat.admin_id == current_user.id)
-    ).first()
+    """Create new chat."""
+    # Здесь будет логика создания чата
+    pass
 
-    if not chat:
-        return []
+@router.get("/", response_model=List[Chat])
+def get_chats(
+    current_user: User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """Get all chats for current user."""
+    # Здесь будет логика получения чатов
+    pass
 
-    # Получаем сообщения
-    messages = db.query(Message).filter(Message.chat_id == chat.id).all()
-    return messages
+@router.post("/{chat_id}/messages", response_model=Message)
+def create_message(
+    chat_id: int,
+    message: MessageCreate,
+    current_user: User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """Create new message in chat."""
+    # Здесь будет логика создания сообщения
+    pass
 
-@router.get("/messages/{chat_id}/", response_model=List[Message])
-def get_chat_messages(
+@router.get("/{chat_id}/messages", response_model=List[Message])
+def get_messages(
     chat_id: int,
     current_user: User = Depends(get_current_user),
     db: Session = Depends(get_db)
 ):
-    # Проверяем доступ к чату
-    chat = db.query(Chat).filter(Chat.id == chat_id).first()
-    if not chat:
-        raise HTTPException(status_code=404, detail="Chat not found")
-
-    if not current_user.is_admin and chat.employee_id != current_user.id:
-        raise HTTPException(status_code=403, detail="Not authorized")
-
-    # Получаем сообщения
-    messages = db.query(Message).filter(Message.chat_id == chat_id).all()
-    return messages
-
-@router.get("/unread-count/")
-def get_unread_count(
-    current_user: User = Depends(get_current_user),
-    db: Session = Depends(get_db)
-):
-    # Получаем чат пользователя
-    chat = db.query(Chat).filter(
-        (Chat.employee_id == current_user.id) |
-        (Chat.admin_id == current_user.id)
-    ).first()
-
-    if not chat:
-        return {"unread_count": 0}
-
-    # Считаем непрочитанные сообщения
-    unread_count = db.query(Message).filter(
-        Message.chat_id == chat.id,
-        Message.sender_id != current_user.id,
-        Message.is_read == False
-    ).count()
-
-    return {"unread_count": unread_count}
-
-@router.get("/admin/chats/", response_model=List[Chat])
-def get_admin_chats(
-    current_user: User = Depends(get_current_user),
-    db: Session = Depends(get_db)
-):
-    if not current_user.is_admin:
-        raise HTTPException(status_code=403, detail="Not authorized")
-
-    # Получаем все чаты с последними сообщениями и количеством непрочитанных
-    chats = db.query(Chat).all()
-    
-    # Для каждого чата добавляем дополнительную информацию
-    for chat in chats:
-        # Последнее сообщение
-        last_message = db.query(Message)\
-            .filter(Message.chat_id == chat.id)\
-            .order_by(Message.created_at.desc())\
-            .first()
-        chat.last_message = last_message
-
-        # Количество непрочитанных сообщений
-        unread_count = db.query(Message)\
-            .filter(
-                Message.chat_id == chat.id,
-                Message.sender_id != current_user.id,
-                Message.is_read == False
-            ).count()
-        chat.unread_count = unread_count
-
-    return chats 
+    """Get all messages in chat."""
+    # Здесь будет логика получения сообщений
+    pass 

backend/app/api/endpoints/employees.py

@@ -1,52 +1,86 @@
-"""Employee router"""
+"""Employee endpoints."""
 from fastapi import APIRouter, Depends, HTTPException, status
 from sqlalchemy.orm import Session
 from typing import List
 
-from app.core.auth import get_current_user, get_password_hash
 from app.database import get_db
 from app.models.user import User
-from app.schemas.user import UserCreate, User as UserSchema
+from app.core.auth import get_current_user, get_password_hash
+from app.schemas.user import User as UserSchema, UserCreate, UserUpdate
 
 router = APIRouter()
 
 @router.post("/", response_model=UserSchema)
 def create_employee(
     user: UserCreate,
+    current_user: User = Depends(get_current_user),
     db: Session = Depends(get_db)
 ):
-    # Проверяем, не существует ли уже пользователь с таким email
+    """Create new employee (admin only)."""
+    if not current_user.is_admin:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Not enough permissions"
+        )
+
+    # Проверяем, не существует ли пользователь с таким email
     db_user = db.query(User).filter(User.email == user.email).first()
     if db_user:
         raise HTTPException(
             status_code=status.HTTP_400_BAD_REQUEST,
             detail="Email already registered"
         )
-    
-    # Создаем нового пользователя
+
+    # Создаем пользователя
     hashed_password = get_password_hash(user.password)
     db_user = User(
         email=user.email,
         full_name=user.full_name,
         hashed_password=hashed_password,
-        is_admin=False
+        is_admin=user.is_admin
     )
     db.add(db_user)
     db.commit()
     db.refresh(db_user)
     return db_user
 
-@router.get("/", response_model=List[UserSchema])
-def read_employees(
-    skip: int = 0,
-    limit: int = 100,
+@router.get("/me", response_model=UserSchema)
+def get_current_employee(current_user: User = Depends(get_current_user)):
+    """Get current employee info."""
+    return current_user
+
+@router.put("/me", response_model=UserSchema)
+def update_employee_me(
+    user_update: UserUpdate,
     current_user: User = Depends(get_current_user),
     db: Session = Depends(get_db)
 ):
+    """Update current employee info."""
+    update_data = user_update.model_dump(exclude_unset=True)
+    if "password" in update_data:
+        update_data["hashed_password"] = get_password_hash(update_data.pop("password"))
+    
+    for key, value in update_data.items():
+        setattr(current_user, key, value)
+    
+    db.commit()
+    db.refresh(current_user)
+    return current_user
+
+@router.get("/{employee_id}", response_model=UserSchema)
+def get_employee(
+    employee_id: int,
+    current_user: User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """Get employee by ID (admin only)."""
     if not current_user.is_admin:
         raise HTTPException(
             status_code=status.HTTP_403_FORBIDDEN,
             detail="Not enough permissions"
         )
-    users = db.query(User).filter(User.is_admin == False).offset(skip).limit(limit).all()
-    return users
+
+    employee = db.query(User).filter(User.id == employee_id).first()
+    if not employee:
+        raise HTTPException(status_code=404, detail="Employee not found")
+    return employee

backend/app/api/endpoints/requests.py

@@ -1,13 +1,12 @@
-"""Requests router"""
-from fastapi import APIRouter, Depends, HTTPException, status
+"""Request endpoints."""
+from fastapi import APIRouter, Depends, HTTPException
 from sqlalchemy.orm import Session
 from typing import List
-
-from app.core.auth import get_current_user
 from app.database import get_db
 from app.models.user import User
 from app.models.request import Request
 from app.schemas.request import RequestCreate, Request as RequestSchema
+from app.core.auth import get_current_user
 
 router = APIRouter()
 
@@ -17,89 +16,34 @@ def create_request(
     current_user: User = Depends(get_current_user),
     db: Session = Depends(get_db)
 ):
-    """Create new request"""
+    """Create new request."""
     db_request = Request(
-        **request.dict(),
         employee_id=current_user.id,
-        status="new"
+        **request.model_dump()
     )
     db.add(db_request)
     db.commit()
     db.refresh(db_request)
     return db_request
 
-@router.get("/", response_model=List[RequestSchema])
-def read_requests(
-    skip: int = 0,
-    limit: int = 100,
+@router.get("/my", response_model=List[RequestSchema])
+def get_my_requests(
     current_user: User = Depends(get_current_user),
     db: Session = Depends(get_db)
 ):
-    """Get all requests (admin only)"""
-    if current_user.is_admin:
-        requests = db.query(Request).offset(skip).limit(limit).all()
-    else:
-        requests = db.query(Request).filter(
-            Request.employee_id == current_user.id
-        ).offset(skip).limit(limit).all()
-    return requests
+    """Get current user's requests."""
+    return db.query(Request).filter(Request.employee_id == current_user.id).all()
 
 @router.get("/{request_id}", response_model=RequestSchema)
-def read_request(
+def get_request(
     request_id: int,
     current_user: User = Depends(get_current_user),
     db: Session = Depends(get_db)
 ):
-    """Get a specific request"""
+    """Get request by ID."""
     request = db.query(Request).filter(Request.id == request_id).first()
     if not request:
         raise HTTPException(status_code=404, detail="Request not found")
-    
-    # Проверяем права доступа
     if not current_user.is_admin and request.employee_id != current_user.id:
-        raise HTTPException(status_code=403, detail="Not enough permissions")
-    
-    return request
-
-@router.put("/{request_id}", response_model=RequestSchema)
-def update_request(
-    request_id: int,
-    request_update: RequestCreate,
-    current_user: User = Depends(get_current_user),
-    db: Session = Depends(get_db)
-):
-    """Update a request"""
-    db_request = db.query(Request).filter(Request.id == request_id).first()
-    if not db_request:
-        raise HTTPException(status_code=404, detail="Request not found")
-    
-    # Проверяем права доступа
-    if not current_user.is_admin and db_request.employee_id != current_user.id:
-        raise HTTPException(status_code=403, detail="Not enough permissions")
-    
-    # Обновляем заявку
-    for key, value in request_update.dict().items():
-        setattr(db_request, key, value)
-    
-    db.commit()
-    db.refresh(db_request)
-    return db_request
-
-@router.delete("/{request_id}", response_model=RequestSchema)
-def delete_request(
-    request_id: int,
-    current_user: User = Depends(get_current_user),
-    db: Session = Depends(get_db)
-):
-    """Delete a request"""
-    db_request = db.query(Request).filter(Request.id == request_id).first()
-    if not db_request:
-        raise HTTPException(status_code=404, detail="Request not found")
-    
-    # Только админ может удалять заявки
-    if not current_user.is_admin:
-        raise HTTPException(status_code=403, detail="Not enough permissions")
-    
-    db.delete(db_request)
-    db.commit()
-    return db_request
+        raise HTTPException(status_code=403, detail="Not authorized to access this request")
+    return request

backend/app/api/endpoints/statistics.py

@@ -1,13 +1,13 @@
-"""Statistics router"""
+"""Statistics endpoints."""
 from fastapi import APIRouter, Depends, HTTPException, status
 from sqlalchemy.orm import Session
 from sqlalchemy import func
 from datetime import datetime, timedelta
 
-from app.core.auth import get_current_user
 from app.database import get_db
 from app.models.user import User
 from app.models.request import Request
+from app.core.auth import get_current_user
 
 router = APIRouter()
 
@@ -16,6 +16,7 @@ def get_statistics(
     current_user: User = Depends(get_current_user),
     db: Session = Depends(get_db)
 ):
+    """Get system statistics (admin only)."""
     if not current_user.is_admin:
         raise HTTPException(
             status_code=status.HTTP_403_FORBIDDEN,