用户、项目、权限体系构建

app/common/decorators.py

@@ -0,0 +1,68 @@
+from typing import Optional
+from fastapi import FastAPI, Header, HTTPException, Depends, Request
+from sqlalchemy.orm import Session
+from app import crud, get_db, get_page, schemas
+
+def verify_user(request: Request, user_token: str = Header(), db: Session = Depends(get_db)):
+    try:
+        user = crud.verify_user_token(db, user_token)
+    except Exception as e:
+        raise HTTPException(status_code=401, detail=str(e))
+
+def verify_super_admin(request: Request, user_token: str = Header(), db: Session = Depends(get_db)):
+    print(request.url.path)
+    try:
+        user = crud.verify_user_token(db, user_token)
+    except Exception as e:
+        raise HTTPException(status_code=401, detail=str(e))
+    if user.id != 1:
+        raise HTTPException(status_code=401, detail='该用户不拥有此权限')
+
+def verify_all(request: Request, user_token: str = Header(), item_token: str = Header(), db: Session = Depends(get_db)):
+    try:
+        user = crud.verify_user_token(db, user_token)
+    except Exception as e:
+        raise HTTPException(status_code=401, detail=str(e))
+    try:
+        project = crud.verify_item_token(db, item_token)
+    except Exception as e:
+        raise HTTPException(status_code=401, detail=str(e))
+    relations = crud.get_relations_by_user(db,user.id)
+    project_role = {r.project_id:r.role_id for r in relations}
+    if not project.id in project_role.keys():
+        raise HTTPException(status_code=401, detail='该用户不属于此项目')
+    role = crud.get_role_info(db,project_role[project.id])
+
+def verify_special(request: Request, user_token: str = Header(), item_token: str = Header(), db: Session = Depends(get_db)):
+    try:
+        user = crud.verify_user_token(db, user_token)
+    except Exception as e:
+        raise HTTPException(status_code=401, detail=str(e))
+    try:
+        project = crud.verify_item_token(db, item_token)
+    except Exception as e:
+        raise HTTPException(status_code=401, detail=str(e))
+    relations = crud.get_relations_by_user(db,user.id)
+    project_role = {r.project_id:r.role_id for r in relations}
+    if not project.id in project_role.keys():
+        raise HTTPException(status_code=401, detail='该用户不属于此项目')
+    role = crud.get_role_info(db,project_role[project.id])
+    if not role.id in ['726a51e45b4d11edbb4809c4df301a','9ff183445b4d11ed87db29f50d093a','eef984e65b4d11ed8cc491f9c82401']:
+        raise HTTPException(status_code=401, detail='该用户没有此接口的权限')
+
+def verify_admin(request: Request, user_token: str = Header(), item_token: str = Header(), db: Session = Depends(get_db)):
+    try:
+        user = crud.verify_user_token(db, user_token)
+    except Exception as e:
+        raise HTTPException(status_code=401, detail=str(e))
+    try:
+        project = crud.verify_item_token(db, item_token)
+    except Exception as e:
+        raise HTTPException(status_code=401, detail=str(e))
+    relations = crud.get_relations_by_user(db,user.id)
+    project_role = {r.project_id:r.role_id for r in relations}
+    if not project.id in project_role.keys():
+        raise HTTPException(status_code=401, detail='该用户不属于此项目')
+    role = crud.get_role_info(db,project_role[project.id])
+    if not role.id in ['726a51e45b4d11edbb4809c4df301a','9ff183445b4d11ed87db29f50d093a','026bd8bc5b4e11ed857e6b5ec5c8d6']:
+        raise HTTPException(status_code=401, detail='该用户没有此接口的权限')

app/crud/__init__.py

@@ -12,3 +12,6 @@ from app.crud.af_task import *
 from app.crud.af_job import *
 from app.crud.af_run import *
 from app.crud.relation import *
+from app.crud.users import *
+from app.crud.project import *
+from app.crud.roles import *

app/crud/job_info.py

@@ -2,7 +2,6 @@ import time
 from typing import List
 from app import models, schemas
 from sqlalchemy.orm import Session
-from app.services.datax import datax_create_job
 from app.utils.cron_utils import *
 
 

app/crud/project.py

@@ -0,0 +1,85 @@
+import time
+import uuid
+from typing import List
+from app import models, schemas
+from sqlalchemy.orm import Session
+from itsdangerous import BadSignature, SignatureExpired
+from itsdangerous import TimedJSONWebSignatureSerializer as Serializer
+from constants.constants import SECRET_KEY
+
+# 生成新的project_token
+def generate_item_token(project: models.Project):
+    s = Serializer(SECRET_KEY)
+    return s.dumps({'project_id': project.id,'type':project.type}).decode('utf-8')
+
+# 验证Token方法
+def verify_item_token(db: Session, token: str):
+    s = Serializer(SECRET_KEY)
+    try:
+        data = s.loads(token)
+    except SignatureExpired:
+        raise Exception("item_token验证失败")
+    except BadSignature:
+        raise Exception("item_token验证失败")
+    project: models.Project = db.query(models.Project).filter(models.Project.id == data['project_id']).first()
+    return project
+
+def create_project(db: Session, item: schemas.ProjectCreate):
+    # 创建项目
+    check_1 = db.query(models.Project).filter(models.Project.name == item.name).first()
+    if check_1:
+        raise Exception('项目名重复')
+    project_code = str(uuid.uuid1()).replace('-','')
+    db_item = models.Project(**{
+        'name': item.name,
+        'code': project_code,
+        'type': 1,
+        'create_time': int(time.time())
+    })
+    db.add(db_item)
+    db.commit()
+    db.refresh(db_item)
+    project_dict = db_item.to_dict()
+    # 创建超级管理员与项目的关系
+    relation = models.ProjectUserRelation(**{
+        'user_id': item.user_id,
+        'project_id': db_item.id,
+        'role_id': 1,
+    })
+    db.add(relation)
+    db.commit()
+    db.refresh(relation)
+    return project_dict
+
+def get_project_info(db: Session, id: int):
+    project: models.Project = db.query(models.Project)\
+        .filter(models.Project.id == id).first()
+    if not project:
+        raise Exception('该项目不存在')
+    project_token = generate_item_token(project)
+    item = project.to_dict()
+    item.update({'project_token': project_token})
+    return item
+
+def get_project_list(db: Session, user_id: int):
+    relations = get_relations_by_user(db, user_id)
+    project_ids = [ r.project_id for r in relations ]
+    projects: List[models.Project] = db.query(models.Project)\
+        .filter(models.Project.id.in_(project_ids)).all()
+    res = []
+    for project in projects:
+        project_token = generate_item_token(project)
+        item = project.to_dict()
+        item.update({'project_token': project_token})
+        res.append(item)
+    return res
+
+def get_relations_by_user(db: Session, user_id: int):
+    relations: List[models.ProjectUserRelation] = db.query(models.ProjectUserRelation)\
+        .filter(models.ProjectUserRelation.user_id == user_id).all()
+    return relations
+
+def get_relations_by_project(db: Session, project_id: int):
+    relations: List[models.ProjectUserRelation] = db.query(models.ProjectUserRelation)\
+        .filter(models.ProjectUserRelation.project_id == project_id).all()
+    return relations

app/crud/roles.py

@@ -0,0 +1,10 @@
+import time
+from typing import List
+from app import models, schemas
+from sqlalchemy.orm import Session
+
+
+def get_role_info(db: Session, id: int):
+    role: models.Roles = db.query(models.Roles)\
+        .filter(models.Roles.id == id).first()
+    return role

app/crud/users.py

@@ -0,0 +1,175 @@
+import time
+import uuid
+from typing import List
+from app import models, schemas
+from sqlalchemy.orm import Session
+from werkzeug.security import check_password_hash, generate_password_hash
+from itsdangerous import BadSignature, SignatureExpired
+from itsdangerous import TimedJSONWebSignatureSerializer as Serializer
+from constants.constants import SECRET_KEY
+
+
+def verify_password(password_hash, password):
+    return check_password_hash(password_hash, password)
+
+# 生成新的user_token
+def generate_user_token(user: models.Users, expiration=3600 * 5):
+    s = Serializer(SECRET_KEY, expires_in=expiration)
+    return s.dumps({'user_id': user.id,'password':user.password}).decode('utf-8')
+
+# 验证Token方法
+def verify_user_token(db: Session, token: str):
+    s = Serializer(SECRET_KEY)
+    try:
+        data = s.loads(token)
+    except SignatureExpired:
+        raise Exception("user_token验证失败")
+    except BadSignature:
+        raise Exception("user_token验证失败")
+    user: models.Users = db.query(models.Users).filter(models.Users.id == data['user_id']).first()
+    if not user:
+        raise Exception("不存在此用户")
+    if not user.password == data['password']:
+        raise Exception("密码已被修改，请重新登陆")
+    return user
+
+def create_users(db: Session, item: schemas.UsersCreate):
+    check_1 = db.query(models.Users).filter(models.Users.name == item.name).first()
+    if check_1:
+        raise Exception('该用户已存在')
+    check_2 = db.query(models.Users).filter(models.Users.username == item.username).first()
+    if check_2:
+        raise Exception('该账号已存在')
+
+    user_code = str(uuid.uuid1()).replace('-','')
+    db_item = models.Users(**{
+        'name': item.name,
+        'code': user_code,
+        'username': item.username,
+        'password': generate_password_hash(bytes(item.password.encode('utf-8'))),
+        'create_time': int(time.time())
+    })
+    db.add(db_item)
+    db.commit()
+    db.refresh(db_item)
+    return db_item
+
+def login(db, item: schemas.LoginBase):
+    user: models.Users = db.query(models.Users).filter(models.Users.username == item.username).first()
+    if not user:
+        raise Exception('不存在此账号')
+    if not verify_password(user.password,item.password):
+        raise Exception('密码错误')
+    auth_token = generate_user_token(user)
+    res = user.to_dict()
+    res.update({'auth_token':auth_token})
+    return res
+
+def get_users_by_project(db: Session, project_id: int):
+    relation: List[models.ProjectUserRelation] = db.query(models.ProjectUserRelation)\
+        .filter(models.ProjectUserRelation.project_id == project_id).all()
+    user_role = { r.user_id:r.role_id for r in relation}
+    user_ids = list(user_role.keys())
+    roles: List[models.Roles] = db.query(models.Roles).all()
+    id_role = { r.id:r for r in roles}
+    users: List[models.Users] = db.query(models.Users)\
+        .filter(models.Users.id.in_(user_ids)).all()
+    res = []
+    for user in users:
+        if user.id == 1 and project_id != 1: continue
+        item = user.to_dict()
+        item.update({'role_name':id_role[user_role[user.id]].name})
+        res.append(item)
+    return res
+
+def retrieve_users_by_project(db: Session, project_id: int):
+    relation: List[models.ProjectUserRelation] = db.query(models.ProjectUserRelation)\
+        .filter(models.ProjectUserRelation.project_id == project_id).all()
+    now_user_ids = [ r.user_id for r in relation ]
+    users: List[models.Users] = db.query(models.Users)\
+        .filter(models.Users.id.notin_(now_user_ids)).all()
+    return users
+
+def add_users_to_project(db: Session, user_ids: List[int], project_id: int):
+    project: models.Project = db.query(models.Project).filter(models.Project.id == project_id).first()
+    if not project:
+        raise Exception('项目不存在')
+    exist_users = []
+    for user_id in user_ids:
+        check_user = db.query(models.Users).filter(models.Users.id == user_id).first()
+        if not check_user:
+            raise Exception('用户不存在')
+        realtion = db.query(models.ProjectUserRelation)\
+            .filter(models.ProjectUserRelation.project_id == project_id)\
+            .filter(models.ProjectUserRelation.user_id == user_id).first()
+        if realtion:
+            raise Exception('用户已加入项目,不可二次加入')
+        exist_users.append(user_id)
+    for user_id in exist_users:
+        db_item = models.ProjectUserRelation(**{
+            'user_id': user_id,
+            'project_id': project_id,
+            'role_id': 3 if project.type == 0 else 5
+        })
+        db.add(db_item)
+        db.commit()
+        db.refresh(db_item)
+
+def remove_project_users(db: Session, user_id: int, project_id: int):
+    project: models.Project = db.query(models.Project).filter(models.Project.id == project_id).first()
+    if not project:
+        raise Exception('项目不存在')
+    check_user = db.query(models.Users).filter(models.Users.id == user_id).first()
+    if not check_user:
+        raise Exception('用户不存在')
+    realtion = db.query(models.ProjectUserRelation)\
+        .filter(models.ProjectUserRelation.project_id == project_id)\
+        .filter(models.ProjectUserRelation.user_id == user_id).first()
+    if not realtion:
+        raise Exception('用户未加入此项目,不可移除')
+    db.query(models.ProjectUserRelation)\
+        .filter(models.ProjectUserRelation.project_id == project_id)\
+        .filter(models.ProjectUserRelation.user_id == user_id).delete()
+
+def set_user_to_admin(db: Session,user_id: int,project_id: int):
+    project: models.Project = db.query(models.Project).filter(models.Project.id == project_id).first()
+    if not project:
+        raise Exception('项目不存在')
+    check_user = db.query(models.Users).filter(models.Users.id == user_id).first()
+    if not check_user:
+        raise Exception('用户不存在')
+    realtion: models.ProjectUserRelation = db.query(models.ProjectUserRelation)\
+        .filter(models.ProjectUserRelation.project_id == project_id)\
+        .filter(models.ProjectUserRelation.user_id == user_id).first()
+    if not realtion:
+        raise Exception('用户未加入项目,不可设为管理员')
+    admin_role_id = 2 if project.type == 0 else 4
+    admin_realtion: models.ProjectUserRelation = db.query(models.ProjectUserRelation)\
+        .filter(models.ProjectUserRelation.project_id == project_id)\
+        .filter(models.ProjectUserRelation.role_id == admin_role_id).first()
+    if admin_realtion:
+        raise Exception('项目已存在管理员，请先移除原先管理员在设置新的管理员')
+    realtion.role_id = admin_role_id
+    db.commit()
+    db.flush()
+    db.refresh(realtion)
+    return realtion
+
+def remove_user_to_admin(db: Session,user_id: int,project_id: int):
+    project: models.Project = db.query(models.Project).filter(models.Project.id == project_id).first()
+    if not project:
+        raise Exception('项目不存在')
+    check_user = db.query(models.Users).filter(models.Users.id == user_id).first()
+    if not check_user:
+        raise Exception('用户不存在')
+    realtion: models.ProjectUserRelation = db.query(models.ProjectUserRelation)\
+        .filter(models.ProjectUserRelation.project_id == project_id)\
+        .filter(models.ProjectUserRelation.user_id == user_id).first()
+    if not realtion:
+        raise Exception('用户未加入项目')
+    admin_role_id = 3 if project.type == 0 else 5
+    realtion.role_id = admin_role_id
+    db.commit()
+    db.flush()
+    db.refresh(realtion)
+    return realtion

app/models/__init__.py

@@ -11,4 +11,9 @@ from app.models.jm_job_edge import *
 from app.models.af_task import *
 from app.models.af_job import *
 from app.models.af_run import *
-from app.models.relation import *
+from app.models.relation import *
+from app.models.users import *
+from app.models.project import *
+from app.models.roles import *
+from app.models.project_user_relation import *
+from app.models.data_table import *

app/models/data_table.py

@@ -0,0 +1,19 @@
+from sqlalchemy import Boolean, Column, ForeignKey, Integer, String
+
+from app.models.database import BaseModel
+
+
+class DataTable(BaseModel):
+    __tablename__ = "data_table"
+
+    id = Column(Integer, primary_key=True, index=True)
+    # 数据库名称
+    database_name = Column(String)
+    # 数据表名称
+    table_name = Column(String, nullable=False)
+    # 源（0:数据湖；1:ailab）
+    source = Column(Integer, nullable=False)
+    # 类型（0:被分享；1:自建；2:导入）
+    type = Column(Integer, nullable=False)
+    # 项目id
+    project_id = Column(Integer, nullable=False)

app/models/project.py

@@ -0,0 +1,17 @@
+from sqlalchemy import Boolean, Column, ForeignKey, Integer, String
+
+from app.models.database import BaseModel
+
+
+class Project(BaseModel):
+    __tablename__ = "project"
+
+    id = Column(Integer, primary_key=True, index=True)
+    # 项目名称
+    name = Column(String, nullable=False)
+    # 项目编码
+    code = Column(String, nullable=False)
+    # 项目类型（0:算法组；1:普通项目）
+    type = Column(Integer, nullable=False)
+    # 创建时间
+    create_time = Column(Integer, nullable=False)

app/models/project_user_relation.py

@@ -0,0 +1,15 @@
+from sqlalchemy import Boolean, Column, ForeignKey, Integer, String
+
+from app.models.database import BaseModel
+
+
+class ProjectUserRelation(BaseModel):
+    __tablename__ = "project_user_relation"
+
+    id = Column(Integer, primary_key=True, index=True)
+    # 用户id
+    user_id = Column(Integer, nullable=False)
+    # 项目id
+    project_id = Column(Integer, nullable=False)
+    # 角色id
+    role_id = Column(Integer, nullable=False)

app/models/roles.py

@@ -0,0 +1,13 @@
+from sqlalchemy import Boolean, Column, ForeignKey, Integer, String
+
+from app.models.database import BaseModel
+
+
+class Roles(BaseModel):
+    __tablename__ = "roles"
+
+    id = Column(Integer, primary_key=True, index=True)
+    # 角色名称
+    name = Column(String, nullable=False)
+    # 角色编码
+    code = Column(String, nullable=False)

app/models/users.py

@@ -0,0 +1,19 @@
+from sqlalchemy import Boolean, Column, ForeignKey, Integer, String
+
+from app.models.database import BaseModel
+
+
+class Users(BaseModel):
+    __tablename__ = "users"
+
+    id = Column(Integer, primary_key=True, index=True)
+    # 姓名
+    name = Column(String, nullable=False)
+    # 用户编码
+    code = Column(String, nullable=False)
+    # 用户名称
+    username = Column(String, nullable=False)
+    # 密码暗文
+    password = Column(String, nullable=False)
+    # 创建时间
+    create_time = Column(Integer, nullable=False)

app/routers/jm_job_log.py

@@ -5,6 +5,7 @@ from fastapi import APIRouter
 from fastapi import Depends, Query
 from sqlalchemy.orm import Session
 from app import page_help, schemas
+from app.common.decorators import verify_all
 
 import app.crud as crud
 from app.utils.send_util import get_job_run_status, get_task_log
@@ -109,7 +110,7 @@ def get_job_all_task(run_id: str, db: Session = Depends(get_db)):
     return res
 
 
-@router.get("/task_log/{job_id}/{af_run_id}/{task_id}")
+@router.get("/task_log/{job_id}/{af_run_id}/{task_id}", dependencies=[Depends(verify_all)])
 @web_try()
 @sxtimeit
 def get_job_task_log(job_id: str, af_run_id: str, task_id: str, db: Session = Depends(get_db)):

app/routers/job_info.py

@@ -1,4 +1,3 @@
-from pyexpat import model
 import time
 from typing import Optional
 from fastapi import APIRouter

app/routers/project.py

@@ -0,0 +1,42 @@
+import time
+from typing import Optional
+from fastapi import APIRouter
+from fastapi import Depends
+from sqlalchemy.orm import Session
+from app.utils.utils import *
+from utils.sx_time import sxtimeit
+from utils.sx_web import web_try
+from app.common.decorators import verify_user, verify_all, verify_super_admin
+
+from app import crud, get_db, get_page, schemas
+
+router = APIRouter(
+    prefix="/jpt/project",
+    tags=["project-项目管理"],
+)
+
+
+@router.post("/create_project", dependencies=[Depends(verify_super_admin)])
+@web_try()
+@sxtimeit
+def create_project(item: schemas.ProjectCreate, db: Session = Depends(get_db)):
+    return crud.create_project(db,item)
+
+@router.get("", dependencies=[Depends(verify_user)])
+@web_try()
+@sxtimeit
+def get_projects(user_id: int, db: Session = Depends(get_db)):
+    return crud.get_project_list(db,user_id)
+
+@router.get("/switch", dependencies=[Depends(verify_all)])
+@web_try()
+@sxtimeit
+def switch_project(project_id: int, db: Session = Depends(get_db)):
+    return crud.get_project_info(db,project_id)
+
+
+@router.get("/info", dependencies=[Depends(verify_all)])
+@web_try()
+@sxtimeit
+def get_project_info(project_id: int, db: Session = Depends(get_db)):
+    return crud.get_project_info(db,project_id)

app/routers/users.py

@@ -0,0 +1,70 @@
+import time
+from typing import List, Optional
+from fastapi import APIRouter
+from fastapi import Depends
+from sqlalchemy.orm import Session
+from app.utils.utils import *
+from utils.sx_time import sxtimeit
+from utils.sx_web import web_try
+from app.common.decorators import verify_user, verify_all, verify_super_admin, verify_admin
+from app import crud, get_db, get_page, schemas
+
+
+
+router = APIRouter(
+    prefix="/jpt/users",
+    tags=["users-用户管理"],
+)
+
+
+@router.post("/register")
+@web_try()
+@sxtimeit
+def create_user(item: schemas.UsersCreate, db: Session = Depends(get_db)):
+    return crud.create_users(db,item)
+
+@router.post("/login")
+@web_try()
+@sxtimeit
+def login(item: schemas.LoginBase, db: Session = Depends(get_db)):
+    return crud.login(db,item)
+
+
+@router.get("/project_users", dependencies=[Depends(verify_admin)])
+@web_try()
+@sxtimeit
+def get_users_by_project(project_id: int, db: Session = Depends(get_db)):
+    return crud.get_users_by_project(db,project_id)
+
+@router.get("/retrieve_users", dependencies=[Depends(verify_admin)])
+@web_try()
+@sxtimeit
+def retrieve_users_by_project(project_id: int, db: Session = Depends(get_db)):
+    return crud.retrieve_users_by_project(db,project_id)
+
+@router.post("/add_project_users", dependencies=[Depends(verify_admin)])
+@web_try()
+@sxtimeit
+def add_users_to_project(item: schemas.AddUsersToProject, db: Session = Depends(get_db)):
+    crud.add_users_to_project(db,item.user_ids,item.project_id)
+    return 'success'
+
+@router.delete("/remove_project_users", dependencies=[Depends(verify_admin)])
+@web_try()
+@sxtimeit
+def remove_project_users(item: schemas.RemoveUsersToProject, db: Session = Depends(get_db)):
+    crud.remove_project_users(db,item.user_id,item.project_id)
+    return 'success'
+
+@router.put("/set_user_to_admin", dependencies=[Depends(verify_super_admin)])
+@web_try()
+@sxtimeit
+def set_user_to_admin(item: schemas.SetUserToAdmin, db: Session = Depends(get_db)):
+    crud.set_user_to_admin(db,item.user_id,item.project_id)
+
+
+@router.put("/remove_user_to_admin", dependencies=[Depends(verify_super_admin)])
+@web_try()
+@sxtimeit
+def remove_user_to_admin(item: schemas.SetUserToAdmin, db: Session = Depends(get_db)):
+    crud.remove_user_to_admin(db,item.user_id,item.project_id)

app/schemas/__init__.py

@@ -13,4 +13,6 @@ from app.schemas.cron_expression import *
 from app.schemas.af_task import *
 from app.schemas.af_job import *
 from app.schemas.af_run import *
-from app.schemas.dag import *
+from app.schemas.dag import *
+from app.schemas.users import *
+from app.schemas.project import *

app/schemas/project.py

@@ -0,0 +1,18 @@
+from typing import List, Optional
+
+from pydantic import BaseModel
+
+class ProjectBase(BaseModel):
+    # 项目名称
+    name: str
+    # 用户id
+    user_id: int
+
+class ProjectCreate(ProjectBase):
+    class Config:
+        schema_extra = {
+            "example": {
+                "name": "blue_sky",
+                "user_id": 1
+            }
+        }

app/schemas/users.py

@@ -0,0 +1,70 @@
+from typing import List, Optional
+
+from pydantic import BaseModel
+
+class UsersBase(BaseModel):
+    # 姓名
+    name: str
+    # 用户名称
+    username: str
+    # 密码明文
+    password: str
+
+class UsersCreate(UsersBase):
+    class Config:
+        schema_extra = {
+            "example": {
+                "name": "wangyixiao",
+                "username": "xiaogeer",
+                "password": "Hello123!"
+            }
+        }
+
+class LoginBase(BaseModel):
+    username: str
+    password: str
+
+    class Config:
+        schema_extra = {
+            "example": {
+                "username": "xiaogeer",
+                "password": "Hello123!"
+            }
+        }
+
+
+class AddUsersToProject(BaseModel):
+    project_id: int
+    user_ids: List[int]
+
+    class Config:
+        schema_extra = {
+            "example": {
+                "project_id": 1,
+                "user_ids": [3,4]
+            }
+        }
+
+class RemoveUsersToProject(BaseModel):
+    project_id: int
+    user_id: int
+
+    class Config:
+        schema_extra = {
+            "example": {
+                "project_id": 1,
+                "user_id": 4
+            }
+        }
+
+class SetUserToAdmin(BaseModel):
+    project_id: int
+    user_id: int
+
+    class Config:
+        schema_extra = {
+            "example": {
+                "project_id": 1,
+                "user_id": 3
+            }
+        }

constants/constants.py

@@ -1,11 +1,13 @@
 DATASOURCES = {
-    0: 'mysql',
-    1: 'hive',
+    0: "mysql",
+    1: "hive",
 }
 
 
 CONSTANTS = {
-    'DATASOURCES': DATASOURCES
+    "DATASOURCES": DATASOURCES
 }
 
-RUN_STATUS = {"queued": 0, 'scheduled': 1, 'running': 1, 'success': 2, 'failed': 3, 'skipped': 3,'upstream_failed': 3}
+RUN_STATUS = {"queued": 0, "scheduled": 1, "running": 1, "success": 2, "failed": 3, "skipped": 3,"upstream_failed": 3}
+
+SECRET_KEY = "\x8c\xd1Lc\xe5\xda\x1bW\xc0\x82b\xca\xfe\x16i2\x04h\x04\x8e\xe4K\x93\x12"

server.py

@@ -15,6 +15,8 @@ import app.routers.dag as router_dag
 import app.routers.code_check as router_code_check
 import app.routers.jm_job_info as router_jm_job_info
 import app.routers.jm_job_log as router_jm_job_log
+import app.routers.users as router_users
+import app.routers.project as router_project
 from app.routers.run import router_af_run
 from app.routers.job import router_af_job
 from app.routers.task import router_af_task
@@ -34,7 +36,8 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-
+app.include_router(router_users.router)
+app.include_router(router_project.router)
 app.include_router(router_jjds.router)
 app.include_router(router_constants.router)
 app.include_router(router_job_info.router)