Merge remote-tracking branch 'origin/master'

routers/api/Knowledge/__init__.py

@@ -8,6 +8,8 @@ from models import *
 import json
 import random
 from sqlalchemy import create_engine, select
+from typing import Optional
+
 router = APIRouter()
 
 # @router.post('/create')
@@ -82,7 +84,7 @@ async def create_knowledge(request: Request, db: Session = Depends(get_db)):
 
         # 验证必需的字段
         required_fields = ['reportName', 'subject', 'eventType', 'publishingUnit', 'publishDate', 'summary',
-                           'fileNames']
+                           'notificationType', 'fileNames']
         missing_fields = [field for field in required_fields if field not in body]
         print('missing_fields',missing_fields)
         if missing_fields:
@@ -100,8 +102,7 @@ async def create_knowledge(request: Request, db: Session = Depends(get_db)):
         publishingUnit = body["publishingUnit"]
         publishDate = body["publishDate"]
         summary = body["summary"]
-        # notificationType = body["notificationType"]
-        notificationType = "总结报告"
+        notificationType = body["notificationType"]
         fileNames = body["fileNames"]  # 注意：这里假设它是列表
 
         # 创建 KnowledgeBase 实例
@@ -132,16 +133,25 @@ async def create_knowledge(request: Request, db: Session = Depends(get_db)):
             db.add(knowledge_file)
 
         db.commit()
-
         return {
             "code": 200,
-            "data": {
-                "reportId": reportId,
-                "status": "success",
-                "message": "总结报告创建成功"
-            }
+            "msg": "总结报告创建成功",
+            "status": "success",
+            "data":
+                [reportId]
+
         }
 
+        # return {
+        #     "code": 200,
+        #     "msg": "操作成功",
+        #     "data": {
+        #         "reportId": reportId,
+        #         "status": "success",
+        #         "message": "总结报告创建成功"
+        #     }
+        # }
+
     except json.JSONDecodeError:
         raise HTTPException(status_code=400, detail="Invalid JSON data")
     except IntegrityError as e:
@@ -153,77 +163,120 @@ async def create_knowledge(request: Request, db: Session = Depends(get_db)):
         raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
 
 
-
 @router.post('/select')
 @router.get('/select')
-async def select_knowledge(request: Request, db: Session = Depends(get_db)):
-    # 尝试从请求体中解析 JSON 数据
-    data = await request.json()  # 注意：这里直接使用 request.json() 而不是 request.body()
+async def select_knowledge(request: Request, db: Session = Depends(get_db), pageNum: Optional[int] = None,
+                           pageSize: Optional[int] = None):
+    # page_from_json = None
     try:
-        page = int(data.get('page', 1))  # 如果没有提供 page，则默认为 1
-        size = int(data.get('size', 10)) # 如果没有提供 size，则默认为 10
-        if size >100:
-            size = 100
-    except ValueError as e:
-        # 如果转换失败，则抛出 HTTPException
-        raise HTTPException(status_code=400, detail=f"Invalid pagination parameters: {e}")
+        # # 尝试从请求体中解析 JSON 数据
+        json_data = await request.json()
+
+        # 初始化分页参数
+        page_from_json = json_data.get('pageNum') if json_data else None
+        size_from_json = json_data.get('pageSize') if json_data else None
+    except:
+        page_from_json = None
+
+    # 如果查询参数和请求体都存在，优先选择查询参数
+    if pageNum is not None and pageSize is not None:
+        # 使用查询参数
+        page_to_use = pageNum
+        size_to_use = pageSize
+    elif page_from_json is not None and size_from_json is not None:
+        # 使用请求体中的参数
+        page_to_use = page_from_json
+        size_to_use = size_from_json
+    else:
+        # 如果只有一个存在，使用存在的那个，否则抛出异常
+        if pageNum is not None:
+            page_to_use = pageNum
+        elif page_from_json is not None:
+            page_to_use = page_from_json
+        else:
+            raise HTTPException(status_code=400, detail="Page parameter is required")
+
+        if pageSize is not None:
+            size_to_use = pageSize
+        elif size_from_json is not None:
+            size_to_use = size_from_json
+        else:
+            raise HTTPException(status_code=400, detail="Size parameter is required")
+
+            # 验证分页参数
+    if size_to_use > 100:
+        size_to_use = 100
 
         # 计算 offset
-    offset = (page - 1) * size
+    offset = (page_to_use - 1) * size_to_use
 
     # 使用 ORM 查询并应用分页
-    data = db.query(KnowledgeBase).offset(offset).limit(size).all()
-
-    # 打印结果（可选，用于调试）
-    # for i in data:
-    #     print(i)
-    print(f"Returned {len(data)} results from page {page} with size {size}")
+    data = db.query(KnowledgeBase).offset(offset).limit(size_to_use).all()
 
-    # 计算总条数（注意：这可能会很慢，特别是对于大型数据集）
+    # 计算总条数
     total_count = db.query(func.count(KnowledgeBase.reportId)).scalar()
 
     # 计算总页数
-    total_pages = (total_count // size) + (1 if total_count % size else 0)
+    total_pages = (total_count // size_to_use) + (1 if total_count % size_to_use else 0)
 
     # 返回查询结果
+    # result = {
+    #     "code": 200,
+    #     'msg': '查询成功',
+    #     'data': {
+    #         'pages': total_pages,
+    #         'total': total_count,
+    #         "currentPage": page_to_use,
+    #         "pageSize": size_to_use,
+    #         "rows": data
+    #     }
+    # }
     result = {
         "code": 200,
-        'msg': 'success',
-        'data': {
-            'pages': total_pages,
-            'total': total_count,
-            "currentPage":page,
-            "pageSize":size,
-            "list": data
-        }
+        'msg': '查询成功',
+        'pages': total_pages,
+        'total': total_count,
+        "currentPage": page_to_use,
+        "pageSize": size_to_use,
+        'data': data
     }
     return result
 
 
-
-
-
 @router.post('/detail')
 @router.get('/detail')
-async def get_knowledge_detail(request: Request, db: Session = Depends(get_db)):
+async def get_knowledge_detail(request: Request, db: Session = Depends(get_db), reportID: Optional[str] = None):
     # 尝试从请求体中解析 JSON 数据
-    data = await request.json()
-    report_id = data.get('reportID')
-    if not report_id:
+    report_id_body=None
+    try:
+        data = await request.json()
+        report_id_body = data.get('reportID') if data else None
+    except:
+        print('报错')
+        pass
+
+    # 确定要使用的 report_id
+    report_id_to_use = reportID or report_id_body
+    print(reportID)
+    print(report_id_body)
+
+    # 如果没有提供 report_id，则抛出异常
+    if not report_id_to_use:
         raise HTTPException(status_code=400, detail="Missing required parameter 'reportID'")
 
         # 查询 KnowledgeBase
-    kb_entry = db.query(KnowledgeBase).filter(KnowledgeBase.reportId == report_id).first()
+    kb_entry = db.query(KnowledgeBase).filter(KnowledgeBase.reportId == report_id_to_use).first()
     if not kb_entry:
         raise HTTPException(status_code=404, detail="No knowledge base found for the given report ID")
 
+        # 查询相关的 KnowledgeFile
     kf_entries = db.query(KnowledgeFile).filter(KnowledgeFile.knowledge_base_code == kb_entry.base_code).all()
 
     # 准备返回的数据
     result = {
         "code": 200,
-        "msg": "success",
-        "data": {
+        "msg": "查询成功",
+        "data": [{
             "report_id": kb_entry.reportId,
             "reportName": kb_entry.reportName,
             "subject": kb_entry.subject,
@@ -232,15 +285,11 @@ async def get_knowledge_detail(request: Request, db: Session = Depends(get_db)):
             "publishingUnit": kb_entry.publishingUnit,
             "summary": kb_entry.summary,
             "notificationType": kb_entry.notificationType,
-            # "knowledge_base_code": kb_entry.base_code,
             "file": [
-                {
-                 "content": kf.file_name,
-                 "url": 'http://127.0.0.1:9988/api/file/download/'+kf.file_name
-                 }  # 根据需要调整返回的字段
+                {"content": kf.file_name, "url": f'http://127.0.0.1:9988/api/file/download/{kf.file_name}'}
                 for kf in kf_entries
             ]
-            }
+        }]
     }
 
     return result