首次集成

app/common/decorators.py

@@ -1,76 +0,0 @@
-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
-from configs.globals import g
-
-async def verify_user(request: Request, user_token: str = Header(), db: Session = Depends(get_db)):
-    try:
-        user = crud.verify_user_token(db, user_token)
-        g.user_id = user.id
-    except Exception as e:
-        raise HTTPException(status_code=401, detail=str(e))
-
-async def verify_super_admin(request: Request, user_token: str = Header(), db: Session = Depends(get_db)):
-    try:
-        user = crud.verify_user_token(db, user_token)
-        g.user_id = user.id
-    except Exception as e:
-        raise HTTPException(status_code=401, detail=str(e))
-    if user.id != 1:
-        raise HTTPException(status_code=402, detail='该用户不拥有此权限')
-
-async 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)
-        g.user_id = user.id
-    except Exception as e:
-        raise HTTPException(status_code=401, detail=str(e))
-    try:
-        project = crud.verify_item_token(db, item_token)
-        g.project_id = project.id
-    except Exception as e:
-        raise HTTPException(status_code=403, 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=402, detail='该用户不属于此项目')
-    role = crud.get_role_info(db,project_role[project.id])
-
-async 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)
-        g.user_id = user.id
-    except Exception as e:
-        raise HTTPException(status_code=401, detail=str(e))
-    try:
-        project = crud.verify_item_token(db, item_token)
-        g.project_id = project.id
-    except Exception as e:
-        raise HTTPException(status_code=403, 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=402, detail='该用户不属于此项目')
-    role = crud.get_role_info(db,project_role[project.id])
-    if not role.code in ['726a51e45b4d11edbb4809c4df301a','9ff183445b4d11ed87db29f50d093a','eef984e65b4d11ed8cc491f9c82401']:
-        raise HTTPException(status_code=402, detail='该用户没有此接口的权限')
-
-async 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)
-        g.user_id = user.id
-    except Exception as e:
-        raise HTTPException(status_code=401, detail=str(e))
-    try:
-        project = crud.verify_item_token(db, item_token)
-        g.project_id = project.id
-    except Exception as e:
-        raise HTTPException(status_code=403, 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=402, detail='该用户不属于此项目')
-    role = crud.get_role_info(db,project_role[project.id])
-    if not role.code in ['726a51e45b4d11edbb4809c4df301a','9ff183445b4d11ed87db29f50d093a','026bd8bc5b4e11ed857e6b5ec5c8d6']:
-        raise HTTPException(status_code=402, detail='该用户没有此接口的权限')

app/common/security/auth.py

@@ -0,0 +1,43 @@
+import json
+from fastapi import Depends
+from fastapi.security import OAuth2PasswordBearer
+from app import schemas
+from app.utils.utils import decode_base64
+from configs.globals import g
+
+
+reuseable_oauth = OAuth2PasswordBearer(
+    tokenUrl="/jpt/auth/login",
+    scheme_name="JWT"
+)
+
+
+async def verify_super_admin(token: str = Depends(reuseable_oauth)) -> schemas.TokenData:
+    token_data_str = decode_base64(token)
+    token_data_dict = json.loads(token_data_str)
+    token_data = schemas.TokenData(**token_data_dict)
+    if token_data.role_id != '726a51e45b4d11edbb4809c4df301a':
+        raise Exception("暂无权限")
+    g.user_id = token_data.user_id
+    g.project_id = token_data.project_id
+    return token_data
+
+
+async def verify_special(token: str = Depends(reuseable_oauth)) -> schemas.TokenData:
+    token_data_str = decode_base64(token)
+    token_data_dict = json.loads(token_data_str)
+    token_data = schemas.TokenData(**token_data_dict)
+    if not token_data.role_id in ['726a51e45b4d11edbb4809c4df301a','9ff183445b4d11ed87db29f50d093a']:
+        raise Exception("暂无权限")
+    g.user_id = token_data.user_id
+    g.project_id = token_data.project_id
+    return token_data
+
+
+async def verify_users(token: str = Depends(reuseable_oauth)) -> schemas.TokenData:
+    token_data_str = decode_base64(token)
+    token_data_dict = json.loads(token_data_str)
+    token_data = schemas.TokenData(**token_data_dict)
+    g.user_id = token_data.user_id
+    g.project_id = token_data.project_id
+    return token_data

app/crud/__init__.py

@@ -12,7 +12,5 @@ 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 *
 from app.crud.data_table import *

app/crud/data_management.py

@@ -3,6 +3,7 @@ import time
 from typing import List
 from app import models, schemas
 from sqlalchemy.orm import Session
+from configs.globals import g
 
 def create_data_management(db: Session, item: schemas.DataManagementCreate, table_name: str, af_run_id: str):
     create_time: int = int(time.time())
@@ -11,8 +12,8 @@ def create_data_management(db: Session, item: schemas.DataManagementCreate, tabl
         'table_name': table_name,
         'create_time': create_time,
         'user_name': item.user_name,
-        'user_id': item.user_id,
-        'project_id': item.project_id,
+        'user_id': g.user_id,
+        'project_id': g.project_id,
         'af_run_id': af_run_id,
         'status': 1
     })

app/crud/data_table.py

@@ -17,7 +17,7 @@ def import_datalake(db: Session, item: schemas.ImportDataLake):
         'table_path': item.table_path,
         'source': 0,
         'type': 2,
-        'project_id': 1,
+        'project_id': g.project_id,
         'create_time': int(time.time()),
         'user_id': g.user_id
     })
@@ -101,7 +101,7 @@ def create_table(db: Session, item: schemas.CreateAilab):
         'table_name': table_name,
         'source': 1,
         'type': 1,
-        'project_id': item.project_id,
+        'project_id': g.project_id,
         'create_time': int(time.time()),
         'user_id': g.user_id
     })

app/crud/project.py

@@ -1,133 +0,0 @@
-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 JSONWebSignatureSerializer as jws
-from constants.constants import SECRET_KEY
-from configs.globals import g
-
-# 生成新的project_token
-def generate_item_token(project: models.Project):
-    s = jws(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 = jws(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_token = generate_item_token(db_item)
-    db_item.project_token = project_token
-    db.commit()
-    db.flush()
-    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 update_project(db: Session,item: schemas.ProjectUpdate):
-    db_item: models.Project = db.query(models.Project).filter(models.Project.id == item.project_id).first()
-    if not db_item:
-        raise Exception('项目不存在')
-    db_item.name = item.name
-    db.commit()
-    db.flush()
-    db.refresh(db_item)
-    return db_item
-
-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('该项目不存在')
-
-    return project
-
-def switch_project_by_user(db: Session,project_id: int,user_id: int):
-    project: models.Project = db.query(models.Project)\
-        .filter(models.Project.id == project_id).first()
-    if not project:
-        raise Exception('项目不存在')
-    relation: models.ProjectUserRelation = db.query(models.ProjectUserRelation)\
-        .filter(models.ProjectUserRelation.project_id == project_id)\
-        .filter(models.ProjectUserRelation.user_id == user_id).first()
-    role: models.Roles = db.query(models.Roles)\
-        .filter(models.Roles.id == relation.role_id).first()
-    project_token = generate_item_token(project)
-    project.project_token = project_token
-    db.commit()
-    db.flush()
-    db.refresh(project)
-    item = project.to_dict()
-    item.update({
-        'role_id': role.id,
-        'role_name': role.name,
-        'role_code': role.code,
-        })
-    return item
-
-def get_project_list(db: Session, user_id: int):
-    relations = get_relations_by_user(db, user_id)
-    roles: List[models.Roles] = db.query(models.Roles).all()
-    id_to_role = {r.id:r for r in roles}
-    id_to_relation = { r.project_id:r for r in relations }
-    projects: List[models.Project] = db.query(models.Project)\
-        .filter(models.Project.id.in_(id_to_relation.keys())).all()
-    res = []
-    for project in projects:
-        item = project.to_dict()
-        role = id_to_role[id_to_relation[project.id].role_id]
-        item.update({
-            'role_id': role.id,
-            'role_name': role.name,
-            'role_code': role.code,
-            })
-        res.append(item)
-    return res
-
-def get_share_projects(db: Session):
-    projects: List[models.Project] = db.query(models.Project)\
-        .filter(models.Project.type==1).all()
-    return projects
-
-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/users.py

@@ -1,188 +0,0 @@
-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 configs.globals import g
-from itsdangerous import BadSignature, SignatureExpired
-from itsdangerous import TimedJSONWebSignatureSerializer as Serializer
-from app.utils.utils import decode_base64
-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('该账号已存在')
-    item.password = decode_base64(item.password)
-    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: Session, item: schemas.LoginBase):
-    user: models.Users = db.query(models.Users).filter(models.Users.username == item.username).first()
-    if not user:
-        raise Exception('不存在此账号')
-    item.password = decode_base64(item.password)
-    if not verify_password(user.password,item.password):
-        raise Exception('密码错误')
-    auth_token = generate_user_token(user)
-    user.user_token = auth_token
-    db.commit()
-    db.flush()
-    db.refresh(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: 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: 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('用户未加入此项目,不可移除')
-    if realtion.user_id == g.user_id:
-        raise Exception('用户不能移除自己')
-    if realtion.role_id in [2,4]:
-        raise Exception('该用户为项目管理员，不可直接移除')
-    db.query(models.ProjectUserRelation)\
-        .filter(models.ProjectUserRelation.project_id == project_id)\
-        .filter(models.ProjectUserRelation.user_id == user_id).delete()
-    db.commit()
-    db.flush()
-
-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/routers/auth.py

@@ -0,0 +1,38 @@
+
+import json
+from typing import List
+from fastapi import Depends
+from fastapi import APIRouter
+from fastapi.security import OAuth2PasswordRequestForm
+from app import schemas
+from app.utils.utils import encode_base64
+from utils.sx_time import sxtimeit
+from utils.sx_web import web_try
+from configs.settings import config
+
+super_admin_role = config.get('PERMISSIONS', 'super_admin_role')
+special_project_id = config.get('PERMISSIONS', 'special_project_id')
+
+router = APIRouter(
+    prefix="/jpt/auth",
+    tags=["auth-接口文档生成token"],
+)
+
+@router.post("/switch")
+@web_try()
+@sxtimeit
+def switch_project(switch: schemas.SwitchProject):
+    if switch.project_id == special_project_id and super_admin_role in switch.role_ids:
+        return {"role_id": '726a51e45b4d11edbb4809c4df301a'}
+    elif switch.project_id == special_project_id:
+        return {"role_id": '9ff183445b4d11ed87db29f50d093a'}
+    else:
+        return {"role_id": '026bd8bc5b4e11ed857e6b5ec5c8d6'}
+
+@router.post("/login",response_model=schemas.Token)
+async def login_for_access_token(form_data: OAuth2PasswordRequestForm = Depends()):
+    user_id, project_id = form_data.username, form_data.password
+    token_data = {"user_id": user_id,"project_id": project_id, "role_id": "726a51e45b4d11edbb4809c4df301a"}
+    token_data_str =json.dumps(token_data)
+    access_token = encode_base64(token_data_str).replace('\n','')
+    return {"access_token": access_token, "token_type": "bearer"}

app/routers/code_check.py

@@ -5,7 +5,7 @@ from typing import Optional
 from fastapi import APIRouter
 from fastapi import Depends
 from app import schemas
-from app.common.decorators import verify_all
+from app.common.security.auth import verify_users
 from utils.sx_time import sxtimeit
 from utils.sx_web import web_try
 from pylint import epylint
@@ -17,10 +17,10 @@ router = APIRouter(
     tags=["code_check-代码校验"],
 )
 
-@router.post("/", dependencies=[Depends(verify_all)])
+@router.post("/")
 @web_try()
 @sxtimeit
-def code_check(code: str, code_type: str):
+def code_check(code: str, code_type: str, token_data: schemas.TokenData = Depends(verify_users)):
     res = []
     if code_type == "python":
         file = tempfile.NamedTemporaryFile(delete=False, mode='w')

app/routers/constants.py

@@ -2,12 +2,12 @@
 from fastapi import Depends
 from sqlalchemy.orm import Session
 from fastapi import APIRouter
-from app.common.decorators import verify_all
+from app.common.security.auth import verify_users
 from constants.constants import CONSTANTS
 from utils import *
 import app.crud as crud
 
-from app import get_db
+from app import get_db, schemas
 
 router = APIRouter(
     prefix="/jpt/constants",
@@ -19,21 +19,21 @@ router = APIRouter(
 def format_constants(constants: dict):
     return [{'id': k, 'value': v} for k, v in constants.items()]
 
-@router.get("/datasources", dependencies=[Depends(verify_all)])
+@router.get("/datasources")
 @web_try()
 @sxtimeit
-def get_datasources():
+def get_datasources(token_data: schemas.TokenData = Depends(verify_users)):
     return format_constants(CONSTANTS['DATASOURCES'])
 
 
-@router.get("/", dependencies=[Depends(verify_all)])
+@router.get("/")
 @web_try()
 @sxtimeit
-def get_constants(type: str,db: Session = Depends(get_db)):
+def get_constants(type: str,token_data: schemas.TokenData = Depends(verify_users), db: Session = Depends(get_db)):
     return crud.get_constant_list(db, type)
 
-@router.delete("/", dependencies=[Depends(verify_all)])
+@router.delete("/")
 @web_try()
 @sxtimeit
-def delete_constants(type: str, value: str, db: Session = Depends(get_db)):
+def delete_constants(type: str, value: str, token_data: schemas.TokenData = Depends(verify_users), db: Session = Depends(get_db)):
     return crud.delete_constant(db, type, value)

app/routers/dag.py

@@ -2,7 +2,7 @@ import json
 from sqlalchemy.orm import Session
 from fastapi import Depends
 from fastapi import APIRouter
-from app.common.decorators import verify_all
+from app.common.security.auth import verify_users
 from app.services.dag import dag_job_submit, get_tmp_table_name
 from app import crud, models, schemas
 from app.utils.send_util import get_job_run_status, get_task_log
@@ -17,18 +17,17 @@ router = APIRouter(
     tags=["dag-dag管理"],
 )
 
-# , dependencies=[Depends(verify_all)]
 @router.post("/execute")
 @web_try()
 @sxtimeit
-def execute_dag(dag: schemas.Dag, db: Session = Depends(get_db)):
+def execute_dag(dag: schemas.Dag, token_data: schemas.TokenData = Depends(verify_users), db: Session = Depends(get_db)):
     af_job = dag_job_submit(dag.dag_uuid, dag.dag_script,db)
     return af_job
 
 @router.get("/debug_execute")
 @web_try()
 @sxtimeit
-def debug_execute(dag_uuid: str, db: Session = Depends(get_db)):
+def debug_execute(dag_uuid: str, token_data: schemas.TokenData = Depends(verify_users), db: Session = Depends(get_db)):
     relation = crud.get_dag_af_id(db,dag_uuid, 'debug')
     if relation is None:
         return False
@@ -37,7 +36,7 @@ def debug_execute(dag_uuid: str, db: Session = Depends(get_db)):
 @router.get("/debug_status")
 @web_try()
 @sxtimeit
-def get_dag_debug_status(dag_uuid: str, db: Session = Depends(get_db)):
+def get_dag_debug_status(dag_uuid: str, token_data: schemas.TokenData = Depends(verify_users), db: Session = Depends(get_db)):
     relation = crud.get_dag_af_id(db,dag_uuid, 'debug')
     af_job_run = crud.get_airflow_run_once_debug_mode(db,relation.af_id)
     job_run_res = get_job_run_status(af_job_run.id)
@@ -62,7 +61,7 @@ def get_dag_debug_status(dag_uuid: str, db: Session = Depends(get_db)):
 @router.get("/node_log")
 @web_try()
 @sxtimeit
-def get_dag_debug_status(dag_uuid: str, node_id: str,db: Session = Depends(get_db)):
+def get_dag_debug_status(dag_uuid: str, node_id: str, token_data: schemas.TokenData = Depends(verify_users), db: Session = Depends(get_db)):
     relation = crud.get_dag_af_id(db,dag_uuid, 'debug')
     af_job_run = crud.get_airflow_run_once_debug_mode(db,relation.af_id)
     af_job = crud.get_airflow_job_once(db, af_job_run.job_id)
@@ -78,7 +77,7 @@ def get_dag_debug_status(dag_uuid: str, node_id: str,db: Session = Depends(get_d
 @router.get("/node_result")
 @web_try()
 @sxtimeit
-def get_dag_debug_result(dag_uuid: str,node_id: str,out_pin: int ,db: Session = Depends(get_db)):
+def get_dag_debug_result(dag_uuid: str, node_id: str, out_pin: int , token_data: schemas.TokenData = Depends(verify_users), db: Session = Depends(get_db)):
     table_name = get_tmp_table_name(dag_uuid, node_id, str(out_pin), db)
     result = hiveDs.get_preview_data(table_name,500)
     return result

app/routers/data_management.py

@@ -7,7 +7,7 @@ from fastapi import APIRouter
 from fastapi import Depends
 from sqlalchemy.orm import Session
 from app import schemas
-from app.common.decorators import verify_all
+from app.common.security.auth import verify_users
 
 import app.crud as crud
 from app.services.dag import get_tmp_table_name
@@ -26,13 +26,12 @@ router = APIRouter(
     tags=["datamanagement-数据管理"],
 )
 
-# , dependencies=[Depends(verify_all)]
 @router.post("/")
 @web_try()
 @sxtimeit
-def create_data_management(item: schemas.DataManagementCreate, db: Session = Depends(get_db)):
+def create_data_management(item: schemas.DataManagementCreate, token_data: schemas.TokenData = Depends(verify_users), db: Session = Depends(get_db)):
     current_time = int(time.time())
-    table_name = f'project{item.project_id.lower()}_user{item.user_id.lower()}_{item.name.lower()}_{current_time}'
+    table_name = f'project{token_data.project_id.lower()}_user{token_data.user_id.lower()}_{item.name.lower()}_{current_time}'
     tmp_table_name = get_tmp_table_name(item.dag_uuid, item.node_id, str(item.out_pin), db)
     af_run_res = data_transfer_run(database_name+'.'+tmp_table_name, database_name+'.'+table_name)
     af_run = af_run_res['data'] if 'data' in af_run_res.keys() else None
@@ -48,8 +47,8 @@ def create_data_management(item: schemas.DataManagementCreate, db: Session = Dep
 @router.get("/")
 @web_try()
 @sxtimeit
-def get_data_managements(user_id: str, project_id: str, db: Session = Depends(get_db)):
-    res = crud.get_data_managements(db, user_id, project_id)
+def get_data_managements(token_data: schemas.TokenData = Depends(verify_users), db: Session = Depends(get_db)):
+    res = crud.get_data_managements(db, token_data.user_id, token_data.project_id)
     data_management_list = []
     for item in res:
         item.table_name = f'{database_name}.{item.table_name}'
@@ -59,7 +58,7 @@ def get_data_managements(user_id: str, project_id: str, db: Session = Depends(ge
 @router.get("/info")
 @web_try()
 @sxtimeit
-def get_data_management_info(id: int, db: Session = Depends(get_db)):
+def get_data_management_info(id: int, token_data: schemas.TokenData = Depends(verify_users), db: Session = Depends(get_db)):
     item = crud.get_data_management_info(db, id)
     if item.status == 1:
         transfer_run_res = get_data_transfer_run_status(item.af_run_id)
@@ -70,33 +69,17 @@ def get_data_management_info(id: int, db: Session = Depends(get_db)):
     item.table_name = f'{database_name}.{item.table_name}'
     return item
 
-
-@router.get("/local")
-@web_try()
-@sxtimeit
-def get_local_data_managements(db: Session = Depends(get_db)):
-    t_list = hiveDs.list_tables()
-    res = [f'{database_name}.{t}' for t in t_list]
-    return res
-
-@router.get("/table_schema")
-@web_try()
-@sxtimeit
-def get_data_managements_schema(table_name: str, db: Session = Depends(get_db)):
-    table_name = table_name.split('.')[-1]
-    return hiveDs.get_table_schema(table_name)
-
 @router.delete("/")
 @web_try()
 @sxtimeit
-def delete_data_management(data_management_id: int, db: Session = Depends(get_db)):
+def delete_data_management(data_management_id: int, token_data: schemas.TokenData = Depends(verify_users), db: Session = Depends(get_db)):
     data_management = crud.delete_data_management(db, data_management_id)
     return data_management
 
 @router.get("/table_content")
 @web_try()
 @sxtimeit
-def get_data_management_content(table_name: str, page: Optional[int] = 0, size: Optional[int] = 100, db: Session = Depends(get_db)):
+def get_data_management_content(table_name: str, page: Optional[int] = 0, size: Optional[int] = 100, token_data: schemas.TokenData = Depends(verify_users), db: Session = Depends(get_db)):
     table_name = table_name.split('.')[-1]
     result = hiveDs.get_preview_data(table_name,limit=size,page=page)
     data_num = hiveDs.get_data_num(table_name)

app/routers/datax_json.py

@@ -3,8 +3,7 @@ from fastapi import APIRouter
 from fastapi import Depends, Body
 from sqlalchemy.orm import Session
 from app import schemas
-from app.common.decorators import verify_all
-
+from app.common.security.auth import verify_users
 import app.crud as crud
 from utils.sx_time import sxtimeit
 from utils.sx_web import web_try
@@ -19,12 +18,11 @@ router = APIRouter(
 )
 
 
-@router.post("/", dependencies=[Depends(verify_all)])
+@router.post("/")
 @web_try()
 @sxtimeit
 def build_datax_json(param: schemas.DataXJsonParam=Body(
     examples = schemas.DataXJsonParam.Config.schema_extra['examples']
-), db: Session = Depends(get_db)):
-    print(param)
+), token_data: schemas.TokenData = Depends(verify_users), db: Session = Depends(get_db)):
     return crud.generate_datax_json(db, param)
 

app/routers/files.py

@@ -2,7 +2,7 @@ import io
 import json
 import time
 from datetime import datetime, timedelta, timezone
-from app.common.decorators import verify_all
+from app.common.security.auth import verify_users
 import app.crud as crud
 from fastapi import APIRouter, File, UploadFile, Form, Depends
 from sqlalchemy.orm import Session
@@ -11,7 +11,7 @@ from utils.sx_time import sxtimeit
 from utils.sx_web import web_try
 from app.common.minio import minio_client
 
-from app import get_db
+from app import get_db, schemas
 
 
 
@@ -21,31 +21,31 @@ router = APIRouter(
 )
 
 
-@router.delete("/dag", dependencies=[Depends(verify_all)])
+@router.delete("/dag")
 @web_try()
 @sxtimeit
-def delete_dag_file(uri: str,db: Session = Depends(get_db)):
+def delete_dag_file(uri: str, token_data: schemas.TokenData = Depends(verify_users), db: Session = Depends(get_db)):
     res = crud.get_jm_homework_by_dag_url(db,uri)
     if len(res) == 0:
         minio_client.del_file(uri)
     else:
         raise Exception("该算子正在被作业使用，不可删除")
 
-@router.post("/upload_file", dependencies=[Depends(verify_all)])
+@router.post("/upload_file")
 @web_try()
 @sxtimeit
-def upload_file(file: UploadFile = File(...), project_id: str=Form(...), file_type: str=Form(...)):
+def upload_file(file: UploadFile = File(...), file_type: str=Form(...), token_data: schemas.TokenData = Depends(verify_users)):
     print("UploadFile-->",file.filename)
     file_name = str(int(time.time()))+'_'+file.filename
-    url = minio_client.put_byte_file(f"{project_id}/{file_type}/"+file_name, file.file.read())
+    url = minio_client.put_byte_file(f"{token_data.project_id}/{file_type}/"+file_name, file.file.read())
     return url
 
 
-@router.get("/directory", dependencies=[Depends(verify_all)])
+@router.get("/directory")
 @web_try()
 @sxtimeit
-def get_directory(project_id: str, user_id: str, file_type: str):
-    files = minio_client.ls_file(f'{project_id}/{file_type}/')
+def get_directory(file_type: str, token_data: schemas.TokenData = Depends(verify_users)):
+    files = minio_client.ls_file(f'{token_data.project_id}/{file_type}/')
     res = []
     td = timedelta(hours=8)
     tz = timezone(td)
@@ -58,10 +58,10 @@ def get_directory(project_id: str, user_id: str, file_type: str):
     res.sort(key=lambda x: x['timestamp'],reverse=True)
     return res
 
-@router.get("/dag_content", dependencies=[Depends(verify_all)])
+@router.get("/dag_content")
 @sxtimeit
 @web_try()
-def get_dag_content(uri: str):
+def get_dag_content(uri: str, token_data: schemas.TokenData = Depends(verify_users)):
     file = minio_client.get_file(uri)
     if len(file) == 0:
         raise Exception('No file found')

app/routers/jm_homework.py

@@ -1,22 +1,13 @@
-from re import S
-from typing import Optional
-from fastapi import APIRouter
-
-from fastapi import Depends
+from fastapi import APIRouter, Depends
 from sqlalchemy.orm import Session
-from app import schemas
-from app.common.decorators import verify_all
-from app.common.hive import hiveDs
-from app.crud import jm_homework
+from app.common.security.auth import verify_users
 from app.services.jm_homework import create_jm_homework_services, update_jm_homework_service
 from app.services.jm_job import red_dag_and_format
 from utils.sx_time import sxtimeit
 from utils.sx_web import web_try
-from fastapi_pagination import Page, add_pagination, paginate, Params
 import app.crud as crud
-from app import get_db
-from configs.settings import DefaultOption, config
-DATABASE_NAME = config.get('HIVE', 'DATABASE_NAME')
+from app import schemas, get_db
+
 
 
 
@@ -25,34 +16,34 @@ router = APIRouter(
     tags=["jm_homework-作业管理"],
 )
 
-@router.post("/", dependencies=[Depends(verify_all)])
+@router.post("/")
 @web_try()
 @sxtimeit
-def create_jm_homework(item: schemas.JmHomeworkCreate, db: Session = Depends(get_db)):
+def create_jm_homework(item: schemas.JmHomeworkCreate, token_data: schemas.TokenData = Depends(verify_users), db: Session = Depends(get_db)):
     return create_jm_homework_services(db, item)
 
-@router.get("/", dependencies=[Depends(verify_all)])
+@router.get("/")
 @web_try()
 @sxtimeit
-def get_jm_homeworks(project_id: str, db: Session = Depends(get_db)):
-    return crud.get_jm_homeworks(db, project_id)
+def get_jm_homeworks(token_data: schemas.TokenData = Depends(verify_users), db: Session = Depends(get_db)):
+    return crud.get_jm_homeworks(db, token_data.project_id)
 
-@router.get("/info", dependencies=[Depends(verify_all)])
+@router.get("/info")
 @web_try()
 @sxtimeit
-def get_jm_homework_info(homework_id: str, db: Session = Depends(get_db)):
+def get_jm_homework_info(homework_id: str, token_data: schemas.TokenData = Depends(verify_users), db: Session = Depends(get_db)):
     return crud.get_jm_homework_info(db, homework_id)
 
-@router.put("/", dependencies=[Depends(verify_all)])
+@router.put("/")
 @web_try()
 @sxtimeit
-def update_jm_homework(jm_id: int, update_item: schemas.JmHomeworkUpdate, db: Session = Depends(get_db)):
+def update_jm_homework(jm_id: int, update_item: schemas.JmHomeworkUpdate, token_data: schemas.TokenData = Depends(verify_users), db: Session = Depends(get_db)):
     return update_jm_homework_service(db, jm_id, update_item)
 
-@router.delete("/", dependencies=[Depends(verify_all)])
+@router.delete("/")
 @web_try()
 @sxtimeit
-def delete_jm_homework(jm_id: int, db: Session = Depends(get_db)):
+def delete_jm_homework(jm_id: int, token_data: schemas.TokenData = Depends(verify_users), db: Session = Depends(get_db)):
     jm_log_infos = crud.get_jm_job_infos(db)
     jm_job_ids = [jm_job.id for jm_job in jm_log_infos]
     res = crud.find_by_homework_and_job(db, jm_job_ids,jm_id)
@@ -65,28 +56,4 @@ def delete_jm_homework(jm_id: int, db: Session = Depends(get_db)):
 def get_test_dag(db: Session = Depends(get_db)):
     jm_homework = crud.get_jm_homework_info(db, 83)
     res = red_dag_and_format(jm_homework, db)
-    return res
-
-@router.get("/local_source", dependencies=[Depends(verify_all)])
-@web_try()
-@sxtimeit
-def get_local_source():
-    return [{
-            'database_name': DATABASE_NAME,
-            'datasource': "hive",
-            'datasource_name': DATABASE_NAME,
-            'id': -1
-    }]
-
-@router.get("/local_source_table", dependencies=[Depends(verify_all)])
-@web_try()
-@sxtimeit
-def get_local_source_table():
-    t_list = hiveDs.list_tables()
-    return t_list
-
-@router.get("/local_source_table_schema", dependencies=[Depends(verify_all)])
-@web_try()
-@sxtimeit
-def get_local_source_table_schema(table_name: str, db: Session = Depends(get_db)):
-    return hiveDs.get_table_schema(table_name)
+    return res

app/routers/jm_job_info.py

@@ -9,8 +9,7 @@ from fastapi import APIRouter
 from fastapi import Depends
 from sqlalchemy.orm import Session
 from app import models, schemas
-from app.common.decorators import verify_all
-
+from app.common.security.auth import verify_users
 import app.crud as crud
 from app.schemas import cron_expression
 from app.services.jm_job import on_off_control
@@ -30,17 +29,17 @@ router = APIRouter(
     tags=["jm_job_info-定时任务管理"],
 )
 
-@router.post("/", dependencies=[Depends(verify_all)])
+@router.post("/")
 @web_try()
 @sxtimeit
-def create_jm_job_info(item: schemas.JmJobInfoCreate, db: Session = Depends(get_db)):
+def create_jm_job_info(item: schemas.JmJobInfoCreate, token_data: schemas.TokenData = Depends(verify_users), db: Session = Depends(get_db)):
     return create_jm_job_info_services(db, item)
 
 
-@router.get("/", dependencies=[Depends(verify_all)])
+@router.get("/")
 @web_try()
 @sxtimeit
-def get_jm_job_infos(db: Session = Depends(get_db)):
+def get_jm_job_infos(token_data: schemas.TokenData = Depends(verify_users), db: Session = Depends(get_db)):
     res_list = []
     jm_job_list = crud.get_jm_job_infos(db)
     jm_job_ids = [job.id for job in jm_job_list]
@@ -69,10 +68,10 @@ def get_jm_job_infos(db: Session = Depends(get_db)):
         res_list.append(jm_job_dict)
     return res_list
 
-@router.get("/info", dependencies=[Depends(verify_all)])
+@router.get("/info")
 @web_try()
 @sxtimeit
-def get_jm_job_info(jm_job_id: int, db: Session = Depends(get_db)):
+def get_jm_job_info(jm_job_id: int, token_data: schemas.TokenData = Depends(verify_users), db: Session = Depends(get_db)):
     jm_job = crud.get_jm_job_info(db,jm_job_id)
     jm_job_dict = jm_job.to_dict()
     nodes = crud.get_one_job_nodes(db,jm_job_id)
@@ -91,13 +90,13 @@ def get_jm_job_info(jm_job_id: int, db: Session = Depends(get_db)):
     })
     return jm_job_dict
 
-@router.put("/", dependencies=[Depends(verify_all)])
+@router.put("/")
 @web_try()
 @sxtimeit
-def update_jm_job_info(item: schemas.JmJobInfoUpdate, db: Session = Depends(get_db)):
+def update_jm_job_info(item: schemas.JmJobInfoUpdate, token_data: schemas.TokenData = Depends(verify_users), db: Session = Depends(get_db)):
     return update_jm_job_info_services(db, item)
 
-@router.delete("/", dependencies=[Depends(verify_all)])
+@router.delete("/")
 @web_try()
 @sxtimeit
 def delete_jm_job_info(jm_job_id: int, db: Session = Depends(get_db)):
@@ -108,13 +107,13 @@ def delete_jm_job_info(jm_job_id: int, db: Session = Depends(get_db)):
     send_delete('/af/af_job', relation.af_id)
     return crud.delete_jm_job_info(db,jm_job_id)
 
-@router.put("/status", dependencies=[Depends(verify_all)])
+@router.put("/status")
 @web_try()
 @sxtimeit
-def update_jm_job_status(item: schemas.JmJobInfoStatusUpdate, db: Session = Depends(get_db)):
+def update_jm_job_status(item: schemas.JmJobInfoStatusUpdate, token_data: schemas.TokenData = Depends(verify_users), db: Session = Depends(get_db)):
     return update_jm_job_status_services(db, item.id, item.status)
 
-@router.post("/execute/{jm_job_id}", dependencies=[Depends(verify_all)])
+@router.post("/execute/{jm_job_id}")
 @web_try()
 @sxtimeit
 def execute_jm_job(jm_job_id: int, db: Session = Depends(get_db)):
@@ -125,10 +124,10 @@ def execute_jm_job(jm_job_id: int, db: Session = Depends(get_db)):
     return res['data']
 
 
-@router.get("/api/{jm_job_id}", dependencies=[Depends(verify_all)])
+@router.get("/api/{jm_job_id}")
 @web_try()
 @sxtimeit
-def copy_api_path(jm_job_id: int, db: Session = Depends(get_db)):
+def copy_api_path(jm_job_id: int, token_data: schemas.TokenData = Depends(verify_users), db: Session = Depends(get_db)):
     initial = str(jm_job_id).encode('utf-8')
     encryption_id = base64.b64encode(initial).decode('utf-8')
     return f'/jpt/jm_job_info/api_execute/{encryption_id}'
@@ -150,18 +149,18 @@ def api_execute_jm_job(encryption_id: str, db: Session = Depends(get_db)):
     return res['data']
 
 
-@router.post("/cron_expression", dependencies=[Depends(verify_all)])
+@router.post("/cron_expression")
 @web_try()
 @sxtimeit
-def get_cron_expression(cron_expression: schemas.CronExpression):
+def get_cron_expression(cron_expression: schemas.CronExpression, token_data: schemas.TokenData = Depends(verify_users), ):
     print(cron_expression)
     cron = joint_cron_expression(cron_expression)
     return cron
 
-@router.get("/cron_next_execute", dependencies=[Depends(verify_all)])
+@router.get("/cron_next_execute")
 @web_try()
 @sxtimeit
-def get_cron_next_execute(cron_expression: str):
+def get_cron_next_execute(cron_expression: str, token_data: schemas.TokenData = Depends(verify_users), ):
     execute_list = run_get_next_time(cron_expression)
     return execute_list
 

app/routers/jm_job_log.py

@@ -5,8 +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
-
+from app.common.security.auth import verify_users
 import app.crud as crud
 from app.utils.send_util import get_job_run_status, get_task_log
 from constants.constants import RUN_STATUS
@@ -25,10 +24,10 @@ router = APIRouter(
 
 
 
-@router.get("/", dependencies=[Depends(verify_all)])
+@router.get("/")
 @web_try()
 @sxtimeit
-def get_job_logs(job_id: int = None, params: Params=Depends(get_page), db: Session = Depends(get_db)):
+def get_job_logs(job_id: int = None, params: Params=Depends(get_page), token_data: schemas.TokenData = Depends(verify_users), db: Session = Depends(get_db)):
     jm_job_list = []
     # 是否有任务筛选
     if job_id is not None:
@@ -63,10 +62,10 @@ def get_job_logs(job_id: int = None, params: Params=Depends(get_page), db: Sessi
         res.append(log)
     return page_help(res,params['page'],params['size'],total)
 
-@router.get("/all_task", dependencies=[Depends(verify_all)])
+@router.get("/all_task")
 @web_try()
 @sxtimeit
-def get_job_all_task(run_id: str, db: Session = Depends(get_db)):
+def get_job_all_task(run_id: str, token_data: schemas.TokenData = Depends(verify_users), db: Session = Depends(get_db)):
     af_job_run = crud.get_airflow_run_once(db, run_id)
     af_job = crud.get_airflow_job_once(db, af_job_run.job_id)
     tasks = list(af_job.tasks) if len(list(af_job.tasks))>0 else []
@@ -110,20 +109,20 @@ 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}", dependencies=[Depends(verify_all)])
+@router.get("/task_log/{job_id}/{af_run_id}/{task_id}")
 @web_try()
 @sxtimeit
-def get_job_task_log(job_id: str, af_run_id: str, task_id: str, db: Session = Depends(get_db)):
+def get_job_task_log(job_id: str, af_run_id: str, task_id: str, token_data: schemas.TokenData = Depends(verify_users), db: Session = Depends(get_db)):
     res = get_task_log(job_id, af_run_id, task_id)
     log = res['data'] if 'data' in res else None
     if log:
         log['status'] = RUN_STATUS[log['status']] if log['status'] else 0
     return log
 
-@router.get("/logs_status/{ids}", dependencies=[Depends(verify_all)])
+@router.get("/logs_status/{ids}")
 @web_try()
 @sxtimeit
-def get_job_log_status(ids: str):
+def get_job_log_status(ids: str, token_data: schemas.TokenData = Depends(verify_users)):
     run_ids = ids.split(',')
     id_to_status = {}
     for run_id in run_ids:

app/routers/job_info.py

@@ -5,8 +5,7 @@ from fastapi import APIRouter
 from fastapi import Depends
 from sqlalchemy.orm import Session
 from app import models, page_help, schemas
-from app.common.decorators import verify_all
-
+from app.common.security.auth import verify_users
 import app.crud as crud
 from app.crud import job_info
 from app.services.datax import datax_create_job, datax_update_job, on_off_control
@@ -29,22 +28,22 @@ router = APIRouter(
 )
 
 
-@router.post("/", dependencies=[Depends(verify_all)])
+@router.post("/")
 @web_try()
 @sxtimeit
-def create_job_info(item: schemas.JobInfoCreate, db: Session = Depends(get_db)):
+def create_job_info(item: schemas.JobInfoCreate, token_data: schemas.TokenData = Depends(verify_users), db: Session = Depends(get_db)):
     return create_job_info_services(db,item)
 
-@router.get("/", dependencies=[Depends(verify_all)])
+@router.get("/")
 @web_try()
 @sxtimeit
-def get_job_infos(params: Params=Depends(get_page), db: Session = Depends(get_db)):
+def get_job_infos(params: Params=Depends(get_page), token_data: schemas.TokenData = Depends(verify_users), db: Session = Depends(get_db)):
     return page_help(crud.get_job_infos(db),params['page'],params['size'])
 
-@router.get("/info", dependencies=[Depends(verify_all)])
+@router.get("/info")
 @web_try()
 @sxtimeit
-def get_job_info(job_id: int, db: Session = Depends(get_db)):
+def get_job_info(job_id: int, token_data: schemas.TokenData = Depends(verify_users), db: Session = Depends(get_db)):
     job_info = crud.get_job_info(db, job_id)
     job_info_dict = job_info.to_dict()
     cron_select_type, cron_expression = job_info_dict['cron_select_type'], job_info_dict['job_cron']
@@ -67,39 +66,39 @@ def get_job_info(job_id: int, db: Session = Depends(get_db)):
         })
     return job_info_dict
 
-@router.put("/{id}", dependencies=[Depends(verify_all)])
+@router.put("/{id}")
 @web_try()
 @sxtimeit
-def update_datasource(id: int, update_item: schemas.JobInfoUpdate, db: Session = Depends(get_db)):
+def update_datasource(id: int, update_item: schemas.JobInfoUpdate, token_data: schemas.TokenData = Depends(verify_users), db: Session = Depends(get_db)):
     return update_job_info_services(db, id, update_item)
 
-@router.put("/update_trigger_status/", dependencies=[Depends(verify_all)])
+@router.put("/update_trigger_status/")
 @web_try()
 @sxtimeit
-def update_trigger_status(item: schemas.JobInfoTriggerStatus, db: Session = Depends(get_db)):
-    job_info = crud.get_job_info(db, item.id)
+def update_trigger_status(item: schemas.JobInfoTriggerStatus, token_data: schemas.TokenData = Depends(verify_users), db: Session = Depends(get_db)):
+    job_info: models.JobInfo = crud.get_job_info(db, item.id)
     relation = crud.get_af_id(db, job_info.id, 'datax')
     job_info.trigger_status = item.trigger_status
     on_off_control(relation.af_id, item.trigger_status)
     job_info = crud.update_job_trigger_status(db, item.id, item.trigger_status)
     return job_info
 
-@router.delete("/{job_id}", dependencies=[Depends(verify_all)])
+@router.delete("/{job_id}")
 @web_try()
 @sxtimeit
-def delete_job_info(job_id: int, db: Session = Depends(get_db)):
-    jm_job = crud.get_job_info(db, job_id)
+def delete_job_info(job_id: int, token_data: schemas.TokenData = Depends(verify_users), db: Session = Depends(get_db)):
+    jm_job: models.JobInfo = crud.get_job_info(db, job_id)
     if jm_job.trigger_status == 1:
         raise Exception('任务未停用，不可删除')
     relation = crud.get_af_id(db, job_id, 'datax')
     send_delete('/af/af_job', relation.af_id)
     return crud.delete_job_info(db, job_id)
 
-@router.post("/execute", dependencies=[Depends(verify_all)])
+@router.post("/execute")
 @web_try()
 @sxtimeit
-def execute_job_info(job_id: int, db: Session = Depends(get_db)):
-    jm_job = crud.get_job_info(db, job_id)
+def execute_job_info(job_id: int, token_data: schemas.TokenData = Depends(verify_users), db: Session = Depends(get_db)):
+    jm_job: models.JobInfo = crud.get_job_info(db, job_id)
     if jm_job.trigger_status == 0:
         raise Exception('任务已被停用')
     res = execute_job_services(db, job_id)

app/routers/job_jdbc_datasource.py

@@ -1,18 +1,14 @@
 from typing import Optional
-from fastapi import APIRouter
-
-from fastapi import Depends
+from fastapi import APIRouter, Depends
 from sqlalchemy.orm import Session
-from app import schemas
-from app.common.decorators import verify_admin, verify_all, verify_special, verify_super_admin
-
 import app.crud as crud
 from utils.sx_time import sxtimeit
 from utils.sx_web import web_try
 from fastapi_pagination import Page, add_pagination, paginate, Params
-
-from app import get_db
-
+from app.common.security.auth import verify_super_admin, verify_special, verify_users
+from app import schemas, get_db
+from configs.settings import DefaultOption, config
+DATABASE_NAME = config.get('HIVE', 'DATABASE_NAME')
 
 
 router = APIRouter(
@@ -21,134 +17,146 @@ router = APIRouter(
 )
 
 
-@router.post("/test", dependencies=[Depends(verify_super_admin)])
+@router.post("/test")
 @web_try()
 @sxtimeit
-def test_datasource_connection(ds: schemas.JobJdbcDatasourceCreate, db: Session = Depends(get_db)):
+def test_datasource_connection(ds: schemas.JobJdbcDatasourceCreate,\
+        token_data: schemas.TokenData = Depends(verify_super_admin),\
+        db: Session = Depends(get_db)):
     return crud.test_datasource_connection(db, ds)
 
 
-@router.post("/preview", dependencies=[Depends(verify_special)])
+@router.post("/preview")
 @web_try()
 @sxtimeit
-def get_preview_data(ds_id: int, table_name: str, limit: int = 100, db: Session = Depends(get_db)):
+def get_preview_data(ds_id: int, table_name: str, limit: int = 100, token_data: schemas.TokenData = Depends(verify_special), db: Session = Depends(get_db)):
     return crud.get_preview_data(db, ds_id, table_name, limit)
 
 
-@router.post("/table_names", description="获取所有表名", dependencies=[Depends(verify_special)])
+@router.post("/table_names", description="获取所有表名")
 @web_try()
 @sxtimeit
-def get_table_names(ds_id: int, db: Session = Depends(get_db)):
+def get_table_names(ds_id: int, token_data: schemas.TokenData = Depends(verify_special), db: Session = Depends(get_db)):
     return crud.get_table_names(db, ds_id)
 
-@router.post("/table_schema", description="获取表结构信息", dependencies=[Depends(verify_special)])
+@router.post("/table_schema", description="获取表结构信息")
 @web_try()
 @sxtimeit
-def get_table_schema(ds_id: int, table_name: str, db: Session = Depends(get_db)):
+def get_table_schema(ds_id: int, table_name: str, token_data: schemas.TokenData = Depends(verify_special), db: Session = Depends(get_db)):
     return crud.get_table_schema(db, ds_id, table_name)
 
-@router.post("/", dependencies=[Depends(verify_super_admin)])
+@router.post("/")
 @web_try()
 @sxtimeit
-def create_datasource(ds: schemas.JobJdbcDatasourceCreate, db: Session = Depends(get_db)):
+def create_datasource(ds: schemas.JobJdbcDatasourceCreate, token_data: schemas.TokenData = Depends(verify_super_admin), db: Session = Depends(get_db)):
     return crud.create_job_jdbc_datasource(db, ds)
 
-@router.get("/", dependencies=[Depends(verify_special)])
+@router.get("/")
 @web_try()
 @sxtimeit
-def get_datasources(datasource_type: Optional[str] = None, params: Params=Depends(), db: Session = Depends(get_db)):
+def get_datasources(datasource_type: Optional[str] = None, params: Params=Depends(), token_data: schemas.TokenData = Depends(verify_special), db: Session = Depends(get_db)):
     return paginate(crud.get_job_jdbc_datasources(db, datasource_type), params)
 
-@router.get("/info", dependencies=[Depends(verify_special)])
+@router.get("/info")
 @web_try()
 @sxtimeit
-def get_datasources_info(ds_id: int, db: Session = Depends(get_db)):
+def get_datasources_info(ds_id: int, token_data: schemas.TokenData = Depends(verify_special), db: Session = Depends(get_db)):
     return crud.get_job_jdbc_datasources_info(db, ds_id)
 
-@router.put("/{ds_id}", dependencies=[Depends(verify_super_admin)])
+@router.put("/{ds_id}")
 @web_try()
 @sxtimeit
-def update_datasource(ds_id: int, ds: schemas.JobJdbcDatasourceUpdate, db: Session = Depends(get_db)):
+def update_datasource(ds_id: int, ds: schemas.JobJdbcDatasourceUpdate, token_data: schemas.TokenData = Depends(verify_super_admin), db: Session = Depends(get_db)):
     return crud.update_job_jdbc_datasources(db, ds_id, ds)
 
-@router.delete("/{ds_id}", dependencies=[Depends(verify_super_admin)])
+@router.delete("/{ds_id}")
 @web_try()
 @sxtimeit
-def delete_job_jdbc_datasource(ds_id: int, db: Session = Depends(get_db)):
+def delete_job_jdbc_datasource(ds_id: int, token_data: schemas.TokenData = Depends(verify_super_admin), db: Session = Depends(get_db)):
     return crud.delete_job_jdbc_datasource(db, ds_id)
 
-@router.post("/import_datalake", dependencies=[Depends(verify_super_admin)])
+@router.post("/import_datalake")
 @web_try()
 @sxtimeit
-def import_datalake(item: schemas.ImportDataLake, db: Session = Depends(get_db)):
+def import_datalake(item: schemas.ImportDataLake, token_data: schemas.TokenData = Depends(verify_super_admin), db: Session = Depends(get_db)):
     return crud.import_datalake(db, item)
 
-@router.put("/update_datalake/{dl_id}", dependencies=[Depends(verify_super_admin)])
+@router.put("/update_datalake/{dl_id}")
 @web_try()
 @sxtimeit
-def update_datalake(dl_id: int,item: schemas.ImportDataLake, db: Session = Depends(get_db)):
+def update_datalake(dl_id: int,item: schemas.ImportDataLake, token_data: schemas.TokenData = Depends(verify_super_admin), db: Session = Depends(get_db)):
     return crud.update_datalake(db, dl_id, item)
 
-@router.delete("/delete_datalake/{dl_id}", dependencies=[Depends(verify_super_admin)])
+@router.delete("/delete_datalake/{dl_id}")
 @web_try()
 @sxtimeit
-def delete_datalake(dl_id: int, db: Session = Depends(get_db)):
+def delete_datalake(dl_id: int, token_data: schemas.TokenData = Depends(verify_super_admin), db: Session = Depends(get_db)):
     return crud.delete_datalake(db, dl_id)
 
-@router.post("/share_ailab", dependencies=[Depends(verify_special)])
+@router.post("/share_ailab")
 @web_try()
 @sxtimeit
-def share_ailab(item: schemas.ShareAilab, db: Session = Depends(get_db)):
+def share_ailab(item: schemas.ShareAilab, token_data: schemas.TokenData = Depends(verify_special), db: Session = Depends(get_db)):
     return crud.share_ailab(db, item)
 
-@router.post("/create_table", dependencies=[Depends(verify_all)])
+@router.post("/create_table")
 @web_try()
 @sxtimeit
-def create_table(item: schemas.CreateAilab, db: Session = Depends(get_db)):
+def create_table(item: schemas.CreateAilab, token_data: schemas.TokenData = Depends(verify_users), db: Session = Depends(get_db)):
     return crud.create_table(db, item)
 
+@router.get("/ailab_source")
+@web_try()
+@sxtimeit
+def get_ailab_source(token_data: schemas.TokenData = Depends(verify_users), ):
+    return [{
+            'database_name': DATABASE_NAME,
+            'datasource': "hive",
+            'datasource_name': DATABASE_NAME,
+            'id': -1
+    }]
 
-@router.get("/ailab_table", dependencies=[Depends(verify_all)])
+@router.get("/ailab_table")
 @web_try()
 @sxtimeit
-def get_ailab_table(project_id: int, db: Session = Depends(get_db)):
-    return crud.get_ailab_table(db, project_id)
+def get_ailab_table(token_data: schemas.TokenData = Depends(verify_users), db: Session = Depends(get_db)):
+    return crud.get_ailab_table(db, token_data.project_id)
 
-@router.get("/ailab_table_schema", dependencies=[Depends(verify_all)])
+@router.get("/ailab_table_schema")
 @web_try()
 @sxtimeit
-def get_ailab_table_schema(table_name: str, db: Session = Depends(get_db)):
+def get_ailab_table_schema(table_name: str, token_data: schemas.TokenData = Depends(verify_users), db: Session = Depends(get_db)):
     return crud.get_ailab_table_schema(db, table_name)
 
-@router.get("/preview_ailab_table", dependencies=[Depends(verify_all)])
+@router.get("/preview_ailab_table")
 @web_try()
 @sxtimeit
-def get_preview_ailab_table(table_name: str, db: Session = Depends(get_db)):
+def get_preview_ailab_table(table_name: str, token_data: schemas.TokenData = Depends(verify_users), db: Session = Depends(get_db)):
     return crud.get_preview_ailab_table(db, table_name)
 
-@router.get("/lake_table", dependencies=[Depends(verify_special)])
+@router.get("/lake_table")
 @web_try()
 @sxtimeit
-def get_lake_table(project_id: int, db: Session = Depends(get_db)):
-    return crud.get_lake_table(db, project_id)
+def get_lake_table(token_data: schemas.TokenData = Depends(verify_special), db: Session = Depends(get_db)):
+    return crud.get_lake_table(db, token_data.project_id)
 
 
-@router.get("/lake_table_info", dependencies=[Depends(verify_special)])
+@router.get("/lake_table_info")
 @web_try()
 @sxtimeit
-def get_lake_table_info(dl_id: int, db: Session = Depends(get_db)):
+def get_lake_table_info(dl_id: int, token_data: schemas.TokenData = Depends(verify_special), db: Session = Depends(get_db)):
     return crud.get_lake_table_info(db, dl_id)
 
-@router.get("/lake_table_schema", dependencies=[Depends(verify_special)])
+@router.get("/lake_table_schema")
 @web_try()
 @sxtimeit
-def get_lake_table_schema(table_name: str, db: Session = Depends(get_db)):
+def get_lake_table_schema(table_name: str, token_data: schemas.TokenData = Depends(verify_special), db: Session = Depends(get_db)):
     return crud.get_ailab_table_schema(db, table_name)
 
-@router.get("/preview_lake_table", dependencies=[Depends(verify_special)])
+@router.get("/preview_lake_table")
 @web_try()
 @sxtimeit
-def get_preview_lake_table(table_name: str, db: Session = Depends(get_db)):
+def get_preview_lake_table(table_name: str, token_data: schemas.TokenData = Depends(verify_special), db: Session = Depends(get_db)):
     return crud.get_preview_ailab_table(db, table_name)
 
 

app/routers/job_log.py

@@ -4,8 +4,7 @@ from fastapi import APIRouter
 from fastapi import Depends
 from sqlalchemy.orm import Session
 from app import get_page, page_help, schemas
-from app.common.decorators import verify_all
-
+from app.common.security.auth import verify_users
 import app.crud as crud
 from app.utils.send_util import get_job_run_status, get_task_log
 from constants.constants import RUN_STATUS
@@ -20,10 +19,10 @@ router = APIRouter(
     tags=["joblog-日志管理"],
 )
 
-@router.get("/", dependencies=[Depends(verify_all)])
+@router.get("/")
 @web_try()
 @sxtimeit
-def get_job_logs(job_id: Optional[int] = None, params: Params=Depends(get_page), db: Session = Depends(get_db)):
+def get_job_logs(job_id: Optional[int] = None, params: Params=Depends(get_page), token_data: schemas.TokenData = Depends(verify_users), db: Session = Depends(get_db)):
     job_infos = []
     # 是否有任务筛选
     if job_id is None:
@@ -63,10 +62,10 @@ def get_job_logs(job_id: Optional[int] = None, params: Params=Depends(get_page),
     return page_help(res,params['page'],params['size'],total)
 
 
-@router.get("/getOnce", dependencies=[Depends(verify_all)])
+@router.get("/getOnce")
 @web_try()
 @sxtimeit
-def get_job_logs_once(run_id: int, db: Session = Depends(get_db)):
+def get_job_logs_once(run_id: int, token_data: schemas.TokenData = Depends(verify_users), db: Session = Depends(get_db)):
     # 获取af_run
     af_job_run = crud.get_airflow_run_once(db, run_id)
     # 获取af_job
@@ -82,10 +81,10 @@ def get_job_logs_once(run_id: int, db: Session = Depends(get_db)):
     return log
 
 
-@router.get("/logs_status/{ids}", dependencies=[Depends(verify_all)])
+@router.get("/logs_status/{ids}")
 @web_try()
 @sxtimeit
-def get_job_log_status(ids: str):
+def get_job_log_status(ids: str, token_data: schemas.TokenData = Depends(verify_users)):
     run_ids = ids.split(',')
     id_to_status = {}
     for run_id in run_ids:

app/routers/project.py

@@ -1,55 +0,0 @@
-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_special, verify_user, verify_all, verify_super_admin
-from configs.globals import g
-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.put("/update_project", dependencies=[Depends(verify_super_admin)])
-@web_try()
-@sxtimeit
-def update_project(item: schemas.ProjectUpdate, db: Session = Depends(get_db)):
-    return crud.update_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("/share_projects", dependencies=[Depends(verify_special)])
-@web_try()
-@sxtimeit
-def get_share_projects(db: Session = Depends(get_db)):
-    return crud.get_share_projects(db)
-
-@router.get("/switch", dependencies=[Depends(verify_user)])
-@web_try()
-@sxtimeit
-def switch_project(project_id: int, user_id: int, db: Session = Depends(get_db)):
-    return crud.switch_project_by_user(db,project_id,user_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

@@ -1,70 +0,0 @@
-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

@@ -14,5 +14,4 @@ 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.users import *
-from app.schemas.project import *
+from app.schemas.auth import *

app/schemas/auth.py

@@ -0,0 +1,16 @@
+from pydantic import BaseModel
+from typing import List, Optional
+
+class Token(BaseModel):
+    access_token: str
+    token_type: str
+
+class TokenData(BaseModel):
+    user_id: str
+    project_id: str
+    role_id: str
+
+class SwitchProject(BaseModel):
+    project_id: str
+    user_id: str
+    role_ids: List[str] = []

app/schemas/data_management.py

@@ -7,10 +7,6 @@ class DataManagementBase(BaseModel):
     name: str
     # 创建人名称
     user_name: str
-    # 创建人编号
-    user_id: str
-    # 项目编号
-    project_id: str
 
 class DataManagementCreate(DataManagementBase):
     dag_uuid: str
@@ -21,8 +17,6 @@ class DataManagementCreate(DataManagementBase):
             "example": {
                 "name": "test",
                 "user_name": "test",
-                "user_id": "test",
-                "project_id": "test",
                 "dag_uuid": "test",
                 "node_id": "test",
                 "out_pin": "0",
@@ -35,6 +29,10 @@ class DataManagement(DataManagementBase):
     table_name: str
     # 创建时间
     create_time: int
+    # 创建人编号
+    user_id: str
+    # 项目编号
+    project_id: str
     class Config:
         orm_mode = True
 

app/schemas/jm_homework.py

@@ -21,10 +21,6 @@ class JmHomeworkBase(BaseModel):
     script_file: str
     # 执行命令
     execute_command: Optional[str]
-    # 用户ID
-    user_id: str
-    # 项目ID
-    project_id: str
 
 
 class JmHomeworkCreate(JmHomeworkBase):
@@ -41,8 +37,6 @@ class JmHomeworkCreate(JmHomeworkBase):
                 "dag_url": "",
                 "script_file": "/test/scripts/example",
                 "execute_command": "ls",
-                "user_id": "test",
-                "project_id": "test",
                 "relation_list": [
                     {
                         "type": "input",
@@ -67,8 +61,6 @@ class JmHomeworkUpdate(JmHomeworkBase):
                 "dag_url": "",
                 "script_file": "/test/scripts/example",
                 "execute_command": "ls",
-                "user_id": "test",
-                "project_id": "test",
                 "relation_list": [
                     {
                         "type": "input",
@@ -82,6 +74,10 @@ class JmHomeworkUpdate(JmHomeworkBase):
 
 class JmHomework(JmHomeworkBase):
     id: int
+    # 用户ID
+    user_id: str
+    # 项目ID
+    project_id: str
     # 创建时间
     create_time: int
     # 更新时间

app/schemas/jm_job_info.py

@@ -17,12 +17,8 @@ class JmJobInfoBase(BaseModel):
     cron_expression: Optional[CronExpression] = None
     # 图形信息
     json_str : Optional[str]
-    # 用户id
-    user_id: str
     # 用户名称
     user_name: str
-    # 项目id
-    project_id: str
 
 
 class JmJobInfoCreate(JmJobInfoBase):
@@ -45,9 +41,7 @@ class JmJobInfoCreate(JmJobInfoBase):
                     "month": 2,
                 },
                 "json_str": "\{图形信息\}",
-                "user_id": "test",
                 "user_name": "test",
-                "project_id": "test",
                 "nodes": [
                     {
                         "id": 1,
@@ -93,9 +87,7 @@ class JmJobInfoUpdate(JmJobInfoBase):
                     "month": 2,
                 },
                 "json_str": "\{图形信息\}",
-                "user_id": "test",
                 "user_name": "test",
-                "project_id": "test",
                 "nodes": [
                     {
                         "id": 1,

app/schemas/job_info.py

@@ -37,8 +37,6 @@ class JobInfoBase(BaseModel):
     last_time: Optional[str]
     # 当前时间字段
     current_time: Optional[str]
-    # 创建人
-    user_id: str
 
 
 
@@ -73,7 +71,6 @@ class JobInfoCreate(JobInfoBase):
                 "jvm_param": "",
                 "last_time": "lastTime",
                 "current_time": "currentTime",
-                "user_id": "test",
             }
         }
 
@@ -111,7 +108,6 @@ class JobInfoUpdate(JobInfoBase):
                 "jvm_param": "",
                 "last_time": "lastTime",
                 "current_time": "currentTime",
-                "user_id": "test",
             }
         }
 
@@ -119,6 +115,7 @@ class JobInfoUpdate(JobInfoBase):
 
 class JobInfo(JobInfoBase):
     id: int
+    user_id: str
     # 创建时间
     create_time: int
     # 更新时间

app/schemas/job_jdbc_datasouce.py

@@ -148,7 +148,6 @@ class CreateAilab(BaseModel):
     table_name: str
     columns: List[Column]
     partition_column: Optional[str]
-    project_id: int
 
     class Config:
         schema_extra = {
@@ -161,7 +160,6 @@ class CreateAilab(BaseModel):
                     'column_name': 'name',
                     'Column_type': 'string',
                 }],
-                "project_id": 1,
                 "partition_column": 'data_ct'
             }
         }

app/schemas/project.py

@@ -1,29 +0,0 @@
-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
-            }
-        }
-
-class ProjectUpdate(ProjectBase):
-    project_id: int
-    class Config:
-        schema_extra = {
-            "example": {
-                "name": "blue_sky",
-                "user_id": 1,
-                "project_id": 3
-            }
-        }

app/schemas/users.py

@@ -1,70 +0,0 @@
-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
-            }
-        }

app/services/job_info.py

@@ -36,6 +36,7 @@ def create_job_info_services(db: Session, item: schemas.JobInfoCreate):
         'partition_info': partition_info_str,
     })
     db_item = models.JobInfo(**item_dict, **{
+        'user_id': g.user_id,
         'project_id': g.project_id,
         'trigger_status': 0,
         'create_time': create_time,

development.ini

@@ -1,10 +1,10 @@
 [DATABASE]
-user = root
-pwd = happylay
-db_name = datax_web_dev
-host = 192.168.199.107
-port = 10086
-ssl_disabled = true
+user = sxwl
+pwd = sxwldba
+db_name = aihub-dag
+host = 192.168.199.110
+port = 32306
+ssl_disabled = false
 
 [MINIO]
 url = minio-api.sxkj.com
@@ -71,3 +71,7 @@ kerberos_config = {
                     "kerberosKeytabFilePath": "/workspace/confs/test/user.keytab",
                     "kerberosPrincipal": "ailab@EMR-5XJSY31F"
                   }
+
+[PERMISSIONS]
+super_admin_role = TENANT_ADMIN
+special_project_id = test

server.py

@@ -15,8 +15,7 @@ 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
+import app.routers.auth as router_auth
 from app.routers.run import router_af_run
 from app.routers.job import router_af_job
 from app.routers.task import router_af_task
@@ -44,8 +43,7 @@ app.add_middleware(
 
 app.add_middleware(GlobalsMiddleware)
 
-app.include_router(router_users.router)
-app.include_router(router_project.router)
+app.include_router(router_auth.router)
 app.include_router(router_jjds.router)
 app.include_router(router_constants.router)
 app.include_router(router_job_info.router)