server/handlers.py - master - tinypot/lab4

server/handlers.py
211 строк7 KB
Tim Polus
lab4: Task Management API через RabbitMQ
02 мар 2026, 06:17
02 мар 2026, 06:1752ab147
from __future__ import annotations

from datetime import datetime

from database import (
    Session, User, Category, Task, TaskStatus, TaskPriority,
)


def _parse_status(raw: str | None) -> TaskStatus | None:
    if raw is None:
        return None
    try:
        return TaskStatus(raw)
    except ValueError:
        raise ValueError(f"Недопустимый статус: {raw}")


def _parse_priority(raw: str | None) -> TaskPriority | None:
    if raw is None:
        return None
    try:
        return TaskPriority(raw)
    except ValueError:
        raise ValueError(f"Недопустимый приоритет: {raw}")


def handle_get_users(session, data: dict, user_id: int) -> dict:
    users = session.query(User).all()
    return {"users": [u.to_dict() for u in users]}


def handle_get_user(session, data: dict, user_id: int) -> dict:
    uid = data.get("user_id", user_id)
    user = session.query(User).get(uid)
    if not user:
        raise ValueError(f"Пользователь {uid} не найден")
    return user.to_dict()


def handle_get_categories(session, data: dict, user_id: int) -> dict:
    cats = session.query(Category).filter_by(user_id=user_id).all()
    return {"categories": [c.to_dict() for c in cats]}


def handle_create_category(session, data: dict, user_id: int) -> dict:
    cat = Category(
        name=data["name"],
        description=data.get("description"),
        color=data.get("color"),
        user_id=user_id,
    )
    session.add(cat)
    session.commit()
    return cat.to_dict()


def handle_update_category(session, data: dict, user_id: int) -> dict:
    cat = session.query(Category).filter_by(id=data["category_id"], user_id=user_id).first()
    if not cat:
        raise ValueError(f"Категория {data['category_id']} не найдена")
    if "name" in data:
        cat.name = data["name"]
    if "description" in data:
        cat.description = data["description"]
    if "color" in data:
        cat.color = data["color"]
    session.commit()
    return cat.to_dict()


def handle_delete_category(session, data: dict, user_id: int) -> dict:
    cat = session.query(Category).filter_by(id=data["category_id"], user_id=user_id).first()
    if not cat:
        raise ValueError(f"Категория {data['category_id']} не найдена")
    session.delete(cat)
    session.commit()
    return {"deleted": True, "id": data["category_id"]}


def handle_get_tasks(session, data: dict, user_id: int) -> dict:
    q = session.query(Task).filter_by(user_id=user_id)

    if "status" in data:
        q = q.filter(Task.status == _parse_status(data["status"]))
    if "category_id" in data:
        q = q.filter(Task.category_id == data["category_id"])

    page = data.get("page", 1)
    page_size = data.get("page_size", 20)
    total = q.count()
    tasks = q.offset((page - 1) * page_size).limit(page_size).all()

    return {
        "page": page,
        "page_size": page_size,
        "total_count": total,
        "items": [t.to_dict() for t in tasks],
    }


def handle_get_task(session, data: dict, user_id: int) -> dict:
    task = session.query(Task).filter_by(id=data["task_id"], user_id=user_id).first()
    if not task:
        raise ValueError(f"Задача {data['task_id']} не найдена")
    return task.to_dict()


def handle_create_task(session, data: dict, user_id: int) -> dict:
    task = Task(
        title=data["title"],
        description=data.get("description"),
        status=_parse_status(data.get("status", "pending")),
        priority=_parse_priority(data.get("priority", "medium")),
        due_date=datetime.fromisoformat(data["due_date"]) if data.get("due_date") else None,
        user_id=user_id,
        category_id=data.get("category_id"),
    )
    session.add(task)
    session.commit()
    return task.to_dict()


def handle_update_task(session, data: dict, user_id: int) -> dict:
    task = session.query(Task).filter_by(id=data["task_id"], user_id=user_id).first()
    if not task:
        raise ValueError(f"Задача {data['task_id']} не найдена")

    if "title" in data:
        task.title = data["title"]
    if "description" in data:
        task.description = data["description"]
    if "status" in data:
        task.status = _parse_status(data["status"])
        if task.status == TaskStatus.COMPLETED:
            task.completed_at = datetime.utcnow()
    if "priority" in data:
        task.priority = _parse_priority(data["priority"])
    if "due_date" in data:
        task.due_date = datetime.fromisoformat(data["due_date"]) if data["due_date"] else None
    if "category_id" in data:
        task.category_id = data["category_id"]

    session.commit()
    return task.to_dict()


def handle_delete_task(session, data: dict, user_id: int) -> dict:
    task = session.query(Task).filter_by(id=data["task_id"], user_id=user_id).first()
    if not task:
        raise ValueError(f"Задача {data['task_id']} не найдена")
    session.delete(task)
    session.commit()
    return {"deleted": True, "id": data["task_id"]}


def handle_get_tasks_v2(session, data: dict, user_id: int) -> dict:
    q = session.query(Task).filter_by(user_id=user_id)

    if "status" in data:
        q = q.filter(Task.status == _parse_status(data["status"]))
    if "priority" in data:
        q = q.filter(Task.priority == _parse_priority(data["priority"]))
    if "category_id" in data:
        q = q.filter(Task.category_id == data["category_id"])

    page = data.get("page", 1)
    page_size = data.get("page_size", 20)
    total = q.count()
    tasks = q.offset((page - 1) * page_size).limit(page_size).all()

    return {
        "page": page,
        "page_size": page_size,
        "total_count": total,
        "items": [t.to_dict() for t in tasks],
    }


HANDLERS_V1 = {
    "get_users": handle_get_users,
    "get_user": handle_get_user,
    "get_categories": handle_get_categories,
    "create_category": handle_create_category,
    "update_category": handle_update_category,
    "delete_category": handle_delete_category,
    "get_tasks": handle_get_tasks,
    "get_task": handle_get_task,
    "create_task": handle_create_task,
    "update_task": handle_update_task,
    "delete_task": handle_delete_task,
}

HANDLERS_V2 = {
    **HANDLERS_V1,
    "get_tasks": handle_get_tasks_v2,
}


def dispatch(version: str, action: str, data: dict, user_id: int) -> dict:
    handlers = HANDLERS_V2 if version == "v2" else HANDLERS_V1

    handler = handlers.get(action)
    if not handler:
        raise ValueError(f"Неизвестный action: {action}")

    session = Session()
    try:
        return handler(session, data, user_id)
    finally:
        session.close()