知识库分享，历史记录文件

app/api/knowledge.py

@@ -2,41 +2,48 @@
 
 from fastapi import APIRouter, Depends, Query, HTTPException
 from app.api import Response, get_current_user, ResponseList
-from app.models import klgParameter, klgIcon
+from app.models import klgParameter, klgIcon, KlgOwner
 from app.models.base_model import get_db
 from app.models.user_model import UserModel
 from app.service.knowledge import get_knowledge_list, create_knowledge_service, sync_knowledge_service, \
-    delete_knowledge_service, update_knowledge_icon_service
+    delete_knowledge_service, update_knowledge_icon_service, get_knowledge_users_service, set_knowledge_owner_service, \
+    add_knowledge_user_service
 from typing import Optional
+
 knowledge_router = APIRouter()
 
+
 @knowledge_router.get("/list", response_model=Response)
 async def knowledge_list(
         current: int,
         pageSize: int,
-        keyword: str="",
-        status: str="",
-        knowledge: str="1",
-        location: str="",
+        keyword: str = "",
+        status: str = "",
+        knowledge: str = "1",
+        location: str = "",
         current_user: UserModel = Depends(get_current_user),
         db=Depends(get_db)):
     if current and not pageSize:
         return ResponseList(code=400, msg="缺少参数")
-    getknowledgelist = await get_knowledge_list(db, current_user.id, keyword, pageSize, current, status, knowledge, location)
+    getknowledgelist = await get_knowledge_list(db, current_user.id, keyword, pageSize, current, status, knowledge,
+                                                location)
 
     return Response(code=200, msg="", data=getknowledgelist)
 
 
 @knowledge_router.post("/create", response_model=Response)
-async def create_knowledge_api(klg: klgParameter, current_user: UserModel = Depends(get_current_user), db=Depends(get_db)):
-    is_create = await create_knowledge_service(db, klg.id, klg.name, klg.description, klg.icon, klg.klgType, current_user.id)
+async def create_knowledge_api(klg: klgParameter, current_user: UserModel = Depends(get_current_user),
+                               db=Depends(get_db)):
+    is_create = await create_knowledge_service(db, klg.id, klg.name, klg.description, klg.icon, klg.klgType,
+                                               current_user.id)
     if not is_create:
         return Response(code=500, msg="role knowledge failure", data={})
     return Response(code=200, msg="role knowledge success", data={})
 
 
 @knowledge_router.get("/update", response_model=Response)
-async def change_knowledge_api(knowledgeId: str, current_user: UserModel = Depends(get_current_user), db=Depends(get_db)):
+async def change_knowledge_api(knowledgeId: str, current_user: UserModel = Depends(get_current_user),
+                               db=Depends(get_db)):
     # is_create = await update_dialog_status_service(db, dialog.id, dialog.status)
     # if not is_create:
     #     return Response(code=500, msg="dialog update failure", data={})
@@ -59,10 +66,38 @@ async def sync_knowledge_api(knowledgeId: str, current_user: UserModel = Depends
     return Response(code=200, msg="knowledge delete success", data={})
 
 
-
 @knowledge_router.put("/update_icon", response_model=Response)
 async def change_dialog_icon(klg: klgIcon, current_user: UserModel = Depends(get_current_user), db=Depends(get_db)):
     is_create = await update_knowledge_icon_service(db, klg.id, klg.icon)
     if not is_create:
         return Response(code=500, msg="knowledge update failure", data={})
-    return Response(code=200, msg="knowledge update success", data={})
+    return Response(code=200, msg="knowledge update success", data={})
+
+
+@knowledge_router.get("/{knowledgeId}/users", response_model=Response)
+async def get_kb_users(knowledgeId: str,
+                       current: int,
+                       pageSize: int,
+                       member:int = 0,
+                       current_user: UserModel = Depends(get_current_user), db=Depends(get_db)):
+    kb_user = await get_knowledge_users_service(db, knowledgeId, current_user.id, current, pageSize, member)
+
+    return Response(code=200, msg="knowledge user success", data={"rows": kb_user})
+
+
+@knowledge_router.post("/transfer/owner", response_model=Response)
+async def transfer_kb_owner(klgOwner: KlgOwner,
+                       current_user: UserModel = Depends(get_current_user), db=Depends(get_db)):
+    is_update = await set_knowledge_owner_service(db, klgOwner.knowledgeId, klgOwner.UserId, current_user.id)
+    if not is_update:
+        return Response(code=500, msg="knowledge update failure", data={})
+    return Response(code=200, msg="knowledge update success", data={})
+
+
+@knowledge_router.get("/{knowledgeId}/join", response_model=Response)
+async def join_kb_user(knowledgeId: str,
+                       current_user: UserModel = Depends(get_current_user), db=Depends(get_db)):
+    is_add = await add_knowledge_user_service(db, knowledgeId, current_user.id)
+    if not is_add:
+        return Response(code=500, msg="knowledge join failure", data={})
+    return Response(code=200, msg="knowledge join success", data={})

app/api/user.py

@@ -154,4 +154,9 @@ async def edit_user(user: UserDept, current_user: UserModel = Depends(get_curren
     is_edit = await edit_user_dept(db, user.userId, user.depts)
     if not is_edit:
         return Response(code=500, msg="user edit failure", data={})
-    return Response(code=200, msg="user edit successfully", data={})
+    return Response(code=200, msg="user edit successfully", data={})
+
+
+@user_router.get("/ping", response_model=Response)
+async def user_ping(current_user: UserModel = Depends(get_current_user)):
+    return Response(code=200, msg="", data={})

app/config/env_conf/admin.yaml

@@ -3,9 +3,9 @@ smart_server:
   password: gAAAAABnvAq8bErFiR9x_ZcODjUeOdrDo8Z5UVOzyqo6SxIhAvLpw81kciQN0frwIFVfY9wrxH1WqrpTICpEwfH7r2SkLjS7SQ==
 
 chat_server:
-  id: 2c039666c29d11efa4670242ac1b0006
-  account: zhao1@example.com
-  password: gAAAAABnpFLtotY2OIRH12BJh4MzMgn5Zil7-DVpIeuqlFwvr0g6g_n4ULogn-LNhCbtk6cCDkzZlqAHvBSX2e_zf7AsoyzbiQ==
+  id: e7f1b3a6062911f0a9650242ac120004
+  account: 1528276425@qq.com
+  password: gAAAAABn4MzQzoGBSFI6Gx1Nz1RdEY31E0exNFwUtD7q0iWtaUeFCgA6ruDxjLxA7sNgP_lV_Un_SgN0xnaCdwd9a_XH3VAHMg==
 
 workflow_server:
   account: admin@basic.com

app/models/knowledge_model.py

@@ -30,7 +30,7 @@ class KnowledgeModel(Base):
     def get_id(self):
         return str(self.id)
 
-    def to_json(self):
+    def to_json(self, user_id=""):
         return {
             'id': self.id,
             'name': self.name,
@@ -42,7 +42,8 @@ class KnowledgeModel(Base):
             'status': self.status,
             'documents': self.documents if self.documents else 0,
             'icon': self.icon,
-            'embd_id': self.embd_id
+            'embd_id': self.embd_id,
+            'link': True if (self.tenant_id == user_id or user_id == "admin" ) and self.permission == "team" else False,
         }
     def __repr__(self):
         return '<Knowledge name:%r url:%r>\n' % (self.name, self.id)
@@ -59,4 +60,40 @@ class klgParameter(BaseModel):
 
 class klgIcon(BaseModel):
     id: str
-    icon: str
+    icon: str
+
+
+
+class KnowledgeUserModel(Base):
+    __tablename__ = 'knowledgebase_user'
+
+    id = Column(Integer, primary_key=True)  # id
+    kb_id = Column(String(36))
+    user_id = Column(Integer)
+    create_date = Column(DateTime, default=datetime.now())             # 创建时间
+    update_date = Column(DateTime, default=datetime.now(), onupdate=datetime.now())             # 更新时间
+    status = Column(Integer)  # 状态
+
+
+
+    def get_id(self):
+        return str(self.id)
+
+    def to_json(self, user_id=""):
+        return {
+            'id': self.id,
+            'kb_id': self.kb_id,
+            'create_time': self.create_date.strftime('%Y-%m-%d %H:%M:%S'),
+            'update_time': self.update_date.strftime('%Y-%m-%d %H:%M:%S'),
+            'user_id': self.user_id,
+            'status': self.status,
+            'owner': True if str(self.user_id) == user_id else False,
+        }
+    def __repr__(self):
+        return '<Knowledge name:%r url:%r>\n' % (self.name, self.id)
+
+
+
+class KlgOwner(BaseModel):
+    knowledgeId: str
+    UserId: int

app/models/v2/chat.py

@@ -177,16 +177,17 @@ class ComplexChatSessionModel(Base):
         }
 
     def log_to_json(self):
+        query = {}
+        if self.query:
+            query = json.loads(self.query)
         if self.message_type == 1:
             return {
                 'id': self.id,
                 'role': "user",
                 'content': self.content,
+                'files': query.get("files", []),
             }
         else:
-            query = {}
-            if self.query:
-                query = json.loads(self.query)
 
             res = {
                 'id': self.id,
@@ -195,6 +196,7 @@ class ComplexChatSessionModel(Base):
                 'chat_mode': self.chat_mode,
                 "parentId": query.get("parentId"),
                 "isDeep": query.get("isDeep", 1),
+                "mindmap": True if self.mindmap else False,
             }
             if self.chat_mode == complex_knowledge_chat:
                 res['reference'] = json.loads(self.node_data) if self.node_data else {}

app/models/v2/session_model.py

@@ -82,6 +82,17 @@ class ChatData(BaseModel):
 
 
 
+    def to_dict(self):
+        res = {"files": [], "inputs": {}}
+        if hasattr(self, 'files'):
+            res['files'] = self.files
+        if hasattr(self, 'inputs'):
+            res['inputs'] = self.inputs
+        return res
+
+
+
+
 class ChatSessionDao:
     def __init__(self, db: Session):
         self.db = db

app/service/knowledge.py

@@ -2,7 +2,7 @@ from datetime import datetime
 
 from sqlalchemy import or_
 
-from app.models import KnowledgeModel, group_knowledge_table
+from app.models import KnowledgeModel, group_knowledge_table, KnowledgeUserModel
 from app.models.user_model import UserModel
 from Log import logger
 from app.task.fetch_agent import get_one_from_ragflow_knowledge
@@ -15,6 +15,9 @@ async def get_knowledge_list(db, user_id, keyword, page_size, page_index, status
     query = db.query(KnowledgeModel).filter(KnowledgeModel.knowledge_type==knowledge)
     if user.permission != "admin":
         klg_list = [j.id for i in user.groups for j in i.knowledges]
+        for i in db.query(KnowledgeUserModel).filter(KnowledgeUserModel.user_id == user_id, KnowledgeUserModel.status == 1).all():
+            if i.kb_id not in klg_list:
+                klg_list.append(i.kb_id)
         query = query.filter(or_(KnowledgeModel.id.in_(klg_list), KnowledgeModel.tenant_id == str(user_id)))
 
         if location:
@@ -25,13 +28,16 @@ async def get_knowledge_list(db, user_id, keyword, page_size, page_index, status
     total = query.count()
     if page_size:
         query = query.order_by(KnowledgeModel.update_date.desc()).limit(page_size).offset((page_index - 1) * page_size)
-    return {"total":  total, "rows": [kld.to_json() for kld in query.all()]}
+    return {"total":  total, "rows": [kld.to_json(str(user_id) if user.permission != "admin" else "admin") for kld in query.all()]}
 
 
 async def create_knowledge_service(db, klg_id, name, description, icon, klg_type, user_id):
     try:
         dialog_model = KnowledgeModel(id=klg_id,name=name, description=description,icon=icon, knowledge_type=klg_type, tenant_id=user_id,update_date=datetime.now(),create_date=datetime.now())
         db.add(dialog_model)
+        kb_user = KnowledgeUserModel(kb_id=klg_id, user_id=user_id, status=1, update_date=datetime.now(),
+                                     create_date=datetime.now())
+        db.add(kb_user)
         db.commit()
         db.refresh(dialog_model)
     except Exception as e:
@@ -87,3 +93,47 @@ async def update_knowledge_icon_service(db, klg_id, icon):
         return False
     return True
 
+
+
+async def get_knowledge_users_service(db, kb_id, user_id, page, page_size, member):
+    kb_user_list = []
+    user_ids = []
+    kb_info = db.query(KnowledgeModel).filter(KnowledgeModel.id == kb_id).first()
+    query = db.query(KnowledgeUserModel).filter(KnowledgeUserModel.kb_id == kb_id)
+    if member:
+        query = query.filter(KnowledgeUserModel.user_id != user_id)
+    total = query.count()
+
+    for kld in query.limit(page_size).offset((page - 1) * page_size).all():
+        user_ids.append(kld.user_id)
+        print(kb_info.tenant_id)
+        kb_user_list.append(kld.to_json(kb_info.tenant_id))
+    user = {i.id: i.username for i in db.query(UserModel).filter(UserModel.id.in_(user_ids)).all()}
+    for kld in kb_user_list:
+        kld["username"] = user.get(kld["user_id"], "")
+    return {"total": total, "rows": kb_user_list}
+
+
+async def set_knowledge_owner_service(db, kb_id, user_id, u_id):
+    try:
+        db.query(KnowledgeModel).filter_by(id=kb_id).update({"tenant_id": str(user_id), "update_date": datetime.now()})
+        db.commit()
+    except Exception as e:
+        logger.error(e)
+        db.rollback()
+        return False
+    return True
+
+
+async def add_knowledge_user_service(db, kb_id, user_id):
+    try:
+
+        kb_user = KnowledgeUserModel(kb_id=kb_id, user_id=user_id, status=1, update_date=datetime.now(),
+                                     create_date=datetime.now())
+        db.add(kb_user)
+        db.commit()
+    except Exception as e:
+        logger.error(e)
+        db.rollback()
+        return False
+    return True

app/service/v2/chat.py

@@ -14,7 +14,7 @@ from app.config.agent_base_url import RG_CHAT_DIALOG, DF_CHAT_AGENT, DF_CHAT_PAR
 from app.config.config import settings
 from app.config.const import *
 from app.models import DialogModel, ApiTokenModel, UserTokenModel, ComplexChatSessionDao, ChatDataRequest, \
-    ComplexChatDao, KnowledgeModel, UserModel
+    ComplexChatDao, KnowledgeModel, UserModel, KnowledgeUserModel
 from app.models.v2.session_model import ChatSessionDao, ChatData
 from app.service.v2.app_driver.chat_agent import ChatAgent
 from app.service.v2.app_driver.chat_data import ChatBaseApply
@@ -34,7 +34,7 @@ async def update_session_log(db, session_id: str, message: dict, conversation_id
 
 
 async def add_session_log(db, session_id: str, question: str, chat_id: str, user_id, event_type: str,
-                          conversation_id: str, agent_type):
+                          conversation_id: str, agent_type, query: dict=None):
     try:
         session = await ChatSessionDao(db).update_or_insert_by_id(
             session_id=session_id,
@@ -42,7 +42,7 @@ async def add_session_log(db, session_id: str, question: str, chat_id: str, user
             agent_id=chat_id,
             agent_type=agent_type,
             tenant_id=user_id,
-            message={"role": "user", "content": question},
+            message={"role": "user", "content": question, "query": query},
             conversation_id=conversation_id,
             event_type=event_type
         )
@@ -97,6 +97,9 @@ async def get_user_kb(db, user_id: int, kb_ids: list) -> list:
     query = db.query(KnowledgeModel)
     if user.permission != "admin":
         klg_list = [j.id for i in user.groups for j in i.knowledges]
+        for i in db.query(KnowledgeUserModel).filter(KnowledgeUserModel.user_id == user_id, KnowledgeUserModel.status == 1).all():
+            if i.kb_id not in klg_list:
+                klg_list.append(i.kb_id)
         query = query.filter(or_(KnowledgeModel.id.in_(klg_list), KnowledgeModel.tenant_id == str(user_id)))
         kb_list= query.all()
         for kb in kb_list:
@@ -204,7 +207,7 @@ async def service_chat_workflow(db, chat_id: str, chat_data: ChatData, session_i
     else:
         query = "start new conversation"
     session = await add_session_log(db, session_id, query if query else "start new conversation", chat_id, user_id,
-                                    mode, conversation_id, DF_TYPE)
+                                    mode, conversation_id, DF_TYPE, chat_data.to_dict())
     if session:
         conversation_id = session.conversation_id
     try: