feat: (0.6)New UI (#1855)

Co-authored-by: 夏姜 <wenfengjiang.jwf@digital-engine.com>
Co-authored-by: aries_ckt <916701291@qq.com>
Co-authored-by: wb-lh513319 <wb-lh513319@alibaba-inc.com>
Co-authored-by: csunny <cfqsunny@163.com>

dbgpt/serve/agent/app/controller.py

@@ -1,6 +1,8 @@
+import json
 import logging
+from typing import List, Optional
 
-from fastapi import APIRouter
+from fastapi import APIRouter, Depends
 
 from dbgpt._private.config import Config
 from dbgpt.agent.core.agent_manage import get_agent_manager
@@ -13,9 +15,10 @@ from dbgpt.serve.agent.db.gpts_app import (
     GptsAppCollectionDao,
     GptsAppDao,
     GptsAppQuery,
-    GptsAppResponse,
+    native_app_params,
 )
 from dbgpt.serve.agent.team.base import TeamMode
+from dbgpt.serve.utils.auth import UserRequest, get_user_from_headers
 
 CFG = Config()
 
@@ -27,103 +30,217 @@ collection_dao = GptsAppCollectionDao()
 
 
 @router.post("/v1/app/create")
-async def create(gpts_app: GptsApp):
+async def create(
+    gpts_app: GptsApp, user_info: UserRequest = Depends(get_user_from_headers)
+):
     try:
+        gpts_app.user_code = (
+            user_info.user_id if user_info.user_id is not None else gpts_app.user_code
+        )
         return Result.succ(gpts_dao.create(gpts_app))
     except Exception as ex:
         return Result.failed(code="E000X", msg=f"create app error: {ex}")
 
 
-@router.post("/v1/app/list", response_model=Result[GptsAppResponse])
-async def app_list(query: GptsAppQuery):
+@router.post("/v1/app/list")
+async def app_list(
+    query: GptsAppQuery, user_info: UserRequest = Depends(get_user_from_headers)
+):
     try:
+        # query.user_code = (
+        #     user_info.user_id if user_info.user_id is not None else query.user_code
+        # )
+        query.ignore_user = "true"
         return Result.succ(gpts_dao.app_list(query, True))
     except Exception as ex:
-        return Result.failed(code="E000X", msg=f"query app error: {ex}")
+        logger.exception("app_list exception!")
+        return Result.failed(code="E000X", msg=f"query app list error: {ex}")
+
+
+@router.get("/v1/app/info")
+async def app_detail(
+    chat_scene: str,
+    app_code: str = None,
+):
+    logger.info(f"app_detail:{chat_scene},{app_code}")
+    try:
+        if app_code:
+            return Result.succ(gpts_dao.app_detail(app_code))
+        else:
+            from dbgpt.app.scene.base import ChatScene
+
+            scene: ChatScene = ChatScene.of_mode(chat_scene)
+            return Result.succ(gpts_dao.native_app_detail(scene.scene_name()))
+    except Exception as ex:
+        logger.exception("query app detail error!")
+        return Result.failed(code="E000X", msg=f"query app detail error: {ex}")
+
+
+@router.get("/v1/app/export")
+async def app_export(
+    chat_scene: str,
+    app_code: str = None,
+):
+    logger.info(f"app_export:{app_code}")
+    try:
+        if app_code:
+            app_info = gpts_dao.app_detail(app_code)
+        else:
+            from dbgpt.app.scene.base import ChatScene
+
+            scene: ChatScene = ChatScene.of_mode(chat_scene)
+            app_info = gpts_dao.native_app_detail(scene.scene_name())
+
+        return Result.succ(app_info)
+    except Exception as ex:
+        logger.exception("export app info error!")
+        return Result.failed(code="E000X", msg=f"export app info error: {ex}")
+
+
+@router.get("/v1/app/{app_code}")
+async def get_app_by_code(
+    app_code: str,
+):
+    try:
+        return Result.succ(gpts_dao.app_detail(app_code))
+    except Exception as ex:
+        logger.exception("query app detail error!")
+        return Result.failed(code="E000X", msg=f"query app detail error: {ex}")
+
+
+@router.post("/v1/app/hot/list")
+async def hot_app_list(
+    query: GptsAppQuery, user_info: UserRequest = Depends(get_user_from_headers)
+):
+    try:
+        query.user_code = (
+            user_info.user_id if user_info.user_id is not None else query.user_code
+        )
+        list_hot_apps = gpts_dao.list_hot_apps(query)
+        return Result.succ(list_hot_apps)
+    except Exception as ex:
+        logger.exception("hot_app_list exception！")
+        return Result.failed(code="E000X", msg=f"query hot app error: {ex}")
 
 
 @router.post("/v1/app/detail")
-async def app_list(gpts_app: GptsApp):
+async def app_list(
+    gpts_app: GptsApp, user_info: UserRequest = Depends(get_user_from_headers)
+):
     try:
+        gpts_app.user_code = (
+            user_info.user_id if user_info.user_id is not None else gpts_app.user_code
+        )
         return Result.succ(gpts_dao.app_detail(gpts_app.app_code))
     except Exception as ex:
         return Result.failed(code="E000X", msg=f"query app error: {ex}")
 
 
 @router.post("/v1/app/edit")
-async def edit(gpts_app: GptsApp):
+async def edit(
+    gpts_app: GptsApp, user_info: UserRequest = Depends(get_user_from_headers)
+):
     try:
+        gpts_app.user_code = (
+            user_info.user_id if user_info.user_id is not None else gpts_app.user_code
+        )
         return Result.succ(gpts_dao.edit(gpts_app))
     except Exception as ex:
+        logger.exception(" app edit exception!")
         return Result.failed(code="E000X", msg=f"edit app error: {ex}")
 
 
 @router.get("/v1/agents/list")
-async def all_agents():
+async def all_agents(user_info: UserRequest = Depends(get_user_from_headers)):
     try:
-        return Result.succ(get_agent_manager().list_agents())
+        agents = get_agent_manager().list_agents()
+        for agent in agents:
+            label = agent["name"]
+            agent["label"] = label
+        return Result.succ(agents)
     except Exception as ex:
         return Result.failed(code="E000X", msg=f"query agents error: {ex}")
 
 
-@router.post("/v1/app/remove")
-async def delete(gpts_app: GptsApp):
+@router.post("/v1/app/remove", response_model=Result)
+async def delete(
+    gpts_app: GptsApp, user_info: UserRequest = Depends(get_user_from_headers)
+):
     try:
+        gpts_app.user_code = (
+            user_info.user_id if user_info.user_id is not None else gpts_app.user_code
+        )
         gpts_dao.delete(gpts_app.app_code, gpts_app.user_code, gpts_app.sys_code)
-        return Result.succ(None)
+        return Result.succ()
     except Exception as ex:
+        logger.exception("app remove exception!")
         return Result.failed(code="E000X", msg=f"delete app error: {ex}")
 
 
-@router.post("/v1/app/collect", response_model=Result[str])
-async def collect(gpts_app: GptsApp):
+@router.post("/v1/app/collect", response_model=Result)
+async def collect(
+    gpts_app: GptsApp, user_info: UserRequest = Depends(get_user_from_headers)
+):
     try:
+        gpts_app.user_code = (
+            user_info.user_id if user_info.user_id is not None else gpts_app.user_code
+        )
         collection_dao.collect(gpts_app.app_code, gpts_app.user_code, gpts_app.sys_code)
-        return Result.succ([])
+        return Result.succ()
     except Exception as ex:
         return Result.failed(code="E000X", msg=f"collect app error: {ex}")
 
 
-@router.post("/v1/app/uncollect", response_model=Result[str])
-async def uncollect(gpts_app: GptsApp):
+@router.post("/v1/app/uncollect", response_model=Result)
+async def uncollect(
+    gpts_app: GptsApp, user_info: UserRequest = Depends(get_user_from_headers)
+):
     try:
+        gpts_app.user_code = (
+            user_info.user_id if user_info.user_id is not None else gpts_app.user_code
+        )
         collection_dao.uncollect(
             gpts_app.app_code, gpts_app.user_code, gpts_app.sys_code
         )
-        return Result.succ([])
+        return Result.succ()
     except Exception as ex:
         return Result.failed(code="E000X", msg=f"uncollect app error: {ex}")
 
 
 @router.get("/v1/team-mode/list")
-async def team_mode_list():
+async def team_mode_list(user_info: UserRequest = Depends(get_user_from_headers)):
     try:
-        return Result.succ([mode.value for mode in TeamMode])
+        return Result.succ([mode.to_dict() for mode in TeamMode])
     except Exception as ex:
+        logger.exception(str(ex))
         return Result.failed(code="E000X", msg=f"query team mode list error: {ex}")
 
 
 @router.get("/v1/resource-type/list")
-async def team_mode_list():
+async def team_mode_list(user_info: UserRequest = Depends(get_user_from_headers)):
     try:
-        resources = get_resource_manager().get_supported_resources(version="v1")
-        return Result.succ(list(resources.keys()))
+        resources = get_resource_manager().get_supported_resources_type()
+        return Result.succ(resources)
     except Exception as ex:
+        logger.exception(str(ex))
         return Result.failed(code="E000X", msg=f"query resource type list error: {ex}")
 
 
 @router.get("/v1/llm-strategy/list")
-async def llm_strategies():
+async def llm_strategies(user_info: UserRequest = Depends(get_user_from_headers)):
     try:
-        return Result.succ([type.value for type in LLMStrategyType])
+        return Result.succ([type.to_dict() for type in LLMStrategyType])
     except Exception as ex:
+        logger.exception(str(ex))
         return Result.failed(
             code="E000X", msg=f"query llm strategy type list error: {ex}"
         )
 
 
 @router.get("/v1/llm-strategy/value/list")
-async def llm_strategy_values(type: str):
+async def llm_strategy_values(
+    type: str, user_info: UserRequest = Depends(get_user_from_headers)
+):
     try:
         results = []
         match type:
@@ -131,21 +248,111 @@ async def llm_strategy_values(type: str):
                 results = await available_llms()
         return Result.succ(results)
     except Exception as ex:
+        logger.exception(str(ex))
         return Result.failed(
             code="E000X", msg=f"query llm strategy type list error: {ex}"
         )
 
 
-@router.get("/v1/app/resources/list", response_model=Result[list[str]])
+@router.get("/v1/app/resources/list", response_model=Result)
 async def app_resources(
-    type: str, name: str = None, user_code: str = None, sys_code: str = None
+    type: str,
+    name: Optional[str] = None,
+    user_code: Optional[str] = None,
+    sys_code: Optional[str] = None,
+    user_info: UserRequest = Depends(get_user_from_headers),
 ):
     """
     Get agent resources, such as db, knowledge, internet, plugin.
     """
     try:
-        resources = get_resource_manager().get_supported_resources("v1")
+        resources = get_resource_manager().get_supported_resources(
+            version="v1", type=type, user_id=None
+        )
         results = resources.get(type, [])
         return Result.succ(results)
     except Exception as ex:
+        logger.exception(str(ex))
         return Result.failed(code="E000X", msg=f"query app resources error: {ex}")
+
+
+@router.post("/v1/app/publish", response_model=Result)
+async def publish(
+    gpts_app: GptsApp, user_info: UserRequest = Depends(get_user_from_headers)
+):
+    try:
+        gpts_app.user_code = (
+            user_info.user_id if user_info.user_id is not None else gpts_app.user_code
+        )
+        gpts_dao.publish(gpts_app.app_code, gpts_app.user_code, gpts_app.sys_code)
+        return Result.succ([])
+    except Exception as ex:
+        logger.exception(str(ex))
+        return Result.failed(code="E000X", msg=f"publish app error: {ex}")
+
+
+@router.post("/v1/app/unpublish", response_model=Result)
+async def unpublish(
+    gpts_app: GptsApp, user_info: UserRequest = Depends(get_user_from_headers)
+):
+    try:
+        gpts_app.user_code = (
+            user_info.user_id if user_info.user_id is not None else gpts_app.user_code
+        )
+        gpts_dao.unpublish(gpts_app.app_code, gpts_app.user_code, gpts_app.sys_code)
+        return Result.succ([])
+    except Exception as ex:
+        logger.exception("unpublish:" + str(ex))
+        return Result.failed(code="E000X", msg=f"unpublish app error: {ex}")
+
+
+@router.post("/v1/app/native/init", response_model=Result)
+async def init_native_apps(
+    gpts_app: GptsApp, user_info: UserRequest = Depends(get_user_from_headers)
+):
+    try:
+        user_code = (
+            user_info.user_id if user_info.user_id is not None else gpts_app.user_code
+        )
+        gpts_dao.init_native_apps(user_code)
+        return Result.succ([])
+    except Exception as ex:
+        logger.exception("init natove error!")
+        return Result.failed(code="E000X", msg=f"init natove error: {ex}")
+
+
+@router.get("/v1/native_scenes")
+async def native_scenes(user_info: UserRequest = Depends(get_user_from_headers)):
+    return Result.succ(native_app_params())
+
+
+@router.post("/v1/app/admins/update")
+def update_admins(
+    gpts_app: GptsApp, user_info: UserRequest = Depends(get_user_from_headers)
+):
+    return Result.succ(gpts_dao.update_admins(gpts_app.app_code, gpts_app.admins))
+
+
+@router.get("/v1/app/{app_code}/admins")
+async def query_admins(
+    app_code: str,
+    user_info: UserRequest = Depends(get_user_from_headers),
+):
+    try:
+        return Result.succ(gpts_dao.get_admins(app_code))
+    except Exception as ex:
+        logger.exception("query_admins:" + str(ex))
+        return Result.failed(code="E000X", msg=f"query admins error: {ex}")
+
+
+@router.get("/v1/dbgpts/list", response_model=Result[List[GptsApp]])
+async def get_dbgpts(user_code: str = None, sys_code: str = None):
+    logger.info(f"get_dbgpts:{user_code},{sys_code}")
+    try:
+        query: GptsAppQuery = GptsAppQuery()
+        query.ignore_user = "true"
+        response = gpts_dao.app_list(query, True)
+        return Result.succ(response.app_list)
+    except Exception as e:
+        logger.error(f"get_dbgpts failed:{str(e)}")
+        return Result.failed(msg=str(e), code="E300003")

dbgpt/serve/agent/app/endpoints.py

@@ -14,6 +14,8 @@ router = APIRouter()
 gpts_dao = GptsAppDao()
 collection_dao = GptsAppCollectionDao()
 
+gpts_dao.init_native_apps("dbgpt")
+
 
 @router.get("/v2/serve/apps")
 async def app_list(

dbgpt/serve/agent/app/recommend_question/controller.py

@@ -0,0 +1,77 @@
+import logging
+
+from fastapi import APIRouter, Depends
+
+from dbgpt.app.openapi.api_view_model import Result
+from dbgpt.serve.agent.app.recommend_question.recommend_question import (
+    RecommendQuestion,
+    RecommendQuestionDao,
+)
+from dbgpt.serve.utils.auth import UserRequest, get_user_from_headers
+
+router = APIRouter()
+logger = logging.getLogger(__name__)
+
+recommend_question_dao = RecommendQuestionDao()
+
+
+@router.post("/v1/question/create")
+async def create(
+    recommend_question: RecommendQuestion,
+    user_info: UserRequest = Depends(get_user_from_headers),
+):
+    try:
+        if user_info.user_id is not None:
+            recommend_question.user_code = user_info.user_id
+        return Result.succ(recommend_question_dao.create(recommend_question))
+    except Exception as ex:
+        return Result.failed(code="E000X", msg=f"create question error: {ex}")
+
+
+@router.get("/v1/question/list")
+async def query(
+    valid: str = None,
+    app_code: str = None,
+    chat_mode: str = None,
+    is_hot_question: str = None,
+    user_info: UserRequest = Depends(get_user_from_headers),
+):
+    try:
+        return Result.succ(
+            recommend_question_dao.list_questions(
+                RecommendQuestion(
+                    valid=valid,
+                    app_code=app_code,
+                    chat_mode=chat_mode,
+                    is_hot_question=is_hot_question,
+                )
+            )
+        )
+    except Exception as ex:
+        return Result.failed(code="E000X", msg=f"query questions error: {ex}")
+
+
+@router.post("/v1/question/update")
+async def update(
+    recommend_question: RecommendQuestion,
+    user_info: UserRequest = Depends(get_user_from_headers),
+):
+    try:
+        if user_info.user_id is not None:
+            recommend_question.user_code = user_info.user_id
+        recommend_question_dao.update_question(recommend_question)
+        return Result.succ([])
+    except Exception as ex:
+        return Result.failed(code="E000X", msg=f"update question error: {ex}")
+
+
+@router.post("/v1/question/delete")
+async def delete(
+    recommend_question: RecommendQuestion,
+    user_info: UserRequest = Depends(get_user_from_headers),
+):
+    try:
+        recommend_question_dao.delete_question(recommend_question)
+        return Result.succ([])
+    except Exception as ex:
+        return Result.failed(code="E000X", msg=f"delete question error: {ex}")

dbgpt/serve/agent/app/recommend_question/recommend_question.py

@@ -0,0 +1,160 @@
+import json
+from datetime import datetime
+from typing import Any, Dict, Optional, Union
+
+from sqlalchemy import Column, DateTime, Index, Integer, String, Text
+
+from dbgpt._private.pydantic import BaseModel, Field
+from dbgpt.storage.metadata import BaseDao, Model
+
+
+class RecommendQuestion(BaseModel):
+    id: Optional[int] = Field(None, description="id")
+    app_code: Optional[str] = Field(None, description="The unique identify of app")
+    question: Optional[str] = Field(None, description="The question you may ask")
+    user_code: Optional[str] = Field(None, description="The user code")
+    sys_code: Optional[str] = Field(None, description="The system code")
+    gmt_create: datetime = datetime.now()
+    gmt_modified: datetime = datetime.now()
+    params: Optional[dict] = Field(default={}, description="The params of app")
+    valid: Optional[Union[str, bool]] = Field(
+        default=None, description="is the question valid to display, default is true"
+    )
+    chat_mode: Optional[str] = Field(
+        default=None, description="is the question valid to display, default is true"
+    )
+    is_hot_question: Optional[str] = Field(default=None, description="is hot question.")
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]):
+        return cls(
+            id=d["id"],
+            app_code=d.get("app_code", None),
+            question=d.get("question", None),
+            user_code=str(d.get("user_code", None)),
+            sys_code=d.get("sys_code", None),
+            gmt_create=d.get("gmt_create", None),
+            updated_at=d.get("updated_at", None),
+            gmt_modified=d.get("gmt_modified", None),
+            params=d.get("params", None),
+            valid=d.get("valid", False),
+            chat_mode=d.get("chat_mode", None),
+            is_hot_question=d.get("is_hot_question", False),
+        )
+
+    @classmethod
+    def from_entity(cls, entity):
+        return RecommendQuestion.from_dict(
+            {
+                "id": entity.id,
+                "app_code": entity.app_code,
+                "question": entity.question,
+                "user_code": entity.user_code,
+                "sys_code": entity.sys_code,
+                "gmt_create": entity.gmt_create,
+                "gmt_modified": entity.gmt_modified,
+                "params": json.loads(entity.params),
+                "valid": entity.valid,
+                "chat_mode": entity.chat_mode,
+                "is_hot_question": entity.is_hot_question,
+            }
+        )
+
+
+class RecommendQuestionEntity(Model):
+    __tablename__ = "recommend_question"
+    id = Column(Integer, primary_key=True, comment="autoincrement id")
+    app_code = Column(String(255), nullable=False, comment="Current AI assistant code")
+    user_code = Column(String(255), nullable=True, comment="user code")
+    sys_code = Column(String(255), nullable=True, comment="system app code")
+    gmt_create = Column(DateTime, default=datetime.utcnow, comment="create time")
+    gmt_modified = Column(
+        DateTime,
+        default=datetime.utcnow,
+        onupdate=datetime.utcnow,
+        comment="last update time",
+    )
+    question = Column(Text, default=None, comment="question")
+    valid = Column(String(31), default=True, comment="is valid")
+    params = Column(Text, nullable=True, comment="is valid")
+    chat_mode = Column(
+        String(31),
+        nullable=True,
+        comment="chat_mode, such as chat_knowledge, chat_normal",
+    )
+    is_hot_question = Column(
+        String(10),
+        default=False,
+        comment="hot question would be displayed on the main page.",
+    )
+    __table_args__ = (Index("idx_app_code", "app_code"),)
+
+
+class RecommendQuestionDao(BaseDao):
+    def list_questions(self, rq: RecommendQuestion):
+        questions = []
+        with self.session() as session:
+            qry = session.query(RecommendQuestionEntity)
+            if rq.valid is not None:
+                qry = qry.filter(RecommendQuestionEntity.valid == rq.valid)
+            if rq.app_code is not None:
+                qry = qry.filter(RecommendQuestionEntity.app_code == rq.app_code)
+            if rq.chat_mode is not None:
+                qry = qry.filter(RecommendQuestionEntity.chat_mode == rq.chat_mode)
+            if rq.is_hot_question is not None:
+                qry = qry.filter(
+                    RecommendQuestionEntity.is_hot_question == rq.is_hot_question
+                )
+            entities = qry.all()
+            for entity in entities:
+                questions.append(RecommendQuestion.from_entity(entity))
+        return questions
+
+    def create(self, recommend_question: RecommendQuestion):
+        with self.session() as session:
+            entity = RecommendQuestionEntity(
+                app_code=recommend_question.app_code,
+                question=recommend_question.question,
+                user_code=recommend_question.user_code,
+                sys_code=recommend_question.sys_code,
+                gmt_create=recommend_question.gmt_create,
+                gmt_modified=recommend_question.gmt_modified,
+                params=json.dumps(recommend_question.params),
+                valid=recommend_question.valid,
+                chat_mode=recommend_question.chat_mode,
+                is_hot_question=recommend_question.is_hot_question,
+            )
+            session.add(entity)
+            return RecommendQuestion.from_entity(entity)
+
+    def update_question(self, recommend_question: RecommendQuestion):
+        with self.session() as session:
+            qry = session.query(RecommendQuestionEntity)
+            qry = qry.filter(RecommendQuestionEntity.id == recommend_question.id)
+            entity = qry.one()
+            if entity is not None:
+                if recommend_question.question is not None:
+                    entity.question = recommend_question.question
+                if recommend_question.app_code is not None:
+                    entity.app_code = recommend_question.app_code
+                if recommend_question.valid is not None:
+                    entity.valid = recommend_question.valid
+                if recommend_question.user_code is not None:
+                    entity.user_code = recommend_question.user_code
+                if recommend_question.is_hot_question is not None:
+                    entity.is_hot_question = recommend_question.is_hot_question
+                session.merge(entity)
+
+    def delete_question(self, recommend_question: RecommendQuestion):
+        with self.session() as session:
+            qry = session.query(RecommendQuestionEntity)
+            qry = qry.filter(RecommendQuestionEntity.id == recommend_question.id)
+            entity = qry.one()
+            if entity is not None:
+                session.delete(entity)
+
+    def delete_by_app_code(self, app_code: str):
+        with self.session() as session:
+            qry = session.query(RecommendQuestionEntity)
+            qry = qry.filter(RecommendQuestionEntity.app_code == app_code)
+            qry.delete()