新增：个人应用分享

packages/dbgpt-app/src/dbgpt_app/dbgpt_server.py

@@ -70,6 +70,7 @@ def mount_routers(app: FastAPI):
     from dbgpt_system.sys_type.controller import router as type_v1
     from dbgpt_system.upload_image.controller import router as upload_image_v1
     from dbgpt_system.app_description.controller import router as app_description_v1
+    from dbgpt_system.sys_agent_user_share.agent_user_share_controller import  router as user_share_v1
     app.include_router(api_v1, prefix="/api", tags=["Chat"])
     app.include_router(api_v2, prefix="/api", tags=["ChatV2"])
     app.include_router(api_editor_route_v1, prefix="/api", tags=["Editor"])
@@ -85,7 +86,7 @@ def mount_routers(app: FastAPI):
     app.include_router(upload_image_v1,prefix = "/api/upload_image",tags=["upload_image"])
     app.include_router(app_description_v1,prefix = "/api/app_description",tags=["app_description"])
     app.include_router(knowledge_router, tags=["Knowledge"])
-
+    app.include_router(user_share_v1,prefix = "/api/agent_user_share",tags= ["AgentUserShare"])
     from dbgpt_serve.agent.app.recommend_question.controller import (
         router as recommend_question_v1,
     )

packages/dbgpt-system/src/dbgpt_system/sys_agent_user_share/agent_user.py

@@ -0,0 +1,137 @@
+import re
+
+from dbgpt._private.pydantic import  BaseModel,ConfigDict,Field,field_validator
+from typing import Any,Dict,List,Optional
+from dbgpt.storage.metadata import  Model
+from datetime import datetime
+from sqlalchemy import (
+    Column,
+    DateTime,
+    Integer,
+    String,
+)
+
+class AgentUserShare(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+    id: Optional[int] = None
+    share_name: Optional[str] = None
+    validity_period: Optional[str] = None
+    start_time: Optional[datetime] = None
+    end_time: Optional[datetime] = None
+    api_key: Optional[str] = None
+    share_type: Optional[str] = None
+    app_ids: Optional[str] = None
+    api_root_url: Optional[str] = None
+    share_user_id: Optional[int] = None
+    creator: Optional[str] = None
+    create_time: Optional[datetime] = None
+    update_time: Optional[datetime] = None
+    updater: Optional[str] = None
+    deleted: Optional[str] = None
+
+    def to_dict(self):
+        return {k: self._serialize(v) for k, v in self.__dict__.items()}
+
+    def _serialize(self, value):
+        if isinstance(value, BaseModel):
+            return value.to_dict()
+        elif isinstance(value, list):
+            return [self._serialize(item) for item in value]
+        elif isinstance(value, dict):
+            return {k: self._serialize(v) for k, v in value.items()}
+        else:
+            return value
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]):
+        return cls(
+            id=d.get("id", None),
+            share_name=d.get("share_name", None),
+            validity_period=d.get("validity_period", None),
+            start_time=d.get("start_time", None),
+            end_time=d.get("end_time", None),
+            api_key=d.get("api_key", None),
+            share_type=d.get("share_type", None),
+            app_ids=d.get("app_ids", None),
+            api_root_url=d.get("api_root_url", None),
+            share_user_id=d.get("share_user_id", None),
+            update_time=d.get("update_time", None),
+            updater=d.get("updater", None),
+            create_time=d.get("create_time", None),
+            creator=d.get("creator", None),
+            deleted=d.get("deleted", None),
+        )
+
+class AgentUserShareSave(BaseModel):
+    share_name: Optional[str] = None
+    validity_period: Optional[str] = None
+    start_time: Optional[datetime] = None
+    end_time: Optional[datetime] = None
+    api_key: Optional[str] = None
+    share_type: Optional[str] = None
+    app_ids: Optional[str] = None
+    api_root_url: Optional[str] = None
+    share_user_id: Optional[int] = None
+    creator: Optional[str] = None
+    create_time: Optional[datetime] = None
+    update_time: Optional[datetime] = None
+    updater: Optional[str] = None
+    deleted: Optional[str] = None
+
+    @field_validator('share_name')
+    def validate_username(cls, v):
+        if not v:
+            raise ValueError("分享名称不能为空")
+        if not (2 <= len(v) <= 20):
+            raise ValueError('用户名必须为2-20个字符')
+        return v
+
+
+class AgentUserShareUpdate(BaseModel):
+    id: Optional[int] = None
+    share_name: Optional[str] = None
+    validity_period: Optional[str] = None
+    start_time: Optional[datetime] = None
+    end_time: Optional[datetime] = None
+    share_type: Optional[str] = None
+    app_ids: Optional[str] = None
+    api_root_url: Optional[str] = None
+    update_time: Optional[datetime] = None
+    updater: Optional[str] = None
+
+    @field_validator('share_name')
+    def validate_username(cls, v):
+        if not v:
+            raise ValueError("分享名称不能为空")
+        if not (2 <= len(v) <= 20):
+            raise ValueError('用户名必须为2-20个字符')
+        return v
+class AgentUserShareEntity(Model):
+    __tablename__ = "agent_user_share"
+    id = Column(Integer, primary_key=True)
+    share_name= Column(String(255))
+    validity_period= Column(String(1))
+    start_time= Column(DateTime)
+    end_time= Column(DateTime)
+    api_key= Column(String(255))
+    share_type= Column(String(2))
+    app_ids= Column(String(255))
+    api_root_url= Column(String(255))
+    share_user_id= Column(String(255))
+    creator= Column(String(35))
+    create_time= Column(DateTime)
+    update_time= Column(DateTime)
+    updater= Column(String(35))
+    deleted= Column(String(1))
+
+class AgentUserShareQuery(AgentUserShare):
+    page_size: int = 100
+    page: int = 1
+
+class AgentUserShareResponse(BaseModel):
+    total_count: Optional[int] = 0
+    total_page: Optional[int] = 0
+    current_page: Optional[int] = 0
+    agent_user_share_list: Optional[List[AgentUserShare]] = Field(
+        default_factory=list, description="AgentUserShare list"
+    )

packages/dbgpt-system/src/dbgpt_system/sys_agent_user_share/agent_user_share_controller.py

@@ -0,0 +1,77 @@
+from dbgpt_app.openapi.api_view_model import Result
+from fastapi import APIRouter, Depends,Header
+from dbgpt_system.sys_agent_user_share.agent_user_share_db import  AgentUserShareDao
+from dbgpt_system.sys_agent_user_share.agent_user import AgentUserShare, AgentUserShareQuery,AgentUserShareSave,AgentUserShareUpdate
+from dbgpt_serve.utils.auth import UserRequest, get_user_from_headers
+from dbgpt_system.util.UUIDGenerator import UUIDGenerator
+from datetime import  datetime
+router = APIRouter()
+agentUserShareDao = AgentUserShareDao()
+uuidGenerator = UUIDGenerator()
+@router.get("/list",response_model=Result)
+async  def select_user_share_list(
+        agentUserShare: AgentUserShareQuery = Depends(),
+        user_info: UserRequest = Depends(get_user_from_headers)
+):
+    try:
+        agentUserShare.share_user_id =user_info.user_id
+        res = agentUserShareDao.select_agent_user_share_page(agentUserShare)
+        return  Result.succ(res)
+    except Exception as ex:
+        print(ex)
+        return Result.failed(msg=f"query agent_user_share error: {ex}")
+
+@router.post("/create")
+async  def create_agent_user_share(
+        agentUserShare: AgentUserShareSave,
+        user_info: UserRequest = Depends(get_user_from_headers)
+):
+    try:
+        # 验证名称是否重复
+        if agentUserShareDao.select_user_share_by_name(agentUserShare.share_name,user_info.user_id):
+            return Result.failed(msg=f"分享名称重复")
+        # 生成随机分享码
+        agentUserShare.api_key = 'cjy-'+uuidGenerator.generate_uuid32()
+        agentUserShare.share_user_id = user_info.user_id
+        agentUserShare.creator = user_info.user_id
+        agentUserShare.create_time = datetime.now()
+        agentUserShare.updater = user_info.user_id
+        agentUserShare.update_time = datetime.now()
+        return Result.succ(agentUserShareDao.create(agentUserShare))
+    except Exception as ex:
+        print(ex)
+        return Result.failed(msg=f"create agent_user_share error: {ex}")
+
+@router.put("/update")
+async  def update_agent_user_share(
+       agentUserShareUpdate: AgentUserShareUpdate,
+       user_info: UserRequest = Depends(get_user_from_headers)
+):
+    try:
+        agentUserShareUpdate.updater = user_info.user_id
+        agentUserShareUpdate.update_time = datetime.now()
+        return Result.succ(agentUserShareDao.update(agentUserShareUpdate))
+    except Exception as ex:
+        print(ex)
+        return Result.failed(msg=f"update agent_user_share error: {ex}")
+@router.get("/get")
+async  def select_agent_user_share_detail(
+       id: int,
+       user_info: UserRequest = Depends(get_user_from_headers)
+):
+    try:
+        return Result.succ(agentUserShareDao.select_user_share_details(id))
+    except Exception as ex:
+        print(ex)
+        return Result.failed(msg=f"select agent_user_share error: {ex}")
+
+@router.delete("/delete")
+async  def delete_agent_user_share(
+        id: int,
+        user_info: UserRequest = Depends(get_user_from_headers)
+):
+    try:
+        return Result.succ(agentUserShareDao.delete_user_share(id))
+    except Exception as ex:
+        print(ex)
+        return Result.failed(msg=f"delete agent_user_share error: {ex}")

packages/dbgpt-system/src/dbgpt_system/sys_agent_user_share/agent_user_share_db.py

@@ -0,0 +1,153 @@
+
+from dbgpt.storage.metadata import BaseDao
+from dbgpt_system.sys_agent_user_share.agent_user import  AgentUserShare,AgentUserShareQuery,AgentUserShareResponse,AgentUserShareSave,AgentUserShareUpdate,AgentUserShareEntity
+from datetime import  datetime
+
+
+
+class AgentUserShareDao(BaseDao):
+    def select_agent_user_share(self,agent_user_share: AgentUserShareEntity):
+        session = self.get_raw_session()
+
+        return None;
+    def select_agent_user_share_page(self,agent_user_share: AgentUserShareQuery):
+        session = self.get_raw_session()
+        try:
+            agent_user_share_query = session.query(AgentUserShareEntity).filter(AgentUserShareEntity.deleted == '0').filter(AgentUserShareEntity.share_user_id == agent_user_share.share_user_id)
+            if(agent_user_share.share_name):
+                agent_user_share_query = agent_user_share_query.filter(
+                    AgentUserShareEntity.share_name.like(f"%{agent_user_share.share_name}%")
+                )
+            total_count = agent_user_share_query.count()
+            user_qry = agent_user_share_query.order_by(AgentUserShareEntity.id.desc())
+            user_qry = agent_user_share_query.offset((agent_user_share.page - 1) * agent_user_share.page_size).limit(
+                agent_user_share.page_size
+            )
+            results = user_qry.all()
+        finally:
+            session.close()
+        if results is not None:
+            agent_user_shares = []
+            agent_user_share_resp = AgentUserShareResponse()
+            for share in results:
+                agent_user_shares.append(
+                    AgentUserShare.from_dict(
+                        {
+                            "id": share.id,
+                            "share_name": share.share_name,
+                            "validity_period": share.validity_period,
+                            "start_time": share.start_time,
+                            "end_time": share.end_time,
+                            "api_key": None,
+                            "share_type": share.share_type,
+                            "app_ids": share.app_ids,
+                            "api_root_url": share.api_root_url,
+                            "share_user_id": share.share_user_id,
+                            "creator": share.creator,
+                            "create_time": share.create_time,
+                            "update_time": share.update_time,
+                            "updater": share.updater
+                        }
+                    )
+                )
+                agent_user_share_resp.total_count = total_count
+                agent_user_share_resp.agent_user_share_list = agent_user_shares
+                agent_user_share_resp.current_page = agent_user_share.page
+                agent_user_share_resp.total_page = (total_count + agent_user_share.page_size - 1)
+                return agent_user_share_resp
+
+    def select_user_share_details(self,id:int):
+        session = self.get_raw_session()
+        try:
+            user_share_qry = session.query(AgentUserShareEntity).filter(AgentUserShareEntity.deleted == '0',AgentUserShareEntity.id == id)
+            user_share_details = user_share_qry.first()
+        finally:
+            session.close()
+        return AgentUserShare.from_dict(
+            {
+                "id": user_share_details.id,
+                "share_name": user_share_details.share_name,
+                "validity_period": user_share_details.validity_period,
+                "start_time": user_share_details.start_time,
+                "end_time": user_share_details.end_time,
+                "share_type": user_share_details.share_type,
+                "app_ids": user_share_details.app_ids,
+                "api_root_url": user_share_details.api_root_url,
+                "share_user_id": user_share_details.share_user_id,
+                "creator": user_share_details.creator,
+                "create_time": user_share_details.create_time,
+                "update_time": user_share_details.update_time,
+                "updater": user_share_details.updater
+            }
+        )
+
+    def create(self,user_share_create: AgentUserShareSave):
+        try:
+            with self.session() as session:
+                user_share = AgentUserShareEntity(
+                    share_name= user_share_create.share_name,
+                    validity_period= user_share_create.validity_period,
+                    start_time= user_share_create.start_time,
+                    end_time= user_share_create.end_time,
+                    api_key= user_share_create.api_key,
+                    share_type= user_share_create.share_type,
+                    app_ids= user_share_create.app_ids,
+                    api_root_url= user_share_create.api_root_url,
+                    share_user_id= user_share_create.share_user_id,
+                    creator= user_share_create.creator,
+                    create_time= user_share_create.create_time,
+                    update_time= user_share_create.update_time,
+                    updater= user_share_create.updater,
+                    deleted = '0'
+                )
+                session.add(user_share)
+                session.commit()
+            return user_share_create.api_key
+        except Exception as e:
+            session.rollback()
+            raise RuntimeError(f"创建应用分享失败: {str(e)}")
+        finally:
+            session.close()
+
+
+    def update(self,user_share_update:AgentUserShareUpdate):
+        session =self.get_raw_session()
+        with self.session() as session:
+            user_share_entity = session.query(AgentUserShareEntity).filter_by(id=user_share_update.id,deleted=0).first()
+            if user_share_entity:
+                user_share_entity.share_name = user_share_update.share_name
+                user_share_entity.validity_period = user_share_update.validity_period
+                user_share_entity.start_time = user_share_update.start_time
+                user_share_entity.end_time = user_share_update.end_time
+                user_share_entity.app_ids = user_share_update.app_ids
+                user_share_entity.updater = user_share_update.updater
+                user_share_entity.update_time =  datetime.now()
+                session.commit()
+            else:
+                raise ValueError("用户分享信息不存在")
+            session.close()
+            return True
+
+    def delete_user_share(self,ids: int):
+        with self.session() as session:
+            user_share_entity = session.query(AgentUserShareEntity).filter_by(id=ids,deleted=0).first()
+            if user_share_entity:
+                user_share_entity.deleted = 1
+            else:
+                raise ValueError("用户分享不存在或已删除")
+            session.commit()
+            session.close()
+            return True
+
+
+    def select_user_share_by_name(self, userShareName: str,userId:int):
+        session = self.get_raw_session()
+        try:
+            user_qry = session.query(AgentUserShareEntity).filter(AgentUserShareEntity.deleted == '0', AgentUserShareEntity.share_name == userShareName,AgentUserShareEntity.share_user_id==userId)
+            user_details = user_qry.first()
+        finally:
+            session.close()
+        if user_details is not None:
+            return True
+        else:
+            return False

packages/dbgpt-system/src/dbgpt_system/util/UUIDGenerator.py

@@ -0,0 +1,13 @@
+import uuid
+
+class UUIDGenerator:
+    def generate_uuid32(self):
+        full_uuid = str(uuid.uuid4())
+        uuid_32 = full_uuid.replace('-', '')
+        return uuid_32
+
+# Example usage
+if __name__ == "__main__":
+    generator = UUIDGenerator()
+    print(generator.generate_uuid33())
+