增加功能

zhaoqingang

2024-11-13 de45d8dc19cd16b85344a3c3bbb243a12e8811a0

增加功能

 Log/__init__.py

File was renamed from app/Log/__init__.py
@@ -5,7 +5,7 @@
    logger = logging.getLogger()
    logger.setLevel(logging.INFO)
    # ch = logging.StreamHandler()
    fh = logging.handlers.RotatingFileHandler("app/Log/log.log",mode="a",maxBytes = 100*1024, backupCount = 10, encoding='utf-8')
    fh = logging.handlers.RotatingFileHandler("Log/log.log",mode="a",maxBytes = 100*1024, backupCount = 10, encoding='utf-8')
    formatter = logging.Formatter(
        "%(asctime)s - %(module)s - %(funcName)s - line:%(lineno)d - %(levelname)s -: %(message)s"
    )

 app/Log/log.log

File was deleted

 app/api/group.py

@@ -15,7 +15,7 @@
@group_router.post("/group_list", response_model=Response)
async def user_group_list(paras: PageParameter, current_user: UserModel = Depends(get_current_user),
                          db=Depends(get_db)):
    return Response(code=200, msg="", data=await group_list(db, paras.page_size, paras.page_index, paras.keyword))
    return Response(code=200, msg="", data=await group_list(db, paras.page_size, paras.page_index, paras.keyword, current_user.permission, current_user.id))


@group_router.post("/add_group", response_model=Response)
@@ -25,7 +25,7 @@
    db_group = db.query(GroupModel).filter(GroupModel.group_name == group.group_name).first()
    if db_group:
        return Response(code=200, msg="group already created")
    is_create = await create_group(db, group.group_name, group.group_description)
    is_create = await create_group(db, group.group_name, group.group_description, current_user.id)
    if not is_create:
        return Response(code=200, msg="group create failure", data={})
    return Response(code=200, msg="group create successfully", data={"group_name": group.group_name})

 app/api/knowledge.py

New file
@@ -0,0 +1,30 @@
# coding:utf-8

from fastapi import APIRouter, Depends
from app.api import Response, get_current_user, ResponseList
from app.models import RoleParameter, GroupModel, KnowledgeModel
from app.models.base_model import get_db
from app.models.user_model import UserModel

knowledge_router = APIRouter()

@knowledge_router.get("/list", response_model=Response)
async def knowledge_list(role:str, current_user: UserModel = Depends(get_current_user),
                          db=Depends(get_db)):
    if role == "admin":
        kld_list = db.query(KnowledgeModel).all()
    else:
        user = db.query(UserModel).filter(UserModel.id == current_user.id).first()

        group_list = [i.id for i in user.groups]

        kld_list = db.query(KnowledgeModel).filter(KnowledgeModel.tenant_id==current_user.id).all()
        kld_set = set([i.id for i in kld_list])
        for group in db.query(GroupModel).filter(GroupModel.id.in_(group_list)).all():
            for k in group.knowledges:
                if k.id not in kld_set:
                    kld_list.append(k)
                    kld_set.add(k.id)

    data = [kld.to_json() for kld in kld_list]
    return Response(code=200, msg="", data={"rows": data})

 app/api/resource.py

@@ -1,8 +1,10 @@
from fastapi import APIRouter, Depends
from app.api import Response, pwd_context, get_current_user
from app.models import MenuInfo
from app.models.base_model import get_db
from app.models.user_model import UserModel
from app.service.resource import get_resource_tree, get_resource_info, delete_resource_info
from app.service.resource import get_resource_tree, get_resource_info, delete_resource_info, create_menu, \
    edit_resource_data

menu_router = APIRouter()

@@ -26,12 +28,24 @@


@menu_router.post("/add_menu", response_model=Response)
async def add_dept(dept: DeptInfo, current_user: UserModel = Depends(get_current_user), db=Depends(get_db)):
    if not dept.deptName:
        return Response(code=400, msg="The deptName cannot be empty!")
    if dept.status not in ["0", "1"]:
        return Response(code=400, msg="The status cannot be {}!".format(dept.status))
    is_create = await create_dept(db, dept.deptName, dept.leader, dept.phone, dept.address, dept.status, dept.orderNum, dept.roles, dept.groups, dept.parentId)
async def resource_add_menu(menu: MenuInfo, current_user: UserModel = Depends(get_current_user), db=Depends(get_db)):
    if not menu.menuName:
        return Response(code=400, msg="The menuName cannot be empty!")
    if menu.status not in ["0", "1"]:
        return Response(code=400, msg="The status cannot be {}!".format(menu.status))
    is_create = await create_menu(db, menu.menuName, menu.component, menu.path, menu.orderNum, menu.perms, menu.menuType, menu.description, menu.parentId, menu.status,menu.icon)
    if not is_create:
        return Response(code=500, msg="dept create failure", data={})
    return Response(code=200, msg="dept create successfully", data={})
        return Response(code=500, msg="menu create failure", data={})
    return Response(code=200, msg="menu create successfully", data={})


@menu_router.put("/edit_menu", response_model=Response)
async def resource_edit_menu(menu: MenuInfo, current_user: UserModel = Depends(get_current_user), db=Depends(get_db)):
    if not menu.menuName:
        return Response(code=400, msg="The menuName cannot be empty!")
    if menu.status not in ["0", "1"]:
        return Response(code=400, msg="The status cannot be {}!".format(menu.status))
    is_create = await edit_resource_data(db, menu.menuId, menu.menuName, menu.component, menu.path, menu.orderNum, menu.perms, menu.menuType, menu.description, menu.parentId, menu.status,menu.icon)
    if not is_create:
        return Response(code=500, msg="dept edit failure", data={})
    return Response(code=200, msg="dept edit successfully", data={})

 app/api/role.py

@@ -13,7 +13,8 @@
@role_router.get("/list", response_model=Response)
async def user_group_list(paras: PageParameter, current_user: UserModel = Depends(get_current_user),
                          db=Depends(get_db)):
    return Response(code=200, msg="", data=await role_list(db, paras.page_size, paras.page_index, paras.keyword))

    return Response(code=200, msg="", data=await role_list(db, paras.page_size, paras.page_index, paras.keyword, current_user.permission, current_user.id))


@role_router.post("/add_role", response_model=Response)
@@ -23,7 +24,7 @@
    db_role = db.query(RoleModel).filter(RoleModel.name == role.roleName).first()
    if db_role:
        return Response(code=200, msg="role already created")
    is_create = await create_role(db, role.roleName, role.remark, current_user.id)
    is_create = await create_role(db, role.roleName, role.remark, role.roleKey, role.dataScope,current_user.id)
    if not is_create:
        return Response(code=500, msg="role create failure", data={})
    return Response(code=200, msg="role create successfully", data={"roleName": role.roleName})
@@ -53,16 +54,17 @@

@role_router.put("/edit_role", response_model=Response)
async def edit_role_data(role: RoleEdit, current_user: UserModel = Depends(get_current_user), db=Depends(get_db)):
    if not role.roleName:
        return Response(code=400, msg="The roleName cannot be empty!")
    db_role = db.query(RoleModel).filter(RoleModel.id == role.role_id).first()
    if not db_role:
        return Response(code=200, msg="role does not exist")
    if role.editType == 1:
        if not role.roleName:
            return Response(code=400, msg="The roleName cannot be empty!")
        db_role = db.query(RoleModel).filter(RoleModel.id == role.role_id).first()
        if not db_role:
            return Response(code=200, msg="role does not exist")

    db_role = db.query(RoleModel).filter(RoleModel.name == role.roleName).first()
    if db_role and db_role.id != role.role_id:
        return Response(code=200, msg="role already created")
    is_edit = await edit_role_resource(db, role.role_id,role.roleName, role.remark, role.resources)
        db_role = db.query(RoleModel).filter(RoleModel.name == role.roleName).first()
        if db_role and db_role.id != role.role_id:
            return Response(code=200, msg="role already created")
    is_edit = await edit_role_resource(db, role.role_id,role.roleName, role.remark, role.roleKey, role.dataScope, role.resources, role.editType)
    if not is_edit:
        return Response(code=500, msg="role edit failure", data={})
    return Response(code=200, msg="role edit successfully", data={})

 app/api/user.py

@@ -11,7 +11,7 @@

@user_router.get("/list", response_model=Response)
async def user_list(paras: PageParameter,current_user: UserModel = Depends(get_current_user), db=Depends(get_db)):
    return Response(code=200, msg="", data=await get_user_list(db, paras.page_size, paras.page_index, paras.keyword))
    return Response(code=200, msg="", data=await get_user_list(db, paras.page_size, paras.page_index, paras.keyword, current_user.permission, current_user.id))


@user_router.post("/add_user", response_model=Response)
@@ -24,7 +24,7 @@
    pwd = user.pwd
    if not pwd:
        pwd = "000000"
    is_create = await create_user(db, user.userName, user.email, user.phone, user.loginName, pwd, user.roles, user.groups)
    is_create = await create_user(db, user.userName, user.email, user.phone, user.loginName, pwd, user.roles, user.groups,current_user.id)
    if not is_create:
        return Response(code=500, msg="user create failure", data={})
    return Response(code=200, msg="user create successfully", data={})

 app/models/group_model.py

@@ -38,6 +38,7 @@
    status = Column(String(10), nullable=False, default="1")
    created_at = Column(DateTime, default=datetime.now())
    updated_at = Column(DateTime, default=datetime.now(), onupdate=datetime.now())
    creator = Column(Integer)


    knowledges = relationship('KnowledgeModel',
@@ -79,8 +80,8 @@


    def __repr__(self):
        return '<Role name:%r description:%r iconCls:%r seq:%r>\n' \
            % (self.NAME, self.DESCRIPTION, self.ICONCLS, self.SEQ)
        return '<Role name:%r description:%r>\n' \
            % (self.group_name, self.group_description)

    def to_json(self):
        json = {

 app/models/knowledge_model.py

@@ -1,5 +1,8 @@
import json
from datetime import datetime
from typing import Optional

from pydantic import BaseModel
from sqlalchemy import Column, Integer, String, Table, ForeignKey, DateTime, BigInteger, Text, Float, Boolean
from sqlalchemy.orm import relationship, backref

@@ -18,7 +21,7 @@
    tenant_id = Column(String(32))              # 创建人id
    description = Column(Text)                 # 说明
    status = Column(String(1))                    # 状态
    kld_type = Column(String(1))                  # 知识库平台
    # kld_type = Column(String(1))                  # 知识库平台


    def get_id(self):
@@ -28,23 +31,17 @@
        return {
            'id': self.id,
            'name': self.name,
            'create_time': self.create_time,
            'update_time': self.update_time,
            'create_time': self.create_date,
            'update_time': self.update_date,
            'avatar': self.avatar,
            'tenant_id': self.tenant_id,
            'language': self.language,
            'description': self.description,
            'embd_id': self.embd_id,
            'permission': self.permission,
            'created_by': self.created_by,
            'doc_num': self.doc_num,
            'token_num': self.token_num,
            'chunk_num': self.chunk_num,
            'similarity_threshold': self.similarity_threshold,
            'vector_similarity_weight': self.vector_similarity_weight,
            'parser_id': self.parser_id,
            'parser_config': json.loads(self.parser_config),
            'status': self.status
            'status': self.status,
            # 'kld_type': self.kld_type
        }
    def __repr__(self):
        return '<Knowledge name:%r url:%r>\n' % (self.name, self.id)
        return '<Knowledge name:%r url:%r>\n' % (self.name, self.id)


class RoleParameter(BaseModel):
    role: str

 app/models/resource_model.py

@@ -151,7 +151,8 @@
    perms: Optional[str] = ""
    menuType: Optional[str] = ""
    description: Optional[str] = ""
    icon: Optional[str] = ""
    parentId: str
    status: str
    roles: list
    groups: Optional[list] = []
    # roles: list
    # groups: Optional[list] = []

 app/models/role_model.py

@@ -69,6 +69,8 @@
class RoleData(BaseModel):
    remark: Optional[str] = ""
    roleName: str
    roleKey: Optional[str] = ""
    dataScope: Optional[str] = ""


class RoleStatus(BaseModel):
@@ -81,3 +83,6 @@
    remark: Optional[str] = ""
    roleName: Optional[str] = ""
    resources: Optional[list] = []
    roleKey: Optional[str] = ""
    dataScope: Optional[int] = 0
    editType: int

 app/models/user_model.py

@@ -34,6 +34,7 @@
    status = Column(String(10), nullable=False, default="1")
    creator = Column(String(36))
    sex = Column(String(1))
    permission = Column(String(16), nullable=False, default="1")
    age = Column(Integer)
    created_at = Column(DateTime, default=datetime.now())
    updated_at = Column(DateTime, default=datetime.now(), onupdate=datetime.now())

 app/service/group.py

@@ -1,16 +1,16 @@
from sqlalchemy.testing.pickleable import Order

from app.config.config import settings
from app.models.group_model import GroupModel
from app.models.user_model import UserModel
from app.service.ragflow import RagflowService
from app.service.token import get_ragflow_token
from app.Log import logger
from Log import logger


async def group_list(db, page_size: int, page_index: int, keyword: str):
async def group_list(db, page_size: int, page_index: int, keyword: str, role_key:str, user_id):
    logger.info("-------------------------group_list----------------------------------")
    query = db.query(GroupModel)
    if role_key != "admin":
        query.filter(GroupModel.creator==user_id)
    if keyword:
        query = query.filter(GroupModel.group_name.like('%{}%'.format(keyword)))
    items = query.order_by(GroupModel.id.desc()).limit(page_size).offset(
@@ -30,9 +30,9 @@
    return {"total": query.count(), "items": [item.to_json() for item in items]}


async def create_group(db, group_name: str, group_description: str):
async def create_group(db, group_name: str, group_description: str, user_id):
    try:
        group_model = GroupModel(group_name=group_name, group_description=group_description)
        group_model = GroupModel(group_name=group_name, group_description=group_description, creator=user_id)
        db.add(group_model)
        db.commit()
        db.refresh(group_model)

 app/service/knowledge.py

 app/service/organization.py

@@ -1,7 +1,7 @@
import uuid

from app.Log import logger
from app.models import OrganizationModel, GroupModel
from Log import logger
from app.models import OrganizationModel
from app.models.role_model import RoleModel



 app/service/resource.py

@@ -1,9 +1,7 @@
import uuid

from app.Log import logger
from app.models import OrganizationModel, GroupModel, ResourceModel
from app.models.role_model import RoleModel

from Log import logger
from app.models import ResourceModel


async def get_resource_tree(db):
@@ -26,4 +24,42 @@
        logger.error(e)
        db.rollback()
        return False
    return True


async def create_menu(db, menu_name, component, path, order_num, perms, menu_type, description, parent_id, status, icon):
    try:
        dept_model = ResourceModel(id=str(uuid.uuid4()),name=menu_name, url=component,path=path,perms=perms,description=description,status=status, icon=icon,seq=order_num, resource_type_id=menu_type)
        if parent_id:
            dept_model.parent = db.get(ResourceModel, parent_id)
        db.add(dept_model)
        db.commit()
        db.refresh(dept_model)
    except Exception as e:
        logger.error(e)
        db.rollback()
        return False
    return True


async def edit_resource_data(db, menu_id, menu_name, component, path, order_num, perms, menu_type, description, parent_id, status, icon):
    try:
        dept_model = db.query(ResourceModel).filter(ResourceModel.id == menu_id).first()
        dept_model.name = menu_name
        dept_model.url = component
        dept_model.path = path
        dept_model.perms = perms
        dept_model.status = status
        dept_model.icon = icon
        dept_model.seq = order_num
        dept_model.description = description
        dept_model.resource_type_id = menu_type
        if parent_id:
            dept_model.parent = db.get(ResourceModel, parent_id)
        db.commit()
        db.refresh(dept_model)
    except Exception as e:
        logger.error(e)
        db.rollback()
        return False
    return True

 app/service/role.py

@@ -1,13 +1,15 @@
import uuid

from app.Log import logger
from app.models.resource_model import ResourceModel, ResourceTypeModel
from Log import logger
from app.models.resource_model import ResourceModel
from app.models.role_model import RoleModel



async def role_list(db, page_size: int, page_index: int, keyword: str):
async def role_list(db, page_size: int, page_index: int, keyword: str, role_key:str, user_id):
    query = db.query(RoleModel)
    if role_key != "admin":
        query.filter(RoleModel.creator==user_id)
    if keyword:
        query = query.filter(RoleModel.name.like('%{}%'.format(keyword)))
    roles = query.order_by(RoleModel.id.desc()).limit(page_size).offset(
@@ -15,9 +17,11 @@
    return {"total": query.count(), "rows":  [role.to_json() for role in roles]}


async def create_role(db, role_name: str, description: str, user_id):
async def create_role(db, role_name: str, description: str, role_key, data_scope, user_id):
    try:
        role_model = RoleModel(id=str(uuid.uuid4()),name=role_name, description=description,creator=user_id)
        role_model = RoleModel(id=str(uuid.uuid4()),name=role_name, description=description,creator=user_id, data_scope=data_scope)
        if role_key:
            role_model.roleKey = role_key
        db.add(role_model)
        db.commit()
        db.refresh(role_model)
@@ -49,12 +53,18 @@
    return True


async def edit_role_resource(db, role_id:str, role_name:str, description:str, resources:list):
async def edit_role_resource(db, role_id:str, role_name:str, description:str,role_key:str, data_scope:int, resources:list, edit_type:int):
    try:
        role = db.query(RoleModel).filter(RoleModel.id == role_id).first()
        if role_name: role.name = role_name
        if description: role.description = description
        if resources:
        if edit_type == 1:
            role.name = role_name
            role.description = description

            if role_key:
                role.roleKey = role_key
            if data_scope:
                role.data_scope = data_scope
        else:
            role.resources = [db.get(ResourceModel, resourcesId) for resourcesId in resources]
        db.add(role)
        db.commit()

 app/service/user.py

@@ -1,18 +1,18 @@
import base64

from datetime import datetime

from app.api import pwd_context
from app.config.config import settings
from app.models import RoleModel, GroupModel
from app.models.user_model import UserModel
from app.Log import logger
from Log import logger
from app.service.bisheng import BishengService
from app.service.ragflow import RagflowService


async def get_user_list(db, page_size: int, page_index: int, keyword: str):
async def get_user_list(db, page_size: int, page_index: int, keyword: str, role_key:str, user_id):
    query = db.query(UserModel)
    if role_key != "admin":
        query.filter(UserModel.creator==user_id)
    if keyword:
        query = query.filter(UserModel.group_name.like('%{}%'.format(keyword)))
    users = query.order_by(UserModel.id.desc()).limit(page_size).offset(
@@ -42,7 +42,7 @@
    return True


async def create_user(db, user_name, email, phone, login_name, password, roles, groups):
async def create_user(db, user_name, email, phone, login_name, password, roles, groups, user_id):
    try:
        bisheng_service = BishengService(settings.sgb_base_url)
        ragflow_service = RagflowService(settings.fwr_base_url)
@@ -69,6 +69,7 @@
        user_model.roles = [db.get(RoleModel, roleId) for roleId in roles]
        if groups:
            user_model.groups = [db.get(GroupModel, groupId) for groupId in groups]
        user_model.creator = user_id
        db.add(user_model)
        db.commit()
        db.refresh(user_model)

 main.py

@@ -5,6 +5,7 @@
from app.api.agent import router as agent_router
from app.api.excel import router as excel_router
from app.api.files import router as files_router
from app.api.knowledge import knowledge_router
from app.api.organization import dept_router
from app.api.report import router as report_router
from app.api.resource import menu_router
@@ -46,6 +47,7 @@
app.include_router(role_router, prefix='/api/role', tags=["role"])
app.include_router(dept_router, prefix='/api/dept', tags=["dept"])
app.include_router(menu_router, prefix='/api/menu', tags=["menu"])
app.include_router(knowledge_router, prefix='/api/knowledge', tags=["knowledge"])

if __name__ == "__main__":
    import uvicorn