feat:新增系统参数设置模块，用于初始化系统设置（如是否开启登录验证码）

fix:修复SwaggerUI文档成功验证OAuth2后请求接口时token依然为undefined的bug

Author: insistence

dash-fastapi-backend/app.py

@@ -12,6 +12,7 @@
 from module_admin.controller.role_controller import roleController
 from module_admin.controller.post_controler import postController
 from module_admin.controller.dict_controller import dictController
+from module_admin.controller.config_controller import configController
 from module_admin.controller.notice_controller import noticeController
 from module_admin.controller.log_controller import logController
 from module_admin.controller.online_controller import onlineController
@@ -55,6 +56,7 @@ async def startup_event():
     await init_create_table()
     app.state.redis = await RedisUtil.create_redis_pool()
     await RedisUtil.init_sys_dict(app.state.redis)
+    await RedisUtil.init_sys_config(app.state.redis)
     await SchedulerUtil.init_system_scheduler()
     logger.info("Dash-FastAPI启动成功")
 
@@ -87,6 +89,7 @@ async def http_exception_handler(request: Request, exc: HTTPException):
 app.include_router(roleController, prefix="/system", tags=['系统管理-角色管理'])
 app.include_router(postController, prefix="/system", tags=['系统管理-岗位管理'])
 app.include_router(dictController, prefix="/system", tags=['系统管理-字典管理'])
+app.include_router(configController, prefix="/system", tags=['系统管理-参数管理'])
 app.include_router(noticeController, prefix="/system", tags=['系统管理-通知公告管理'])
 app.include_router(logController, prefix="/system", tags=['系统管理-日志管理'])
 app.include_router(onlineController, prefix="/monitor", tags=['系统监控-在线用户'])

dash-fastapi-backend/config/get_redis.py

@@ -1,5 +1,6 @@
 import aioredis
 from module_admin.service.dict_service import DictDataService
+from module_admin.service.config_service import ConfigService
 from config.env import RedisConfig
 from config.database import SessionLocal
 from utils.log_util import logger
@@ -50,3 +51,15 @@ async def init_sys_dict(cls, redis):
         await DictDataService.init_cache_sys_dict_services(session, redis)
 
         session.close()
+
+    @classmethod
+    async def init_sys_config(cls, redis):
+        """
+        应用启动时缓存参数配置表
+        :param redis: redis对象
+        :return:
+        """
+        session = SessionLocal()
+        await ConfigService.init_cache_sys_config_services(session, redis)
+
+        session.close()

dash-fastapi-backend/module_admin/annotation/log_annotation.py

@@ -45,7 +45,9 @@ async def wrapper(*args, **kwargs):
                 operator_type = 1
             if "Mobile" in user_agent or "Android" in user_agent or "iPhone" in user_agent:
                 operator_type = 2
+            # 获取请求的url
             oper_url = request.url.path
+            # 获取请求的ip及ip归属区域
             oper_ip = request.headers.get('remote_addr')
             oper_location = '内网IP'
             try:
@@ -64,17 +66,21 @@ async def wrapper(*args, **kwargs):
                 oper_location = '未知'
                 print(e)
             finally:
+                # 根据不同的请求类型使用不同的方法获取请求参数
                 content_type = request.headers.get("Content-Type")
                 if content_type and ("multipart/form-data" in content_type or 'application/x-www-form-urlencoded' in content_type):
                     payload = await request.form()
                     oper_param = "\n".join([f"{key}: {value}" for key, value in payload.items()])
                 else:
                     payload = await request.body()
                     oper_param = json.dumps(json.loads(str(payload, 'utf-8')), ensure_ascii=False)
+                # 日志表请求参数字段长度最大为2000，因此在此处判断长度
                 if len(oper_param) > 2000:
                     oper_param = '请求参数过长'
 
+                # 获取操作时间
                 oper_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+                # 此处在登录之前向原始函数传递一些登录信息，用于监测在线用户的相关信息
                 login_log = {}
                 if log_type == 'login':
                     user_agent_info = parse(user_agent)
@@ -90,29 +96,43 @@ async def wrapper(*args, **kwargs):
                     kwargs['form_data'].login_info = login_log
                 # 调用原始函数
                 result = await func(*args, **kwargs)
+                # 获取请求耗时
                 cost_time = float(time.time() - start_time) * 100
+                # 判断请求是否来自api文档
+                request_from_swagger = request.headers.get('referer').endswith('docs') if request.headers.get('referer') else False
+                request_from_redoc = request.headers.get('referer').endswith('redoc') if request.headers.get('referer') else False
+                # 根据响应结果的类型使用不同的方法获取响应结果参数
                 if isinstance(result, JSONResponse) or isinstance(result, ORJSONResponse) or isinstance(result, UJSONResponse):
                     result_dict = json.loads(str(result.body, 'utf-8'))
                 else:
-                    if result.status_code == 200:
-                        result_dict = {'code': result.status_code, 'message': '获取成功'}
+                    if request_from_swagger or request_from_redoc:
+                        result_dict = {}
                     else:
-                        result_dict = {'code': result.status_code, 'message': '获取失败'}
+                        if result.status_code == 200:
+                            result_dict = {'code': result.status_code, 'message': '获取成功'}
+                        else:
+                            result_dict = {'code': result.status_code, 'message': '获取失败'}
                 json_result = json.dumps(dict(code=result_dict.get('code'), message=result_dict.get('message')), ensure_ascii=False)
+                # 根据响应结果获取响应状态及异常信息
                 status = 1
                 error_msg = ''
                 if result_dict.get('code') == 200:
                     status = 0
                 else:
                     error_msg = result_dict.get('message')
+                # 根据日志类型向对应的日志表插入数据
                 if log_type == 'login':
-                    user = kwargs.get('form_data')
-                    user_name = user.username
-                    login_log['user_name'] = user_name
-                    login_log['status'] = str(status)
-                    login_log['msg'] = result_dict.get('message')
+                    # 登录请求来自于api文档时不记录登录日志，其余情况则记录
+                    if request_from_swagger or request_from_redoc:
+                        pass
+                    else:
+                        user = kwargs.get('form_data')
+                        user_name = user.username
+                        login_log['user_name'] = user_name
+                        login_log['status'] = str(status)
+                        login_log['msg'] = result_dict.get('message')
 
-                    LoginLogService.add_login_log_services(query_db, LogininforModel(**login_log))
+                        LoginLogService.add_login_log_services(query_db, LogininforModel(**login_log))
                 else:
                     current_user = await get_current_user(request, token, query_db)
                     oper_name = current_user.user.user_name

dash-fastapi-backend/module_admin/controller/common_controller.py

@@ -3,6 +3,7 @@
 from config.env import CachePathConfig
 from module_admin.service.login_service import get_current_user
 from module_admin.service.common_service import *
+from module_admin.service.config_service import ConfigService
 from utils.response_util import *
 from utils.log_util import *
 from module_admin.aspect.interface_auth import CheckUserInterfaceAuth
@@ -70,3 +71,15 @@ def generate_file():
     except Exception as e:
         logger.exception(e)
         return response_500(data="", message=str(e))
+
+
+@commonController.get("/config/query/{config_key}")
+async def query_system_config(request: Request, config_key: str):
+    try:
+        # 获取全量数据
+        config_query_result = await ConfigService.query_config_list_from_cache_services(request.app.state.redis, config_key)
+        logger.info('获取成功')
+        return response_200(data=config_query_result, message="获取成功")
+    except Exception as e:
+        logger.exception(e)
+        return response_500(data="", message=str(e))

dash-fastapi-backend/module_admin/controller/config_controller.py

@@ -0,0 +1,123 @@
+from fastapi import APIRouter, Request
+from fastapi import Depends
+from config.get_db import get_db
+from module_admin.service.login_service import get_current_user, CurrentUserInfoServiceResponse
+from module_admin.service.config_service import *
+from module_admin.entity.vo.config_vo import *
+from utils.response_util import *
+from utils.log_util import *
+from utils.page_util import get_page_obj
+from utils.common_util import bytes2file_response
+from module_admin.aspect.interface_auth import CheckUserInterfaceAuth
+from module_admin.annotation.log_annotation import log_decorator
+
+
+configController = APIRouter(dependencies=[Depends(get_current_user)])
+
+
+@configController.post("/config/get", response_model=ConfigPageObjectResponse, dependencies=[Depends(CheckUserInterfaceAuth('system:config:list'))])
+async def get_system_config_list(request: Request, config_page_query: ConfigPageObject, query_db: Session = Depends(get_db)):
+    try:
+        config_query = ConfigQueryModel(**config_page_query.dict())
+        # 获取全量数据
+        config_query_result = ConfigService.get_config_list_services(query_db, config_query)
+        # 分页操作
+        config_page_query_result = get_page_obj(config_query_result, config_page_query.page_num, config_page_query.page_size)
+        logger.info('获取成功')
+        return response_200(data=config_page_query_result, message="获取成功")
+    except Exception as e:
+        logger.exception(e)
+        return response_500(data="", message=str(e))
+
+
+@configController.post("/config/add", response_model=CrudConfigResponse, dependencies=[Depends(CheckUserInterfaceAuth('system:config:add'))])
+@log_decorator(title='参数管理', business_type=1)
+async def add_system_config(request: Request, add_config: ConfigModel, query_db: Session = Depends(get_db), current_user: CurrentUserInfoServiceResponse = Depends(get_current_user)):
+    try:
+        add_config.create_by = current_user.user.user_name
+        add_config.update_by = current_user.user.user_name
+        add_config_result = await ConfigService.add_config_services(request, query_db, add_config)
+        if add_config_result.is_success:
+            logger.info(add_config_result.message)
+            return response_200(data=add_config_result, message=add_config_result.message)
+        else:
+            logger.warning(add_config_result.message)
+            return response_400(data="", message=add_config_result.message)
+    except Exception as e:
+        logger.exception(e)
+        return response_500(data="", message=str(e))
+
+
+@configController.patch("/config/edit", response_model=CrudConfigResponse, dependencies=[Depends(CheckUserInterfaceAuth('system:config:edit'))])
+@log_decorator(title='参数管理', business_type=2)
+async def edit_system_config(request: Request, edit_config: ConfigModel, query_db: Session = Depends(get_db), current_user: CurrentUserInfoServiceResponse = Depends(get_current_user)):
+    try:
+        edit_config.update_by = current_user.user.user_name
+        edit_config.update_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        edit_config_result = await ConfigService.edit_config_services(request, query_db, edit_config)
+        if edit_config_result.is_success:
+            logger.info(edit_config_result.message)
+            return response_200(data=edit_config_result, message=edit_config_result.message)
+        else:
+            logger.warning(edit_config_result.message)
+            return response_400(data="", message=edit_config_result.message)
+    except Exception as e:
+        logger.exception(e)
+        return response_500(data="", message=str(e))
+
+
+@configController.post("/config/delete", response_model=CrudConfigResponse, dependencies=[Depends(CheckUserInterfaceAuth('system:config:remove'))])
+@log_decorator(title='参数管理', business_type=3)
+async def delete_system_config(request: Request, delete_config: DeleteConfigModel, query_db: Session = Depends(get_db)):
+    try:
+        delete_config_result = await ConfigService.delete_config_services(request, query_db, delete_config)
+        if delete_config_result.is_success:
+            logger.info(delete_config_result.message)
+            return response_200(data=delete_config_result, message=delete_config_result.message)
+        else:
+            logger.warning(delete_config_result.message)
+            return response_400(data="", message=delete_config_result.message)
+    except Exception as e:
+        logger.exception(e)
+        return response_500(data="", message=str(e))
+
+
+@configController.get("/config/{config_id}", response_model=ConfigModel, dependencies=[Depends(CheckUserInterfaceAuth('system:config:query'))])
+async def query_detail_system_config(request: Request, config_id: int, query_db: Session = Depends(get_db)):
+    try:
+        detail_config_result = ConfigService.detail_config_services(query_db, config_id)
+        logger.info(f'获取config_id为{config_id}的信息成功')
+        return response_200(data=detail_config_result, message='获取成功')
+    except Exception as e:
+        logger.exception(e)
+        return response_500(data="", message=str(e))
+
+
+@configController.post("/config/export", dependencies=[Depends(CheckUserInterfaceAuth('system:config:export'))])
+@log_decorator(title='参数管理', business_type=5)
+async def export_system_config_list(request: Request, config_query: ConfigQueryModel, query_db: Session = Depends(get_db)):
+    try:
+        # 获取全量数据
+        config_query_result = ConfigService.get_config_list_services(query_db, config_query)
+        config_export_result = ConfigService.export_config_list_services(config_query_result)
+        logger.info('导出成功')
+        return streaming_response_200(data=bytes2file_response(config_export_result))
+    except Exception as e:
+        logger.exception(e)
+        return response_500(data="", message=str(e))
+
+
+@configController.post("/config/refresh", response_model=CrudConfigResponse, dependencies=[Depends(CheckUserInterfaceAuth('system:config:edit'))])
+@log_decorator(title='参数管理', business_type=2)
+async def refresh_system_config(request: Request, query_db: Session = Depends(get_db)):
+    try:
+        refresh_config_result = await ConfigService.refresh_sys_config_services(request, query_db)
+        if refresh_config_result.is_success:
+            logger.info(refresh_config_result.message)
+            return response_200(data=refresh_config_result, message=refresh_config_result.message)
+        else:
+            logger.warning(refresh_config_result.message)
+            return response_400(data="", message=refresh_config_result.message)
+    except Exception as e:
+        logger.exception(e)
+        return response_500(data="", message=str(e))

dash-fastapi-backend/module_admin/controller/login_controller.py

@@ -17,13 +17,15 @@
 @loginController.post("/loginByAccount", response_model=Token)
 @log_decorator(title='用户登录', business_type=0, log_type='login')
 async def login(request: Request, form_data: CustomOAuth2PasswordRequestForm = Depends(), query_db: Session = Depends(get_db)):
+    captcha_enabled = True if await request.app.state.redis.get(f'sys_config:sys.account.captchaEnabled') == 'true' else False
     user = UserLogin(
         **dict(
             user_name=form_data.username,
             password=form_data.password,
             captcha=form_data.captcha,
             session_id=form_data.session_id,
-            login_info=form_data.login_info
+            login_info=form_data.login_info,
+            captcha_enabled=captcha_enabled
         )
     )
     try:
@@ -49,8 +51,13 @@ async def login(request: Request, form_data: CustomOAuth2PasswordRequestForm = D
         # await request.app.state.redis.set(f'{result.user_id}_access_token', access_token, ex=timedelta(minutes=30))
         # await request.app.state.redis.set(f'{result.user_id}_session_id', session_id, ex=timedelta(minutes=30))
         logger.info('登录成功')
+        # 判断请求是否来自于api文档，如果是返回指定格式的结果，用于修复api文档认证成功后token显示undefined的bug
+        request_from_swagger = request.headers.get('referer').endswith('docs') if request.headers.get('referer') else False
+        request_from_redoc = request.headers.get('referer').endswith('redoc') if request.headers.get('referer') else False
+        if request_from_swagger or request_from_redoc:
+            return {'access_token': access_token, 'token_type': 'Bearer'}
         return response_200(
-            data={'access_token': access_token, 'token_type': 'bearer'},
+            data={'access_token': access_token, 'token_type': 'Bearer'},
             message='登录成功'
         )
     except Exception as e: