python-fastapi-mm-zhcs-yj-api/routers/api/taskRegistration/__init__.py

import json
import random
from sqlalchemy import create_engine, select
from utils.StripTagsHTMLParser import *
from sqlalchemy.orm import Session
import traceback
from models import *
from common.db import db_task
from common.security import valid_access_token
from datetime import datetime, timedelta
from fastapi import APIRouter, Depends, HTTPException, Response, Query
from database import get_db
from pydantic import BaseModel

router = APIRouter()


@router.post('/create')
async def create_task(
        request: Request,
        db: Session = Depends(get_db),
        body=Depends(remove_xss_json),
        user_id=Depends(valid_access_token)):
    try:
        # 验证必需的字段
        required_fields = ['task_description', 'unit_name', 'registrar','event_code']
        missing_fields = [field for field in required_fields if field not in body]
        if missing_fields:
            raise HTTPException(status_code=401, detail=f"Missing required fields: {', '.join(missing_fields)}")

        event_code = db.query(EventBase).filter(EventBase.event_code == body.get('event_code')).first()
        if not event_code:
            return Response(content="事件不存在", status_code=400)
        task_id = db_task.get_next_event_id(db)

        task_base = TaskRegistration(
            **body,
            task_id=task_id
        )
        db.add(task_base)
        db.commit()

        return {
            "code": 200,
            "msg": "任务创建成功",
            "data": task_id
        }

    except Exception as e:
        db.rollback()
        traceback.print_exc()
        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")


class TaskQuery(BaseModel):
    task_id: str = None
    task_description: str = None
    unit_name: str = None
    registrar: str = None
    creation_time: str = None
    processing_status: str = None



@router.post('/select')
@router.get('/select')
async def select_tasks(
        request: Request,
        db: Session = Depends(get_db),
        query: TaskQuery = Depends(),
        sortBy: str = Query(None, description="排序字段"),
        sortOrder: str = Query(None, description="排序顺序"),
        user_id=Depends(valid_access_token),
        pageNum: int = Query(1, gt=0, description="页码"),
        event_code: str = Query(None, description="事件ID"),
        pageSize: int = Query(10, gt=0, le=100, description="每页大小")):
    try:
        missing_event_code = db.query(EventBase).filter(EventBase.event_code == event_code).first()
        # print(missing_event_code)
        if not missing_event_code:
            return Response(content="事件不存在", status_code=400)


        data_query = db.query(TaskRegistration).filter(TaskRegistration.del_flag != '2')
        data_query = data_query.filter(TaskRegistration.event_code == event_code)

        # 应用过滤条件
        if query.task_id:
            data_query = data_query.filter(TaskRegistration.task_id == query.task_id)
        if query.task_description:
            data_query = data_query.filter(TaskRegistration.task_description == query.task_description)
        if query.unit_name:
            data_query = data_query.filter(TaskRegistration.unit_name == query.unit_name)
        if query.registrar:
            data_query = data_query.filter(TaskRegistration.registrar == query.registrar)
        if query.creation_time:
            data_query = data_query.filter(TaskRegistration.creation_time == query.creation_time)
        if query.processing_status:
            data_query = data_query.filter(TaskRegistration.processing_status == query.processing_status)

        # print(TaskRegistration,sortBy)
        if sortBy:
            if hasattr(TaskRegistration, sortBy):
                print("xx")
                sort_attr = getattr(TaskRegistration, sortBy)
                data_query = data_query.order_by(sort_attr.asc() if sortOrder == 'asc' else sort_attr.desc())



        total_count = data_query.count()
        offset = (pageNum - 1) * pageSize
        data_query = data_query.offset(offset).limit(pageSize)

        tasks = data_query.all()

        return {
            "code": 200,
            "msg": "任务查询成功",
            "data": tasks,
            "total": total_count,
            "pages": (total_count + pageSize - 1) // pageSize,
            "current_page": pageNum,
            "page_size": pageSize
        }

    except Exception as e:
        db.rollback()
        traceback.print_exc()
        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")


@router.put('/update')
async def update_task_status(
        request: Request,
        db: Session = Depends(get_db),
        user_id=Depends(valid_access_token)):
    body = await request.json()
    task_id_to_use = body.get('task_id')
    processing_status = body.get('processing_status')

    event_code = db.query(EventBase).filter(EventBase.event_code == body.get('event_code')).first()
    if not event_code:
        return Response(content="事件不存在", status_code=400)


    if not task_id_to_use:
        return Response(content="Missing required parameter 'task_id'", status_code=400)
    if processing_status not in ['已完成', '处理中', '待处理','未完成']:
        return Response(content="processing_status must be '已完成' or '处理中' or '待处理' or '未完成'", status_code=400)

    task_entry = (db.query(TaskRegistration)
                  .filter(TaskRegistration.del_flag != '2')
                  .filter(TaskRegistration.task_id == task_id_to_use))
    task_entry = task_entry.first()
    if not task_entry:
        raise HTTPException(status_code=404, detail="任务不存在")

    task_entry.processing_status = processing_status
    task_entry.update_time = datetime.now()

    try:
        db.commit()
        return {
            "code": 200,
            "msg": "任务状态更新成功",
            "data": {
                "task_id": task_id_to_use,
                "processing_status": task_entry.processing_status,
                "update_time": task_entry.update_time.isoformat()
            }
        }
    except Exception as e:
        db.rollback()
        raise HTTPException(status_code=500, detail=str(e))

@router.delete('/delete')
async def delete_task(
        request: Request,
        db: Session = Depends(get_db),
        user_id=Depends(valid_access_token)):
    try:
        body = await request.json()
        task_id_to_use = body.get('taskID')
        if not task_id_to_use:
            raise HTTPException(status_code=400, detail="Missing required parameter 'taskID'")

        event_code = db.query(EventBase).filter(EventBase.event_code == body.get('event_code')).first()
        if not event_code:
            return Response(content="事件不存在", status_code=400)

        task_entry = db.query(TaskRegistration).filter(TaskRegistration.task_id == task_id_to_use).first()
        if not task_entry:
            raise HTTPException(status_code=404, detail="任务不存在")

        task_entry.del_flag = '2'

        try:
            db.commit()
            return {
                "code": 200,
                "msg": "任务删除成功",
                "data": {
                        "task_id": task_entry.task_id
                    }
                }
        except Exception as e:
            db.rollback()
            raise HTTPException(status_code=500, detail=f"An error occurred while deleting the task: {str(e)}")

    except HTTPException as e:
        raise e
    except Exception as e:
        db.rollback()
        raise HTTPException(status_code=500, detail=f"An unexpected error occurred: {str(e)}")

@router.get('/selectUnit')
async def select_unit(
        request: Request,
        db: Session = Depends(get_db),
        query: TaskQuery = Depends(),
        user_id=Depends(valid_access_token),
        ):
    try:
        data_query = db.query(TaskUnit).filter(TaskUnit.id != '2').all()
        return {
            "code": 200,
            "msg": "查询成功",
            "data": data_query
        }
    except HTTPException as e:
        raise e
    except Exception as e:
        db.rollback()
        raise HTTPException(status_code=500, detail=f"An unexpected error occurred: {str(e)}")