role group user..

zhaoqingang

2024-11-11 c1768114de381e37e272e9faf7db8e95a93ff381

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
from fastapi import APIRouter, Depends
from win32ctypes.pywin32.pywintypes import datetime
 
from app.api import Response, get_current_user
from app.models.base_model import get_db
from app.models.group_model import GroupModel, GroupData, GroupUsers
from app.models.user import PageParameter
from app.models.user_model import UserModel
from app.service.group import create_group, group_list, edit_group_data, delete_group_data, get_group_users, \
    save_user_to_group
 
group_router = APIRouter()
 
 
@group_router.post("/group_list", response_model=Response)
async def user_group_list(paras: PageParameter, current_user: UserModel = Depends(get_current_user),
                          db=Depends(get_db)):
    return Response(code=200, msg="", data=await group_list(db, paras.page_size, paras.page_index, paras.keyword))
 
 
@group_router.post("/add_group", response_model=Response)
async def add_group(group: GroupData, current_user: UserModel = Depends(get_current_user), db=Depends(get_db)):
    if not group.group_name:
        return Response(code=400, msg="The group_name cannot be empty!")
    db_group = db.query(GroupModel).filter(GroupModel.group_name == group.group_name).first()
    if db_group:
        return Response(code=200, msg="group already created")
    is_create = await create_group(db, group.group_name, group.group_description)
    if not is_create:
        return Response(code=200, msg="group create failure", data={})
    return Response(code=200, msg="group create successfully", data={"group_name": group.group_name})
 
 
@group_router.post("/edit_group", response_model=Response)
async def edit_group(group: GroupData, current_user: UserModel = Depends(get_current_user), db=Depends(get_db)):
    if not group.group_name:
        return Response(code=400, msg="The group_name cannot be empty!")
    db_group = db.query(GroupModel).filter(GroupModel.group_name == group.group_name).first()
    if db_group:
        return Response(code=200, msg="group_name already created")
    is_edit = await edit_group_data(db, group.id,
                                    {"group_name": group.group_name, "group_description": group.group_description,
                                     "updated_at": datetime.now()})
    if not is_edit:
        return Response(code=200, msg="group edit failure", data={})
    return Response(code=200, msg="group edit successfully", data={"group_name": group.group_name})
 
 
@group_router.post("/edit_group_status", response_model=Response)
async def edit_group_status(group: GroupData, current_user: UserModel = Depends(get_current_user), db=Depends(get_db)):
    if group.group_status not in ["0", "1"]:
        return Response(code=400, msg="The status cannot be {}!".format(group.group_status))
    db_group = db.query(GroupModel).filter(GroupModel.id == group.id).first()
    if not db_group:
        return Response(code=200, msg="group does not exist")
    is_edit = await edit_group_data(db, group.id,
                                    {"status": group.group_status,"updated_at": datetime.now()})
    if not is_edit:
        return Response(code=200, msg="group status edit failure", data={})
    return Response(code=200, msg="group status edit successfully", data={"group_name": group.group_name})
 
 
@group_router.post("/delete_group", response_model=Response)
async def delete_group(group: GroupData, current_user: UserModel = Depends(get_current_user), db=Depends(get_db)):
    db_group = db.query(GroupModel).filter(GroupModel.id == group.id).first()
    if not db_group:
        return Response(code=200, msg="group does not exist")
    is_edit = await delete_group_data(db, group.id)
    if not is_edit:
        return Response(code=200, msg="group delete failure", data={})
    return Response(code=200, msg="group delete successfully", data={})
 
 
@group_router.post("/group_users", response_model=Response)
async def group_users(group: GroupData, current_user: UserModel = Depends(get_current_user), db=Depends(get_db)):
    db_group = db.query(GroupModel).filter(GroupModel.id == group.id).first()
    if not db_group:
        return Response(code=200, msg="group does not exist", data={})
    return Response(code=200, msg="success", data=await get_group_users(db, group.id))
 
 
@group_router.post("/save_group_user", response_model=Response)
async def save_group_user(group_user: GroupUsers, current_user: UserModel = Depends(get_current_user),
                          db=Depends(get_db)):
    db_group = db.query(GroupModel).filter(GroupModel.id == group_user.id).first()
    if not db_group:
        return Response(code=200, msg="group does not exist")
    is_success = await save_user_to_group(db, current_user.id, group_user.id, group_user.user_list)
    if not is_success:
        return Response(code=500, msg="save user to group failure", data={})
    return Response(code=200, msg="success", data={})