feat: general：新增、更新的时候更新创建人更新人id

app/general/add_general_route.py

@@ -2,6 +2,7 @@ import json
 from typing import Literal
 
 from fastapi import FastAPI
+from starlette.requests import Request
 from starlette.responses import JSONResponse
 
 from app.general.ModuleConfigModule import ModuleConfigModule
@@ -13,9 +14,9 @@ def add_general_route(app: FastAPI):
   types = ['list', 'item', 'insert', 'update', 'delete', 'batch_insert', 'batch_update']
   for type in types:
     @app.post("/general/{module}/" + type)
-    async def func(module: str, query_param: dict, session: AsyncSessionDep, type=type):
+    async def func(module: str, query_param: dict, session: AsyncSessionDep, request: Request, type=type):
       try:
-        result = await perform_general_operation(session=session, module=module, data=query_param, debug_data=[], type=type)
+        result = await perform_general_operation(session=session, module=module, data=query_param, debug_data=[], user=request.state.user, type=type)
         if "error" in result:
           return JSONResponse(content=result, status_code=500)
         else:
@@ -29,12 +30,13 @@ async def perform_general_operation(
   module: str,
   data: dict,
   debug_data=None,
+  user=None,
   type: Literal['list', 'item', 'insert', 'update', 'delete', 'batch_insert', 'batch_update'] = 'query'
 ):
   if debug_data is None:
     debug_data = []
 
-  module_query_result = await get_module_config(session, module, debug_data)
+  module_query_result = await get_module_config(session, module, debug_data, user)
 
   if 'error' in module_query_result:
     return module_query_result
@@ -51,22 +53,22 @@ async def perform_general_operation(
     }
 
   if type == 'list':
-    return await sql_service.list(session, data, module_config, debug_data)
+    return await sql_service.list(session, data, module_config, debug_data, user)
   elif type == 'item':
-    return await sql_service.item(session, data, module_config, debug_data)
+    return await sql_service.item(session, data, module_config, debug_data, user)
   elif type == 'insert':
-    return await sql_service.insert(session, data, module_config, debug_data)
+    return await sql_service.insert(session, data, module_config, debug_data, user)
   elif type == 'update':
-    return await sql_service.update(session, data, module_config, debug_data)
+    return await sql_service.update(session, data, module_config, debug_data, user)
   elif type == 'batch_insert':
-    return await sql_service.batch_insert(session, data, module_config, debug_data)
+    return await sql_service.batch_insert(session, data, module_config, debug_data, user)
   elif type == 'batch_update':
-    return await sql_service.batch_update(session, data, module_config, debug_data)
+    return await sql_service.batch_update(session, data, module_config, debug_data, user)
   elif type == 'delete':
-    return await sql_service.delete(session, data, module_config, debug_data)
+    return await sql_service.delete(session, data, module_config, debug_data, user)
   else:
     return {"error": f"Can't handle operation type: {type}"}
 
 
-async def get_module_config(session: AsyncSessionDep, module: str, debug_data=None):
+async def get_module_config(session: AsyncSessionDep, module: str, debug_data=None, user=None):
-  return await sql_service.item(session, {"code": module}, ModuleConfigModule, debug_data)
+  return await sql_service.item(session, {"code": module}, ModuleConfigModule, debug_data, user)

app/general/general_interceptors.py

@@ -40,7 +40,7 @@ def add_general_interceptor(interceptor: GeneralInterceptor):
   _general_interceptors.append(interceptor)
 
 
-async def invoke_interceptor(method: str, module: str, *args):
+async def invoke_interceptor(method: str, module: str, **kwargs):
   if module.startswith('/'):
     module = module[1:]
   if module.endswith('/'):
@@ -49,4 +49,4 @@ async def invoke_interceptor(method: str, module: str, *args):
   for item in match_interceptors:
     interceptor_method = getattr(item, method, None)  # 使用 getattr 获取方法
     if interceptor_method and callable(interceptor_method):
-      await interceptor_method(*args)  # 调用方法
+      await interceptor_method(**kwargs)  # 调用方法

app/general/general_utils/sql_service.py

@@ -8,6 +8,7 @@ from app.general.general_utils.build_insert_sql import build_insert_sql
 from app.general.general_utils.build_query_sql import build_query_sql
 from app.general.general_utils.build_update_sql import build_update_sql
 from app.general.general_utils.sql_utils import get_value, create_convertor
+from app.model.UserModel import UserServiceModel
 from app.utils.db_utils import AsyncSessionDep
 
 
@@ -36,7 +37,7 @@ async def get_id(session: AsyncSessionDep, len: int | None = 1):
   return [val for key, val in result[0].items()]
 
 
-async def list(session: AsyncSessionDep, query_config, module_config, debug_data=[]):
+async def list(session: AsyncSessionDep, query_config, module_config, debug_data=[], user: UserServiceModel | None = None):
   conn = await session.connection()
 
   n_page = get_value(query_config, 'page', 0)
@@ -54,7 +55,7 @@ async def list(session: AsyncSessionDep, query_config, module_config, debug_data
     "orders": get_default_orders(query_config, module_config)
   }
 
-  await invoke_interceptor('before_list', module_config['base'], target_query_config, session)
+  await invoke_interceptor('before_list', module_config['base'], query_config=target_query_config, session=session, user=user)
 
   sql, values = build_query_sql(target_query_config, module_config)
 
@@ -66,7 +67,7 @@ async def list(session: AsyncSessionDep, query_config, module_config, debug_data
 
     create_convertor(module_config)['decode_list'](result)
 
-    await invoke_interceptor('after_list', module_config['base'], result, session)
+    await invoke_interceptor('after_list', module_config['base'], rows=result, session=session, user=user)
 
     if n_only_count:
       return {
@@ -88,7 +89,7 @@ async def list(session: AsyncSessionDep, query_config, module_config, debug_data
     }
 
 
-async def item(session: AsyncSessionDep, query_config, module_config, debug_data=[]):
+async def item(session: AsyncSessionDep, query_config, module_config, debug_data=[], user: UserServiceModel | None = None):
   target_query_config = {
     "offset": 0,
     "size": 1,
@@ -102,7 +103,7 @@ async def item(session: AsyncSessionDep, query_config, module_config, debug_data
       "operator": "="
     })
 
-  result = await list(session=session, query_config=target_query_config, module_config=module_config, debug_data=debug_data)
+  result = await list(session=session, query_config=target_query_config, module_config=module_config, debug_data=debug_data, user=user)
 
   if "error" in result:
     return result
@@ -110,7 +111,7 @@ async def item(session: AsyncSessionDep, query_config, module_config, debug_data
   return {"result": None if "list" not in result or len(result['list']) == 0 else result['list'][0]}
 
 
-async def insert(session: AsyncSessionDep, query_config, module_config, debug_data=[]):
+async def insert(session: AsyncSessionDep, query_config, module_config, debug_data=[], user: UserServiceModel | None = None):
   conn = await session.connection()
 
   row = get_value(query_config, 'row', None)
@@ -135,7 +136,11 @@ async def insert(session: AsyncSessionDep, query_config, module_config, debug_da
   if get_value(row, 'updatedAt', None):
     row['updatedAt'] = row['createdAt']
 
-  await invoke_interceptor('before_insert', module_config['base'], row, session)
+  if user:
+    row['createdBy'] = user.id
+    row['updatedBy'] = user.id
+
+  await invoke_interceptor('before_insert', module_config['base'], row=row, session=session, user=user)
 
   try:
     sql, values = build_insert_sql(module_config, row)
@@ -151,7 +156,7 @@ async def insert(session: AsyncSessionDep, query_config, module_config, debug_da
 
     item_dict = get_value(result, 'result', None)
 
-    await invoke_interceptor('after_insert', module_config['base'], item_dict, session)
+    await invoke_interceptor('after_insert', module_config['base'], row=item_dict, session=session, user=user)
 
     if item_dict is not None:
       return {
@@ -170,7 +175,7 @@ async def insert(session: AsyncSessionDep, query_config, module_config, debug_da
     }
 
 
-async def batch_insert(session: AsyncSessionDep, query_config, module_config, debug_data=[]):
+async def batch_insert(session: AsyncSessionDep, query_config, module_config, debug_data=[], user: UserServiceModel | None = None):
   conn = await session.connection()
 
   rows = get_value(query_config, 'rows', None)
@@ -196,7 +201,11 @@ async def batch_insert(session: AsyncSessionDep, query_config, module_config, de
     if get_value(row, 'updatedAt', None):
       row['updatedAt'] = row['createdAt']
 
-  await invoke_interceptor('before_batch_insert', module_config['base'], rows, session)
+    if user:
+      row['createdBy'] = user.id
+      row['updatedBy'] = user.id
+
+  await invoke_interceptor('before_batch_insert', module_config['base'], rows=rows, session=session, user=user)
 
   try:
     for row in rows:
@@ -214,7 +223,7 @@ async def batch_insert(session: AsyncSessionDep, query_config, module_config, de
 
     if len(result) > 0:
 
-      await invoke_interceptor('after_batch_insert', module_config['base'], result, session)
+      await invoke_interceptor('after_batch_insert', module_config['base'], rows=result, session=session, user=user)
 
       return {
         "result": result
@@ -232,7 +241,7 @@ async def batch_insert(session: AsyncSessionDep, query_config, module_config, de
     }
 
 
-async def update(session: AsyncSessionDep, query_config, module_config, debug_data=[]):
+async def update(session: AsyncSessionDep, query_config, module_config, debug_data=[], user: UserServiceModel | None = None):
   conn = await session.connection()
 
   row = get_value(query_config, 'row', None)
@@ -251,10 +260,12 @@ async def update(session: AsyncSessionDep, query_config, module_config, debug_da
     }
 
   row['updatedAt'] = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+  if user:
+    row['updatedBy'] = user.id
 
   create_convertor(module_config)['encode_list']([row])
 
-  await invoke_interceptor('before_update', module_config['base'], row, session)
+  await invoke_interceptor('before_update', module_config['base'], row=row, session=session, user=user)
 
   try:
     sql, values = build_update_sql(module_config, row, row.keys() if update_by_fields else None)
@@ -270,7 +281,7 @@ async def update(session: AsyncSessionDep, query_config, module_config, debug_da
 
     item_dict = get_value(result, 'result', None)
 
-    await invoke_interceptor('after_update', module_config['base'], item_dict, session)
+    await invoke_interceptor('after_update', module_config['base'], row=item_dict, session=session, user=user)
 
     if item_dict is not None:
       return {
@@ -289,7 +300,7 @@ async def update(session: AsyncSessionDep, query_config, module_config, debug_da
     }
 
 
-async def batch_update(session: AsyncSessionDep, query_config, module_config, debug_data=[]):
+async def batch_update(session: AsyncSessionDep, query_config, module_config, debug_data=[], user: UserServiceModel | None = None):
   conn = await session.connection()
 
   rows = get_value(query_config, 'rows', None)
@@ -312,8 +323,10 @@ async def batch_update(session: AsyncSessionDep, query_config, module_config, de
 
   for row in rows:
     row['updatedAt'] = current_datetime
+    if user:
+      row['updatedBy'] = user.id
 
-  await invoke_interceptor('before_batch_update', module_config['base'], rows, session)
+  await invoke_interceptor('before_batch_update', module_config['base'], rows=rows, session=session, user=user)
 
   try:
     for row in rows:
@@ -331,7 +344,7 @@ async def batch_update(session: AsyncSessionDep, query_config, module_config, de
 
     if len(result) > 0:
 
-      await invoke_interceptor('after_batch_update', module_config['base'], result, session)
+      await invoke_interceptor('after_batch_update', module_config['base'], rows=result, session=session, user=user)
 
       return {
         "result": result
@@ -349,7 +362,7 @@ async def batch_update(session: AsyncSessionDep, query_config, module_config, de
     }
 
 
-async def delete(session: AsyncSessionDep, query_config, module_config, debug_data=[]):
+async def delete(session: AsyncSessionDep, query_config, module_config, debug_data=[], user: UserServiceModel | None = None):
   conn = await session.connection()
 
   id = get_value(query_config, 'id', None)
@@ -358,7 +371,7 @@ async def delete(session: AsyncSessionDep, query_config, module_config, debug_da
       "error": "id parameter is missing",
     }
 
-  await invoke_interceptor('before_delete', module_config['base'], id, session)
+  await invoke_interceptor('before_delete', module_config['base'], query_config=query_config, session=session, user=user)
 
   try:
     sql, values = build_delete_sql(module_config, id)
@@ -369,7 +382,7 @@ async def delete(session: AsyncSessionDep, query_config, module_config, debug_da
 
     if deleted_rows >= 1:
 
-      await invoke_interceptor('after_delete', module_config['base'], id, session)
+      await invoke_interceptor('after_delete', module_config['base'], query_config=query_config, session=session, user=user)
 
       return {"deletedRows": deleted_rows}
     else:

app/general_interceptors/add_general_interceptor_llm_user.py

@@ -2,41 +2,41 @@ from app.general.general_interceptors import add_general_interceptor, GeneralInt
 
 
 def add_general_interceptor_llm_user():
-  async def before_list(query_config, session):
+  async def before_list(query_config, session, user):
-    print("before_list:llm_user", query_config, session)
+    print("before_list:llm_user", query_config, session, user)
 
-  async def after_list(rows, session):
+  async def after_list(rows, session, user):
-    print("after_list:llm_user", rows, session)
+    print("after_list:llm_user", rows, session, user)
 
-  async def before_insert(row, session):
+  async def before_insert(row, session, user):
-    print("before_insert:llm_user", row, session)
+    print("before_insert:llm_user", row, session, user)
 
-  async def after_insert(row, session):
+  async def after_insert(row, session, user):
-    print("after_insert:llm_user", row, session)
+    print("after_insert:llm_user", row, session, user)
 
-  async def before_update(row, session):
+  async def before_update(row, session, user):
-    print("before_update:llm_user", row, session)
+    print("before_update:llm_user", row, session, user)
 
-  async def after_update(row, session):
+  async def after_update(row, session, user):
-    print("after_update:llm_user", row, session)
+    print("after_update:llm_user", row, session, user)
 
-  async def before_batch_insert(rows, session):
+  async def before_batch_insert(rows, session, user):
-    print("before_batch_insert:llm_user", rows, session)
+    print("before_batch_insert:llm_user", rows, session, user)
 
-  async def after_batch_insert(rows, session):
+  async def after_batch_insert(rows, session, user):
-    print("after_batch_insert:llm_user", rows, session)
+    print("after_batch_insert:llm_user", rows, session, user)
 
-  async def before_batch_update(rows, session):
+  async def before_batch_update(rows, session, user):
-    print("before_batch_update:llm_user", rows, session)
+    print("before_batch_update:llm_user", rows, session, user)
 
-  async def after_batch_update(rows, session):
+  async def after_batch_update(rows, session, user):
-    print("after_batch_update:llm_user", rows, session)
+    print("after_batch_update:llm_user", rows, session, user)
 
-  async def before_delete(id, session):
+  async def before_delete(query_config, session, user):
-    print("before_delete:llm_user", id, session)
+    print("before_delete:llm_user", query_config, session, user)
 
-  async def after_delete(id, session):
+  async def after_delete(query_config, session, user):
-    print("after_delete:llm_user", id, session)
+    print("after_delete:llm_user", query_config, session, user)
 
   add_general_interceptor(GeneralInterceptor(
     module="llm_user",