历史记录增加

zhaoqingang

2025-02-24 f13239560d9a6888d3bf95699ed5fc10395b50ff

历史记录增加

 app/api/auth.py

@@ -1,31 +1,21 @@
import json
import time

from fastapi import APIRouter, Depends
from sqlalchemy.orm import Session
from sqlalchemy.ext.asyncio import AsyncSession

from Log import logger
from app.api import Response, pwd_context, get_current_user
from app.api.user import reset_user_pwd
from app.config.config import settings
from app.config.const import RAGFLOW, BISHENG, DIFY, chat_server, workflow_server
from app.models.app_token_model import AppToken
from app.models.base_model import get_db
from app.models.postgresql_base_model import get_pdb
from app.models.token_model import upsert_token, update_token
from app.models.token_model import upsert_token
from app.models.user import UserCreate, LoginData
from app.models.user_model import UserModel, UserAppModel, UserTokenModel
from app.service.auth import authenticate_user, create_access_token, is_valid_password, save_register_user, \
    update_user_token, UserAppDao, update_user_info, password_rsa
from app.service.bisheng import BishengService
from app.service.service_token import get_new_token, get_token, update_user_group
from app.service.v2.app_register import AppRegisterDao
from app.service.difyService import DifyService
from app.models.user_model import UserModel, UserTokenModel
from app.service.auth import authenticate_user, create_access_token, is_valid_password, save_register_user, password_rsa
from app.service.service_token import  get_token
from app.service.ragflow import RagflowService
from sqlalchemy.future import select

from app.utils.password_handle import generate_password

router = APIRouter()

@@ -144,11 +134,9 @@
    # await update_token(db, user.id, access_token, token_dict)
    # await update_user_token(db, user.id, token_dict)
    token_dict = {}
    for app in  [{"app": RAGFLOW, "token_id": chat_server},
                {"app": DIFY,"token_id": workflow_server}]:
        user_token = db.query(UserTokenModel).filter(UserTokenModel.id == app["token_id"]).first()
        if user_token and user_token.access_token:
            token_dict[app["app"]] = user_token.access_token
    user_tokens = db.query(UserTokenModel).all()
    for user_token in user_tokens:
        token_dict[user_token.id] = user_token.access_token
    result = await pdb.execute(select(AppToken).where(AppToken.id == user.id))
    db_app_token = result.scalars().first()
    if isinstance(access_token, bytes):
@@ -220,7 +208,7 @@

@router.get("/v2/sync", response_model=Response)
async def sync_user_tenant(userFlag: str, db=Depends(get_db)):
    app_register = AppRegisterDao(db).get_app_by_id(RAGFLOW)
    if app_register:
        is_update = await update_user_group(db, userFlag)
    # app_register = AppRegisterDao(db).get_app_by_id(RAGFLOW)
    # if app_register:
    #     is_update = await update_user_group(db, userFlag)
    return Response(code=200, msg="success", data={})

 app/api/v2/chat.py

@@ -5,6 +5,7 @@
from fastapi import Depends, APIRouter, File, UploadFile
from sqlalchemy.orm import Session
from starlette.responses import StreamingResponse, Response
from werkzeug.http import HTTP_STATUS_CODES

from app.api import get_current_user
from app.config.const import dialog_chat, advanced_chat, base_chat, agent_chat, workflow_chat, basic_chat, \
@@ -13,7 +14,8 @@
from app.models.base_model import get_db
from app.models.v2.session_model import ChatData
from app.service.v2.chat import service_chat_dialog, get_chat_info, service_chat_basic, \
    service_chat_workflow, service_chat_parameters, service_chat_sessions, service_chat_upload
    service_chat_workflow, service_chat_parameters, service_chat_sessions, service_chat_upload, \
    service_chat_sessions_list, service_chat_session_log

chat_router_v2 = APIRouter()

@@ -109,3 +111,16 @@
        status_code = http_400
        data = "{}"
    return Response(data, media_type="application/json", status_code=status_code)



@chat_router_v2.get("/chat/sessions")
async def api_chat_sessions(chatId:str, current:int=1, pageSize:int=100, keyword:str="", current_user: UserModel = Depends(get_current_user), db: Session = Depends(get_db)): #  current_user: UserModel = Depends(get_current_user)
    data = await service_chat_sessions_list(db, chatId, current, pageSize, current_user.id, keyword)
    return Response(data, media_type="application/json", status_code=http_200)


@chat_router_v2.get("/chat/session_log")
async def api_chat_sessions(sessionId:str, current_user: UserModel = Depends(get_current_user), db: Session = Depends(get_db)): #  current_user: UserModel = Depends(get_current_user)
    data = await service_chat_session_log(db, sessionId)
    return Response(data, media_type="application/json", status_code=http_200)

 app/api/v2/public_api.py

@@ -4,13 +4,11 @@
from fastapi.responses import JSONResponse
from Log import logger
from app.api import Response
from app.api.auth import login
from app.config.const import IMAGE_TO_TEXT, DOCUMENT_TO_CLEANING, DOCUMENT_TO_REPORT, DIFY, BISHENG, RAGFLOW, \
from app.config.const import IMAGE_TO_TEXT, DOCUMENT_TO_CLEANING, \
    DOCUMENT_IA_QUESTIONS, DOCUMENT_TO_REPORT_TITLE, DOCUMENT_TO_TITLE, DOCUMENT_TO_PAPER
from app.models.base_model import get_db
from app.models.public_api_model import DfToken, AppRegister
from app.models.public_api_model import DfToken
from app.service.v2.api_token import DfTokenDao
from app.service.v2.app_register import AppRegisterDao
from app.service.v2.initialize_data import dialog_menu_sync, create_menu_sync, user_update_app
from app.task.sync_resources import sync_knowledge, sync_dialog, sync_agent, sync_llm, sync_resource

@@ -34,18 +32,18 @@
    return Response(code=200, msg="successfully", data={})


@public_api.post("/sync/app_register", response_model=Response)
async def sync_app_register(apr: AppRegister, db=Depends(get_db)):
    app_dict = {RAGFLOW: apr.rg, BISHENG: apr.bs, DIFY: apr.df}

    try:
        for app_id, status in app_dict.items():
            AppRegisterDao(db).update_and_insert_app(app_id, status)
    except Exception as e:
        logger.error(e)
        return Response(code=500, msg="failed", data={})

    return Response(code=200, msg="successfully", data={})
# @public_api.post("/sync/app_register", response_model=Response)
# async def sync_app_register(apr: AppRegister, db=Depends(get_db)):
#     app_dict = {RAGFLOW: apr.rg, BISHENG: apr.bs, DIFY: apr.df}
#
#     try:
#         for app_id, status in app_dict.items():
#             AppRegisterDao(db).update_and_insert_app(app_id, status)
#     except Exception as e:
#         logger.error(e)
#         return Response(code=500, msg="failed", data={})
#
#     return Response(code=200, msg="successfully", data={})


@public_api.get("/sync/resource", response_model=Response)

 app/config/const.py

@@ -101,3 +101,4 @@
###-----------------------app account key--------------------------------------------
chat_server = "chat_server"
workflow_server = "workflow_server"
smart_server = "smart_server"

 app/config/env_conf/admin.yaml

@@ -1,12 +1,12 @@
smart_server:
  account: administer
  password: basic@2025
  password: gAAAAABnvAq8bErFiR9x_ZcODjUeOdrDo8Z5UVOzyqo6SxIhAvLpw81kciQN0frwIFVfY9wrxH1WqrpTICpEwfH7r2SkLjS7SQ==

ragflow_app:
chat_server:
  id: 2c039666c29d11efa4670242ac1b0006
  account: admin@example.com
  password: basic@2025
  account: zhao1@example.com
  password: gAAAAABnpFLtotY2OIRH12BJh4MzMgn5Zil7-DVpIeuqlFwvr0g6g_n4ULogn-LNhCbtk6cCDkzZlqAHvBSX2e_zf7AsoyzbiQ==

dify_app:
  account: admin@mail.com
  password: basic@2025
workflow_server:
  account: admin@basic.com
  password: gAAAAABnpFLtotY2OIRH12BJh4MzMgn5Zil7-DVpIeuqlFwvr0g6g_n4ULogn-LNhCbtk6cCDkzZlqAHvBSX2e_zf7AsoyzbiQ==

 app/init_config/init_run_data.py

@@ -1,6 +1,6 @@
from app.models.base_model import SessionLocal
from app.service.v2.initialize_data import dialog_menu_sync, default_group_sync, default_role_sync, app_register_sync, \
    basic_agent_sync, admin_account_sync, admin_user_sync
from app.service.v2.initialize_data import dialog_menu_sync, default_group_sync, default_role_sync, \
    basic_agent_sync, admin_account_sync


async def sync_default_data():
@@ -9,10 +9,10 @@
        await dialog_menu_sync(db)  # 小数
        await default_group_sync(db)  # 默认组
        await default_role_sync(db)  # 默认角色
        await app_register_sync(db)  # 注册的应用
        # await app_register_sync(db)  # 注册的应用
        await basic_agent_sync(db)  # 开发的agent
        await admin_account_sync(db)  #
        await admin_user_sync(db)  #

    except Exception as e:
        print(e)
    finally:

 app/models/token_model.py

@@ -1,11 +1,6 @@
from datetime import datetime
from typing import Type

from sqlalchemy import Column, Integer, DateTime, Text, String
from sqlalchemy.orm import Session

from app.config.const import RAGFLOW
# from Log import logger
from app.models.base_model import Base


@@ -52,44 +47,6 @@
    except Exception as e:
        # 异常处理
        db.rollback()  # 回滚事务


async def update_token(db: Session, user_id: int, access_token: str, token: dict):
    # 参数验证
    if not isinstance(user_id, int) or user_id <= 0:
        return
    db_token = None
    # print(token)
    try:
        # 查询现有记录
        db_token = db.query(TokenModel).filter_by(user_id=user_id).first()
        if db_token:
            # 记录存在，进行更新
            db_token.token = access_token
            db_token.ragflow_token = token.get(RAGFLOW, "")
            # db_token.token = access_token
            # for k, v in token.items():
            #     setattr(db_token, k.replace("app", "token"), v)
        else:
            # 记录不存在，进行插入
            db_token = TokenModel(
                user_id=user_id,
                token=access_token,
                ragflow_token = token.get(RAGFLOW, "")
            )
            # for k, v in token.items():
            #     setattr(db_token, k.replace("app", "token"), v)
            db.add(db_token)

        # 提交事务
        db.commit()
        db.refresh(db_token)

    except Exception as e:
        # logger.error(e)
        # 异常处理
        db.rollback()  # 回滚事务



class ApiTokenModel(Base):

 app/models/v2/session_model.py

@@ -3,7 +3,7 @@

from datetime import datetime
from sqlalchemy.orm import Session
from typing import Optional, Type
from typing import Optional, Type, List
from pydantic import BaseModel
from sqlalchemy import Column, String, Integer, DateTime, JSON, TEXT, Index

@@ -43,9 +43,9 @@
            'session_id': self.id,
            'name': self.name,
            'agent_type': self.agent_type,
            'agent_id': self.agent_id,
            'chat_id': self.agent_id,
            'event_type': self.event_type,
            'session_type': self.session_type,
            'session_type': self.session_type if self.session_type else 0,
            'create_date': self.create_date.strftime("%Y-%m-%d %H:%M:%S"),
            'update_date': self.update_date.strftime("%Y-%m-%d %H:%M:%S"),
        }
@@ -55,7 +55,7 @@
            'id': self.id,
            'name': self.name,
            'agent_type': self.agent_type,
            'agent_id': self.agent_id,
            'chat_id': self.agent_id,
            'create_date': self.create_date.strftime("%Y-%m-%d %H:%M:%S"),
            'update_date': self.update_date.strftime("%Y-%m-%d %H:%M:%S"),
            'message': json.loads(self.message)
@@ -104,7 +104,7 @@
        return session

    async def update_session_by_id(self, session_id: str, session, message: dict, conversation_id=None) -> ChatSessionModel | None:
        print(message)
        # print(message)
        if not session:
            session = await self.get_session_by_id(session_id)
        if session:
@@ -133,3 +133,15 @@
        if session:
            self.db.delete(session)
            self.db.commit()

    async def get_session_list(self, user_id: int, agent_id: str, keyword:str, page: int, page_size: int) -> any:
        query = self.db.query(ChatSessionModel).filter(ChatSessionModel.tenant_id==user_id)
        if agent_id:
            query = query.filter(ChatSessionModel.agent_id==agent_id)
        if keyword:
            query = query.filter(ChatSessionModel.name.like('%{}%'.format(keyword)))
        total = query.count()
        session_list = query.order_by(ChatSessionModel.update_date.desc()).offset((page-1)*page_size).limit(page_size).all()
        return total, session_list



 app/service/auth.py

@@ -4,7 +4,6 @@
import base64
from datetime import datetime, timedelta
from typing import Type
from uuid import uuid4

from jwt import encode, decode, exceptions
from passlib.context import CryptContext
@@ -13,12 +12,9 @@

from Log import logger
from app.config.config import settings
from app.config.const import RAGFLOW, BISHENG, DIFY, USER_STATSU_DELETE, APP_SERVICE_PATH
from app.config.const import USER_STATSU_DELETE, APP_SERVICE_PATH
from app.models import RoleModel, GroupModel, TokenModel
from app.models.user_model import UserModel, UserAppModel
# from app.service.ragflow import RagflowService
# from app.service.service_token import get_new_token
from app.service.v2.app_register import AppRegisterDao

from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import serialization
@@ -113,7 +109,7 @@
        return False
    return True


"""
async def update_user_info(db, user_id):
    app_register = AppRegisterDao(db).get_apps()
    register_dict = {}
@@ -147,6 +143,8 @@
    # db.refresh(db_user)

    # is_sava = await save_register_user(db, user.username, user.password, user.email, register_dict)
"""


class UserAppDao:
    def __init__(self, db: Session):

 app/service/dialog.py

@@ -97,10 +97,19 @@


async def create_dialog_service(db, dialog_id, dialog_name, description, icon, dialog_type, mode, user_id):
    para = {
        "user_input_form": [],
        "retriever_resource": {
            "enabled": True
        },
        "file_upload": {
            "enabled": False
        }
    }
    try:
        dialog_model = DialogModel(id=dialog_id, name=dialog_name, description=description, icon=icon,
                                   dialog_type=dialog_type, tenant_id=user_id, mode=mode, update_date=datetime.now(),
                                   create_date=datetime.now())
                                   create_date=datetime.now(), parameters=json.dumps(para))
        db.add(dialog_model)
        db.commit()
        db.refresh(dialog_model)

 app/service/service_token.py

@@ -2,7 +2,6 @@
from app.config.config import settings
from app.config.const import BISHENG, RAGFLOW, DIFY
from app.models import UserModel, UserAppModel
from app.models.base_model import SessionLocal
from app.models.token_model import TokenModel
from app.service.auth import UserAppDao
from app.service.bisheng import BishengService

 app/service/user.py

@@ -1,11 +1,7 @@
import time
import uuid
from datetime import datetime
from traceback import print_tb

from app.api import pwd_context
from app.api.dialog import dialog_list
from app.config.config import settings
from app.config.const import RAGFLOW, BISHENG, DIFY, USER_STATSU_DELETE, ROLE_STATUS_ON, DEPT_STATUS_ON, \
    Dialog_STATSU_ON
from app.models import RoleModel, GroupModel, AgentType, role_resource_table, DialogModel, OrganizationModel, \
@@ -13,13 +9,7 @@
from app.models.menu_model import WebMenuModel, MenuCapacityModel
from app.models.user_model import UserModel, UserAppModel
from Log import logger
from app.service.auth import UserAppDao
from app.service.bisheng import BishengService
from app.service.v2.app_register import AppRegisterDao
from app.service.difyService import DifyService
from app.service.ragflow import RagflowService
from app.service.service_token import get_ragflow_token, get_bisheng_token, get_new_token, get_dify_token
from app.utils.password_handle import generate_password



async def get_user_list(db, page_index: int, page_size: int, keyword: str, role_key: str, user_id):

 app/service/v2/app_driver/chat_dialog.py

@@ -9,7 +9,7 @@
    async def chat_completions(self, url, data, headers):
        complete_response = ""
        async for line in self.http_stream(url, data, headers):
            print(line)
            # print(line)
            if line.startswith("data:"):
                complete_response = line.strip("data:").strip()
            else:

 app/service/v2/app_register.py

@@ -16,22 +16,23 @@

        return session

    def update_app(self, app_id: str, status: int):
    def update_app(self, app_id: str, status: int, name):

        logger.error("更新数据: app register---------------------------")
        try:
            self.db.query(AppRegisterModel).filter(AppRegisterModel.id==app_id).update({"status":status, "updated_at": datetime.now()})
            self.db.query(AppRegisterModel).filter(AppRegisterModel.id==app_id).update({"status":status, "updated_at": datetime.now(), "name": name})
            self.db.commit()
        except Exception as e:
            logger.error(e)
            self.db.rollback()
            raise Exception("更新失败！")

    def insert_app(self, app_id: str, status: int):
    def insert_app(self, app_id: str, status: int, name: str):
        logger.error("新增数据: app register---------------------------")
        new_session = AppRegisterModel(
            id=app_id,
            status=status
            status=status,
            name=name
        )
        self.db.add(new_session)
        self.db.commit()
@@ -39,14 +40,14 @@
        return new_session


    def update_and_insert_app(self, app_id: str, status: int):
    def update_and_insert_app(self, app_id: str, status: int, name=""):

        logger.error("更新或者添加数据: app register---------------------------")
        token_boj = self.get_app_by_id(app_id)
        if token_boj:
            self.update_app(app_id, status)
            self.update_app(app_id, status, name)
        else:
            self.insert_app(app_id, status)
            self.insert_app(app_id, status, name)


    def get_apps(self):

 app/service/v2/chat.py

@@ -28,13 +28,13 @@


async def add_session_log(db, session_id: str, question: str, chat_id: str, user_id, event_type: str,
                          conversation_id: str):
                          conversation_id: str, agent_type):
    try:
        session = await ChatSessionDao(db).update_or_insert_by_id(
            session_id=session_id,
            name=question[:255],
            agent_id=chat_id,
            agent_type=1,
            agent_type=agent_type,
            tenant_id=user_id,
            message={"role": "user", "content": question},
            conversation_id=conversation_id,
@@ -88,7 +88,7 @@
    token = await get_chat_token(db, rg_api_token)
    url = settings.fwr_base_url + RG_CHAT_DIALOG.format(chat_id)
    chat = ChatDialog()
    session = await add_session_log(db, session_id, question, chat_id, user_id, mode, session_id)
    session = await add_session_log(db, session_id, question, chat_id, user_id, mode, session_id, 1)
    if session:
        conversation_id = session.conversation_id
    message = {"role": "assistant", "answer": "", "reference": {}}
@@ -129,13 +129,35 @@
        except:
            ...
    finally:
        message["role"] = "assistant"
        await update_session_log(db, session_id, message, conversation_id)

async def data_process(data):
    if isinstance(data, str):
        return data.replace("dify", "smart")
    elif isinstance(data, dict):
        for k in list(data.keys()):
            if isinstance(k, str) and "dify" in k:
                new_k = k.replace("dify", "smart")
                data[new_k] = await data_process(data[k])
                del data[k]
            else:
                data[k] = await data_process(data[k])
        return data
    elif isinstance(data, list):
        for i in range(len(data)):
            data[i] = await data_process(data[i])
        return data
    else:
        return data


async def service_chat_workflow(db, chat_id: str, chat_data: ChatData, session_id: str, user_id, mode: str):
    conversation_id = ""
    answer_event = ""
    answer_agent = ""
    answer_workflow = ""
    download_url = ""
    message_id = ""
    task_id = ""
    error = ""
@@ -147,7 +169,7 @@
        query = chat_data.query
    else:
        query = "start new workflow"
    session = await add_session_log(db, session_id, query, chat_id, user_id, mode, conversation_id)
    session = await add_session_log(db, session_id, query, chat_id, user_id, mode, conversation_id, 3)
    if session:
        conversation_id = session.conversation_id
    try:
@@ -179,14 +201,17 @@
                event = smart_message_file
            elif ans.get("event") in [workflow_started, node_started, node_finished]:
                data = ans.get("data", {})
                data["inputs"] = []
                data["outputs"] = []
                data["inputs"] = await data_process(data.get("inputs", {}))
                data["outputs"] = await data_process(data.get("outputs", {}))
                data["files"] = await data_process(data.get("files", []))
                data["process_data"] = ""
                node_list.append(ans)
                event = [smart_workflow_started, smart_node_started, smart_node_finished][
                    [workflow_started, node_started, node_finished].index(ans.get("event"))]
            elif ans.get("event") == workflow_finished:
                data = ans.get("data", {})
                answer_workflow = data.get("outputs", {}).get("output")
                download_url = data.get("outputs", {}).get("download_url")
                event = smart_workflow_finished
                node_list.append(ans)

@@ -209,7 +234,8 @@
        except:
            ...
    finally:
        await update_session_log(db, session_id, {"role": "assistant", "answer": answer_event or answer_agent,
        await update_session_log(db, session_id, {"role": "assistant", "answer": answer_event or answer_agent or answer_workflow,
                                                  "download_url":download_url,
                                                  "node_list": node_list, "task_id": task_id, "id": message_id,
                                                  "error": error}, conversation_id)

@@ -223,22 +249,6 @@
    if not chat_info:
        return {}
    return chat_info.parameters
    # if chat_info.dialog_type == RG_TYPE:
    #     return {"retriever_resource":
    #         {
    #             "enabled": True
    #         }
    #     }
    # elif chat_info.dialog_type == BASIC_TYPE:
    #     ...
    # elif chat_info.dialog_type == DF_TYPE:
    #     token = await get_chat_token(db, chat_id)
    #     if not token:
    #         return {}
    #     url = settings.dify_base_url + DF_CHAT_PARAMETERS
    #     chat = ChatBaseApply()
    #     return await chat.chat_get(url, {"user": str(user_id)}, await chat.get_headers(token))


async def service_chat_sessions(db, chat_id, name):
    token = await get_chat_token(db, rg_api_token)
@@ -247,6 +257,24 @@
    url = settings.fwr_base_url + RG_CHAT_SESSIONS.format(chat_id)
    chat = ChatDialog()
    return await chat.chat_sessions(url, {"name": name}, await chat.get_headers(token))


async def service_chat_sessions_list(db, chat_id, current, page_size, user_id, keyword):
    total, session_list = await ChatSessionDao(db).get_session_list(
        user_id=user_id,
        agent_id=chat_id,
        keyword=keyword,
        page=current,
        page_size=page_size
    )
    return json.dumps({"total":total, "rows": [session.to_dict() for session in session_list]})



async def service_chat_session_log(db, session_id):
    session_log = await ChatSessionDao(db).get_session_by_id(session_id)
    return json.dumps(session_log.log_to_json())



async def service_chat_upload(db, chat_id, file, user_id):
@@ -277,14 +305,6 @@
    tokenizer = get_tokenizer('qwen-turbo')
    # 将字符串切分成token并转换为token id
    tokens = tokenizer.encode(input_str)
    # print(f"经过切分后的token id为：{tokens}。")
    # # 经过切分后的token id为： [31935, 64559, 99320, 56007, 100629, 104795, 99788, 1773]
    # print(f"经过切分后共有{len(tokens)}个token")
    # # 经过切分后共有8个token
    #
    # # 将token id转化为字符串并打印出来
    # for i in range(len(tokens)):
    #     print(f"token id为{tokens[i]}对应的字符串为：{tokenizer.decode(tokens[i])}")
    return len(tokens)

async def read_pdf(pdf_stream):

 app/service/v2/initialize_data.py

@@ -8,7 +8,7 @@

from Log import logger
# from app.api import pwd_context
from app.config.const import DIFY, ENV_CONF_PATH, RAGFLOW
from app.config.const import DIFY, ENV_CONF_PATH, RAGFLOW, smart_server, chat_server, workflow_server
from app.models import MenuCapacityModel, WebMenuModel, GroupModel, RoleModel, DialogModel, UserModel, UserAppModel, \
    cipher_suite, UserTokenModel
from app.service.auth import UserAppDao
@@ -18,7 +18,7 @@
from app.service.service_token import get_new_token
from app.service.v2.app_register import AppRegisterDao
from app.config.config import settings
from app.utils.password_handle import generate_password
from app.utils.password_handle import generate_password, password_encrypted, password_decrypted

pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")

@@ -114,16 +114,16 @@
            logger.error(e)


async def app_register_sync(db):
    app_dict = {}
    with open(os.path.join(ENV_CONF_PATH, "app_register_conf.json"), 'r', encoding='utf-8') as file:
        # 加载JSON数据
        app_dict = json.load(file)
        try:
            for app_id, status in app_dict.items():
                AppRegisterDao(db).update_and_insert_app(app_id, status)
        except Exception as e:
            logger.error(e)
# async def app_register_sync(db):
#     app_dict = {}
#     with open(os.path.join(ENV_CONF_PATH, "app_register_conf.json"), 'r', encoding='utf-8') as file:
#         # 加载JSON数据
#         app_dict = json.load(file)
#         try:
#             for app_id, status in app_dict.items():
#                 AppRegisterDao(db).update_and_insert_app(app_id, status)
#         except Exception as e:
#             logger.error(e)


async def basic_agent_sync(db):
@@ -234,8 +234,10 @@
async def admin_account_sync(db):
    try:
        config = {}
        app_dict = {}
        tmp_dict = {chat_server:RAGFLOW, workflow_server:DIFY}
        now_account  =[]
        with open(os.path.join(ENV_CONF_PATH, "account.yaml"), 'r', encoding='utf-8') as file:
        with open(os.path.join(ENV_CONF_PATH, "admin.yaml"), 'r', encoding='utf-8') as file:
            # 加载JSON数据
            config = yaml.safe_load(file)
        account_list = db.query(UserTokenModel).all()
@@ -250,11 +252,38 @@
                now_account.append(account.id)
            else:
                db.query(UserTokenModel).filter_by(id=account.id).delete()

        for k, v in config.items():
            if k in tmp_dict:
                app_dict[tmp_dict[k]] = v.get("id")
            if k == smart_server:
                db_user = db.query(UserModel).filter(UserModel.username == config["smart_server"]["account"]).first()
                if db_user:
                    print("admin_user_sync: 用户已经存在！")
                    continue
                hashed_password = pwd_context.hash(await password_decrypted(config["smart_server"]["password"]))  # config["smart_server"]["password"]
                user_model = UserModel(username=config["smart_server"]["account"], hashed_password=hashed_password,
                                       email="",
                                       phone="", login_name="", sync_flag="", creator=0, permission="admin")
                db.add(user_model)
                # db.commit()
                # db.refresh(user_model)
            else:
            if k not in now_account:
                new_account = UserTokenModel(id=k, account=v["account"], password=v["password"])
                db.add(new_account)

        db.commit()

        # with open(os.path.join(ENV_CONF_PATH, "app_register_conf.json"), 'r', encoding='utf-8') as file:
        #     # 加载JSON数据
        #     app_dict = json.load(file)
        try:
            for app_id, name in app_dict.items():
                AppRegisterDao(db).update_and_insert_app(app_id, 1, name)
        except Exception as e:
            logger.error(e)

    except Exception as e:
        print(e)
        db.rollback()
@@ -269,12 +298,12 @@
        if db_user:
            print("admin_user_sync: 用户已经存在！")
            return
        register_dict = {}

        for app in [RAGFLOW, DIFY]:
            register_dict[app] = {"id": config[app].get("id", "123"), "name": config[app]["account"],
                                        "pwd":config[app]["password"],
                                        "email": config[app]["account"]}
        # register_dict = {}
        #
        # for app in [RAGFLOW, DIFY]:
        #     register_dict[app] = {"id": config[app].get("id", "123"), "name": config[app]["account"],
        #                                 "pwd":config[app]["password"],
        #                                 "email": config[app]["account"]}

        # 存储用户信息
        hashed_password = pwd_context.hash(config["smart_server"]["password"])
@@ -283,10 +312,10 @@
        db.add(user_model)
        db.commit()
        db.refresh(user_model)
        u_id = user_model.id
        user_app_dao = UserAppDao(db)
        for k, v in register_dict.items():
            await user_app_dao.update_and_insert_data(v.get("name"), user_model.encrypted_password(v.get("pwd")), v.get("email"), u_id, str(v.get("id")), k)
        # u_id = user_model.id
        # user_app_dao = UserAppDao(db)
        # for k, v in register_dict.items():
        #     await user_app_dao.update_and_insert_data(v.get("name"), user_model.encrypted_password(v.get("pwd")), v.get("email"), u_id, str(v.get("id")), k)
    except Exception as e:
        print(e)
        db.rollback()

 app/task/fetch_agent.py

@@ -239,7 +239,7 @@
        db.close()


def get_data_from_ragflow_v2(names: List[str]) -> List[Dict]:
def get_data_from_ragflow_v2(names: List[str], tenant_id) -> List[Dict]:
    db = SessionRagflow()
    para = {
        "user_input_form": [],
@@ -256,7 +256,7 @@
                .filter(Dialog.name.in_(names), Dialog.status == "1")
        else:
            query = db.query(Dialog.id, Dialog.name, Dialog.description, Dialog.status, Dialog.tenant_id).filter(
                Dialog.status == "1")
                Dialog.status == "1", Dialog.tenant_id == tenant_id)

        results = query.all()
        formatted_results = [
@@ -320,12 +320,12 @@
        db.close()


def get_data_from_ragflow_knowledge():
def get_data_from_ragflow_knowledge(tenant_id):
    db = SessionRagflow()
    try:

        results = db.query(RgKnowledge.id, RgKnowledge.name, RgKnowledge.description, RgKnowledge.status,
                           RgKnowledge.tenant_id, RgKnowledge.doc_num, RgKnowledge.permission).all()
                           RgKnowledge.tenant_id, RgKnowledge.doc_num, RgKnowledge.permission).filter(RgKnowledge.tenant_id==tenant_id).all()
        formatted_results = [
            {"id": row[0], "name": row[1], "description": row[2], "status": str(row[3]),
             "user_id": str(row[4]), "doc_num": row[5], "permission": row[6]} for row in results]
@@ -340,18 +340,17 @@
    try:
        app_register = AppRegisterDao(db).get_apps()
        for app in app_register:
            try:
            if app["id"] == RAGFLOW:
                ragflow_data = get_data_from_ragflow_v2([])
                    ragflow_data = get_data_from_ragflow_v2([], app["name"])
                if ragflow_data:
                    update_ids_in_local_v2(ragflow_data, "1")
            # elif app["id"] == BISHENG:
            #     bisheng_data = get_data_from_bisheng_v2([])
            #     if bisheng_data:
            #         update_ids_in_local_v2(bisheng_data, "2")
            elif app["id"] == DIFY:
                dify_data = get_data_from_dy_v2([])
                if dify_data:
                    update_ids_in_local_v2(dify_data, "4")
            except Exception as e:
                print(f"Failed to sync agents: {str(e)}")
        print("v2 Agents synchronized successfully")
    except Exception as e:
        print(f"v2 Failed to sync agents: {str(e)}")
@@ -412,7 +411,7 @@
        app_register = AppRegisterDao(db).get_apps()
        for app in app_register:
            if app["id"] == RAGFLOW:
                ragflow_data = get_data_from_ragflow_knowledge()
                ragflow_data = get_data_from_ragflow_knowledge(app["name"])
                if ragflow_data:
                    update_ids_in_local_knowledge(ragflow_data, "1")
            # elif app["id"] == BISHENG:

 app/utils/password_handle.py

@@ -31,13 +31,13 @@

async def password_encrypted(password):
    hash_pwd = cipher_suite.encrypt(password.encode("utf-8")).decode("utf-8")
    print(hash_pwd)
    # print(hash_pwd)
    return hash_pwd


async def password_decrypted(hash_password):
    pwd = cipher_suite.decrypt(hash_password).decode("utf-8")
    print(pwd)
    # print(pwd)
    return pwd
if __name__ == "__main__":
    # 生成一个10位的密码

 main.py

@@ -29,7 +29,7 @@
from app.task.fetch_agent import sync_agents, initialize_agents, sync_agents_v2, sync_knowledge, \
    sync_resources_from_json
from app.init_config.init_run_data import sync_default_data
from app.task.sync_account_token import start_sync_token_task
from app.task.sync_account_token import start_sync_token_task, sync_token

init_db()

@@ -44,10 +44,10 @@


    await sync_default_data()
    sync_agents_v2()
    sync_knowledge()
    sync_agents_v2() # 智能体
    sync_knowledge() # 知识库
    sync_resources_from_json()
    # start_sync_token_task()
    await sync_token()  # 启动同步token任务
    yield
    # 在应用关闭时执行清理操作（如果需要）
    pass