feat(core): AWEL flow 2.0 backend code (#1879)

Co-authored-by: yhjun1026 <460342015@qq.com>

dbgpt/serve/file/models/__init__.py

@@ -0,0 +1,2 @@
+# This is an auto-generated __init__.py file
+# generated by `dbgpt new serve file`

dbgpt/serve/file/models/file_adapter.py

@@ -0,0 +1,88 @@
+import json
+from typing import Type
+
+from sqlalchemy.orm import Session
+
+from dbgpt.core.interface.file import FileMetadata, FileMetadataIdentifier
+from dbgpt.core.interface.storage import StorageItemAdapter
+
+from .models import ServeEntity
+
+
+class FileMetadataAdapter(StorageItemAdapter[FileMetadata, ServeEntity]):
+    """File metadata adapter.
+
+    Convert between storage format and database model.
+    """
+
+    def to_storage_format(self, item: FileMetadata) -> ServeEntity:
+        """Convert to storage format."""
+        custom_metadata = (
+            {k: v for k, v in item.custom_metadata.items()}
+            if item.custom_metadata
+            else {}
+        )
+        user_name = item.user_name or custom_metadata.get("user_name")
+        sys_code = item.sys_code or custom_metadata.get("sys_code")
+        if "user_name" in custom_metadata:
+            del custom_metadata["user_name"]
+        if "sys_code" in custom_metadata:
+            del custom_metadata["sys_code"]
+        custom_metadata_json = (
+            json.dumps(custom_metadata, ensure_ascii=False) if custom_metadata else None
+        )
+        return ServeEntity(
+            bucket=item.bucket,
+            file_id=item.file_id,
+            file_name=item.file_name,
+            file_size=item.file_size,
+            storage_type=item.storage_type,
+            storage_path=item.storage_path,
+            uri=item.uri,
+            custom_metadata=custom_metadata_json,
+            file_hash=item.file_hash,
+            user_name=user_name,
+            sys_code=sys_code,
+        )
+
+    def from_storage_format(self, model: ServeEntity) -> FileMetadata:
+        """Convert from storage format."""
+        custom_metadata = (
+            json.loads(model.custom_metadata) if model.custom_metadata else None
+        )
+        if custom_metadata is None:
+            custom_metadata = {}
+        if model.user_name:
+            custom_metadata["user_name"] = model.user_name
+        if model.sys_code:
+            custom_metadata["sys_code"] = model.sys_code
+
+        return FileMetadata(
+            bucket=model.bucket,
+            file_id=model.file_id,
+            file_name=model.file_name,
+            file_size=model.file_size,
+            storage_type=model.storage_type,
+            storage_path=model.storage_path,
+            uri=model.uri,
+            custom_metadata=custom_metadata,
+            file_hash=model.file_hash,
+            user_name=model.user_name,
+            sys_code=model.sys_code,
+        )
+
+    def get_query_for_identifier(
+        self,
+        storage_format: Type[ServeEntity],
+        resource_id: FileMetadataIdentifier,
+        **kwargs,
+    ):
+        """Get query for identifier."""
+        session: Session = kwargs.get("session")
+        if session is None:
+            raise Exception("session is None")
+        return (
+            session.query(storage_format)
+            .filter(storage_format.bucket == resource_id.bucket)
+            .filter(storage_format.file_id == resource_id.file_id)
+        )

dbgpt/serve/file/models/models.py

@@ -0,0 +1,90 @@
+"""This is an auto-generated model file
+You can define your own models and DAOs here
+"""
+
+from datetime import datetime
+from typing import Any, Dict, Union
+
+from sqlalchemy import Column, DateTime, Index, Integer, String, Text, UniqueConstraint
+
+from dbgpt.storage.metadata import BaseDao, Model, db
+
+from ..api.schemas import ServeRequest, ServerResponse
+from ..config import SERVER_APP_TABLE_NAME, ServeConfig
+
+
+class ServeEntity(Model):
+    __tablename__ = SERVER_APP_TABLE_NAME
+    __table_args__ = (UniqueConstraint("bucket", "file_id", name="uk_bucket_file_id"),)
+
+    id = Column(Integer, primary_key=True, comment="Auto increment id")
+
+    bucket = Column(String(255), nullable=False, comment="Bucket name")
+    file_id = Column(String(255), nullable=False, comment="File id")
+    file_name = Column(String(256), nullable=False, comment="File name")
+    file_size = Column(Integer, nullable=True, comment="File size")
+    storage_type = Column(String(32), nullable=False, comment="Storage type")
+    storage_path = Column(String(512), nullable=False, comment="Storage path")
+    uri = Column(String(512), nullable=False, comment="File URI")
+    custom_metadata = Column(
+        Text, nullable=True, comment="Custom metadata, JSON format"
+    )
+    file_hash = Column(String(128), nullable=True, comment="File hash")
+    user_name = Column(String(128), index=True, nullable=True, comment="User name")
+    sys_code = Column(String(128), index=True, nullable=True, comment="System code")
+    gmt_created = Column(DateTime, default=datetime.now, comment="Record creation time")
+    gmt_modified = Column(DateTime, default=datetime.now, comment="Record update time")
+
+    def __repr__(self):
+        return (
+            f"ServeEntity(id={self.id}, gmt_created='{self.gmt_created}', "
+            f"gmt_modified='{self.gmt_modified}')"
+        )
+
+
+class ServeDao(BaseDao[ServeEntity, ServeRequest, ServerResponse]):
+    """The DAO class for File"""
+
+    def __init__(self, serve_config: ServeConfig):
+        super().__init__()
+        self._serve_config = serve_config
+
+    def from_request(self, request: Union[ServeRequest, Dict[str, Any]]) -> ServeEntity:
+        """Convert the request to an entity
+
+        Args:
+            request (Union[ServeRequest, Dict[str, Any]]): The request
+
+        Returns:
+            T: The entity
+        """
+        request_dict = (
+            request.to_dict() if isinstance(request, ServeRequest) else request
+        )
+        entity = ServeEntity(**request_dict)
+        # TODO implement your own logic here, transfer the request_dict to an entity
+        return entity
+
+    def to_request(self, entity: ServeEntity) -> ServeRequest:
+        """Convert the entity to a request
+
+        Args:
+            entity (T): The entity
+
+        Returns:
+            REQ: The request
+        """
+        # TODO implement your own logic here, transfer the entity to a request
+        return ServeRequest()
+
+    def to_response(self, entity: ServeEntity) -> ServerResponse:
+        """Convert the entity to a response
+
+        Args:
+            entity (T): The entity
+
+        Returns:
+            RES: The response
+        """
+        # TODO implement your own logic here, transfer the entity to a response
+        return ServerResponse()