refactor: 重构RedisInitKeyConfig为枚举类型

ruoyi-fastapi-backend/config/enums.py

@@ -27,3 +27,25 @@ class BusinessType(Enum):
     FORCE = 7
     GENCODE = 8
     CLEAN = 9
+
+
+class RedisInitKeyConfig(Enum):
+    """
+    系统内置Redis键名
+    """
+
+    @property
+    def key(self):
+        return self.value.get('key')
+
+    @property
+    def remark(self):
+        return self.value.get('remark')
+
+    ACCESS_TOKEN = {'key': 'access_token', 'remark': '登录令牌信息'}
+    SYS_DICT = {'key': 'sys_dict', 'remark': '数据字典'}
+    SYS_CONFIG = {'key': 'sys_config', 'remark': '配置信息'}
+    CAPTCHA_CODES = {'key': 'captcha_codes', 'remark': '图片验证码'}
+    ACCOUNT_LOCK = {'key': 'account_lock', 'remark': '用户锁定'}
+    PASSWORD_ERROR_COUNT = {'key': 'password_error_count', 'remark': '密码错误次数'}
+    SMS_CODE = {'key': 'sms_code', 'remark': '短信验证码'}

ruoyi-fastapi-backend/config/env.py

@@ -117,20 +117,6 @@ class CachePathConfig:
     PATHSTR = 'caches'
 
 
-class RedisInitKeyConfig:
-    """
-    系统内置Redis键名
-    """
-
-    ACCESS_TOKEN = {'key': 'access_token', 'remark': '登录令牌信息'}
-    SYS_DICT = {'key': 'sys_dict', 'remark': '数据字典'}
-    SYS_CONFIG = {'key': 'sys_config', 'remark': '配置信息'}
-    CAPTCHA_CODES = {'key': 'captcha_codes', 'remark': '图片验证码'}
-    ACCOUNT_LOCK = {'key': 'account_lock', 'remark': '用户锁定'}
-    PASSWORD_ERROR_COUNT = {'key': 'password_error_count', 'remark': '密码错误次数'}
-    SMS_CODE = {'key': 'sms_code', 'remark': '短信验证码'}
-
-
 class GetConfig:
     """
     获取配置

ruoyi-fastapi-backend/module_admin/controller/captcha_controller.py

@@ -1,7 +1,7 @@
 import uuid
 from datetime import timedelta
 from fastapi import APIRouter, Request
-from config.env import RedisInitKeyConfig
+from config.enums import RedisInitKeyConfig
 from module_admin.entity.vo.login_vo import CaptchaCode
 from module_admin.service.captcha_service import CaptchaService
 from utils.response_util import ResponseUtil
@@ -15,14 +15,13 @@ captchaController = APIRouter()
 async def get_captcha_image(request: Request):
     captcha_enabled = (
         True
-        if await request.app.state.redis.get(f"{RedisInitKeyConfig.SYS_CONFIG.get('key')}:sys.account.captchaEnabled")
+        if await request.app.state.redis.get(f'{RedisInitKeyConfig.SYS_CONFIG.key}:sys.account.captchaEnabled')
         == 'true'
         else False
     )
     register_enabled = (
         True
-        if await request.app.state.redis.get(f"{RedisInitKeyConfig.SYS_CONFIG.get('key')}:sys.account.registerUser")
+        if await request.app.state.redis.get(f'{RedisInitKeyConfig.SYS_CONFIG.key}:sys.account.registerUser') == 'true'
-        == 'true'
         else False
     )
     session_id = str(uuid.uuid4())
@@ -30,7 +29,7 @@ async def get_captcha_image(request: Request):
     image = captcha_result[0]
     computed_result = captcha_result[1]
     await request.app.state.redis.set(
-        f"{RedisInitKeyConfig.CAPTCHA_CODES.get('key')}:{session_id}", computed_result, ex=timedelta(minutes=2)
+        f'{RedisInitKeyConfig.CAPTCHA_CODES.key}:{session_id}', computed_result, ex=timedelta(minutes=2)
     )
     logger.info(f'编号为{session_id}的会话获取图片验证码成功')
 

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

@@ -4,8 +4,8 @@ from fastapi import APIRouter, Depends, Request
 from jose import jwt
 from sqlalchemy.ext.asyncio import AsyncSession
 from typing import Optional
-from config.enums import BusinessType
+from config.enums import BusinessType, RedisInitKeyConfig
-from config.env import AppConfig, JwtConfig, RedisInitKeyConfig
+from config.env import AppConfig, JwtConfig
 from config.get_db import get_db
 from module_admin.annotation.log_annotation import Log
 from module_admin.entity.vo.common_vo import CrudResponseModel
@@ -27,7 +27,7 @@ async def login(
 ):
     captcha_enabled = (
         True
-        if await request.app.state.redis.get(f"{RedisInitKeyConfig.SYS_CONFIG.get('key')}:sys.account.captchaEnabled")
+        if await request.app.state.redis.get(f'{RedisInitKeyConfig.SYS_CONFIG.key}:sys.account.captchaEnabled')
         == 'true'
         else False
     )
@@ -54,14 +54,14 @@ async def login(
     )
     if AppConfig.app_same_time_login:
         await request.app.state.redis.set(
-            f"{RedisInitKeyConfig.ACCESS_TOKEN.get('key')}:{session_id}",
+            f'{RedisInitKeyConfig.ACCESS_TOKEN.key}:{session_id}',
             access_token,
             ex=timedelta(minutes=JwtConfig.jwt_redis_expire_minutes),
         )
     else:
         # 此方法可实现同一账号同一时间只能登录一次
         await request.app.state.redis.set(
-            f"{RedisInitKeyConfig.ACCESS_TOKEN.get('key')}:{result[0].user_id}",
+            f'{RedisInitKeyConfig.ACCESS_TOKEN.key}:{result[0].user_id}',
             access_token,
             ex=timedelta(minutes=JwtConfig.jwt_redis_expire_minutes),
         )

ruoyi-fastapi-backend/module_admin/service/cache_service.py

@@ -1,5 +1,5 @@
 from fastapi import Request
-from config.env import RedisInitKeyConfig
+from config.enums import RedisInitKeyConfig
 from config.get_redis import RedisUtil
 from module_admin.entity.vo.cache_vo import CacheInfoModel, CacheMonitorModel
 from module_admin.entity.vo.common_vo import CrudResponseModel
@@ -36,16 +36,15 @@ class CacheService:
         :return: 缓存名称列表信息
         """
         name_list = []
-        for attr_name in dir(RedisInitKeyConfig):
+        for key_config in RedisInitKeyConfig:
-            if not attr_name.startswith('__') and isinstance(getattr(RedisInitKeyConfig, attr_name), dict):
+            name_list.append(
-                name_list.append(
+                CacheInfoModel(
-                    CacheInfoModel(
+                    cacheKey='',
-                        cacheKey='',
+                    cacheName=key_config.key,
-                        cacheName=getattr(RedisInitKeyConfig, attr_name).get('key'),
+                    cacheValue='',
-                        cacheValue='',
+                    remark=key_config.remark,
-                        remark=getattr(RedisInitKeyConfig, attr_name).get('remark'),
-                    )
                 )
+            )
 
         return name_list
 

ruoyi-fastapi-backend/module_admin/service/config_service.py

@@ -2,7 +2,7 @@ from fastapi import Request
 from sqlalchemy.ext.asyncio import AsyncSession
 from typing import List
 from config.constant import CommonConstant
-from config.env import RedisInitKeyConfig
+from config.enums import RedisInitKeyConfig
 from exceptions.exception import ServiceException
 from module_admin.dao.config_dao import ConfigDao
 from module_admin.entity.vo.common_vo import CrudResponseModel
@@ -41,14 +41,14 @@ class ConfigService:
         :return:
         """
         # 获取以sys_config:开头的键列表
-        keys = await redis.keys(f"{RedisInitKeyConfig.SYS_CONFIG.get('key')}:*")
+        keys = await redis.keys(f'{RedisInitKeyConfig.SYS_CONFIG.key}:*')
         # 删除匹配的键
         if keys:
             await redis.delete(*keys)
         config_all = await ConfigDao.get_config_list(query_db, ConfigPageQueryModel(**dict()), is_page=False)
         for config_obj in config_all:
             await redis.set(
-                f"{RedisInitKeyConfig.SYS_CONFIG.get('key')}:{config_obj.get('configKey')}",
+                f"{RedisInitKeyConfig.SYS_CONFIG.key}:{config_obj.get('configKey')}",
                 config_obj.get('configValue'),
             )
 
@@ -61,7 +61,7 @@ class ConfigService:
         :param config_key: 参数键名
         :return: 参数键名对应值
         """
-        result = await redis.get(f"{RedisInitKeyConfig.SYS_CONFIG.get('key')}:{config_key}")
+        result = await redis.get(f'{RedisInitKeyConfig.SYS_CONFIG.key}:{config_key}')
 
         return result
 
@@ -97,7 +97,7 @@ class ConfigService:
                 await ConfigDao.add_config_dao(query_db, page_object)
                 await query_db.commit()
                 await request.app.state.redis.set(
-                    f"{RedisInitKeyConfig.SYS_CONFIG.get('key')}:{page_object.config_key}", page_object.config_value
+                    f'{RedisInitKeyConfig.SYS_CONFIG.key}:{page_object.config_key}', page_object.config_value
                 )
                 return CrudResponseModel(is_success=True, message='新增成功')
             except Exception as e:
@@ -125,10 +125,10 @@ class ConfigService:
                     await query_db.commit()
                     if config_info.config_key != page_object.config_key:
                         await request.app.state.redis.delete(
-                            f"{RedisInitKeyConfig.SYS_CONFIG.get('key')}:{config_info.config_key}"
+                            f'{RedisInitKeyConfig.SYS_CONFIG.key}:{config_info.config_key}'
                         )
                     await request.app.state.redis.set(
-                        f"{RedisInitKeyConfig.SYS_CONFIG.get('key')}:{page_object.config_key}", page_object.config_value
+                        f'{RedisInitKeyConfig.SYS_CONFIG.key}:{page_object.config_key}', page_object.config_value
                     )
                     return CrudResponseModel(is_success=True, message='更新成功')
                 except Exception as e:
@@ -157,9 +157,7 @@ class ConfigService:
                         raise ServiceException(message=f'内置参数{config_info.config_key}不能删除')
                     else:
                         await ConfigDao.delete_config_dao(query_db, ConfigModel(configId=int(config_id)))
-                        delete_config_key_list.append(
+                        delete_config_key_list.append(f'{RedisInitKeyConfig.SYS_CONFIG.key}:{config_info.config_key}')
-                            f"{RedisInitKeyConfig.SYS_CONFIG.get('key')}:{config_info.config_key}"
-                        )
                 await query_db.commit()
                 if delete_config_key_list:
                     await request.app.state.redis.delete(*delete_config_key_list)

ruoyi-fastapi-backend/module_admin/service/dict_service.py

@@ -3,7 +3,7 @@ from fastapi import Request
 from sqlalchemy.ext.asyncio import AsyncSession
 from typing import List
 from config.constant import CommonConstant
-from config.env import RedisInitKeyConfig
+from config.enums import RedisInitKeyConfig
 from exceptions.exception import ServiceException
 from module_admin.dao.dict_dao import DictDataDao, DictTypeDao
 from module_admin.entity.vo.common_vo import CrudResponseModel
@@ -72,9 +72,7 @@ class DictTypeService:
             try:
                 await DictTypeDao.add_dict_type_dao(query_db, page_object)
                 await query_db.commit()
-                await request.app.state.redis.set(
+                await request.app.state.redis.set(f'{RedisInitKeyConfig.SYS_DICT.key}:{page_object.dict_type}', '')
-                    f"{RedisInitKeyConfig.SYS_DICT.get('key')}:{page_object.dict_type}", ''
-                )
                 result = dict(is_success=True, message='新增成功')
             except Exception as e:
                 await query_db.rollback()
@@ -114,7 +112,7 @@ class DictTypeService:
                     if dict_type_info.dict_type != page_object.dict_type:
                         dict_data = [CamelCaseUtil.transform_result(row) for row in dict_data_list if row]
                         await request.app.state.redis.set(
-                            f"{RedisInitKeyConfig.SYS_DICT.get('key')}:{page_object.dict_type}",
+                            f'{RedisInitKeyConfig.SYS_DICT.key}:{page_object.dict_type}',
                             json.dumps(dict_data, ensure_ascii=False, default=str),
                         )
                     return CrudResponseModel(is_success=True, message='更新成功')
@@ -145,7 +143,7 @@ class DictTypeService:
                     if (await DictDataDao.count_dict_data_dao(query_db, dict_type_into.dict_type)) > 0:
                         raise ServiceException(message=f'{dict_type_into.dict_name}已分配，不能删除')
                     await DictTypeDao.delete_dict_type_dao(query_db, DictTypeModel(dictId=int(dict_id)))
-                    delete_dict_type_list.append(f"{RedisInitKeyConfig.SYS_DICT.get('key')}:{dict_type_into.dict_type}")
+                    delete_dict_type_list.append(f'{RedisInitKeyConfig.SYS_DICT.key}:{dict_type_into.dict_type}')
                 await query_db.commit()
                 if delete_dict_type_list:
                     await request.app.state.redis.delete(*delete_dict_type_list)
@@ -267,7 +265,7 @@ class DictDataService:
         :return:
         """
         # 获取以sys_dict:开头的键列表
-        keys = await redis.keys(f"{RedisInitKeyConfig.SYS_DICT.get('key')}:*")
+        keys = await redis.keys(f'{RedisInitKeyConfig.SYS_DICT.key}:*')
         # 删除匹配的键
         if keys:
             await redis.delete(*keys)
@@ -277,7 +275,7 @@ class DictDataService:
             dict_data_list = await DictDataDao.query_dict_data_list(query_db, dict_type)
             dict_data = [CamelCaseUtil.transform_result(row) for row in dict_data_list if row]
             await redis.set(
-                f"{RedisInitKeyConfig.SYS_DICT.get('key')}:{dict_type}",
+                f'{RedisInitKeyConfig.SYS_DICT.key}:{dict_type}',
                 json.dumps(dict_data, ensure_ascii=False, default=str),
             )
 
@@ -291,7 +289,7 @@ class DictDataService:
         :return: 字典数据列表信息对象
         """
         result = []
-        dict_data_list_result = await redis.get(f"{RedisInitKeyConfig.SYS_DICT.get('key')}:{dict_type}")
+        dict_data_list_result = await redis.get(f'{RedisInitKeyConfig.SYS_DICT.key}:{dict_type}')
         if dict_data_list_result:
             result = json.loads(dict_data_list_result)
 
@@ -332,7 +330,7 @@ class DictDataService:
                 await query_db.commit()
                 dict_data_list = await cls.query_dict_data_list_services(query_db, page_object.dict_type)
                 await request.app.state.redis.set(
-                    f"{RedisInitKeyConfig.SYS_DICT.get('key')}:{page_object.dict_type}",
+                    f'{RedisInitKeyConfig.SYS_DICT.key}:{page_object.dict_type}',
                     json.dumps(CamelCaseUtil.transform_result(dict_data_list), ensure_ascii=False, default=str),
                 )
                 return CrudResponseModel(is_success=True, message='新增成功')
@@ -363,7 +361,7 @@ class DictDataService:
                     await query_db.commit()
                     dict_data_list = await cls.query_dict_data_list_services(query_db, page_object.dict_type)
                     await request.app.state.redis.set(
-                        f"{RedisInitKeyConfig.SYS_DICT.get('key')}:{page_object.dict_type}",
+                        f'{RedisInitKeyConfig.SYS_DICT.key}:{page_object.dict_type}',
                         json.dumps(CamelCaseUtil.transform_result(dict_data_list), ensure_ascii=False, default=str),
                     )
                     return CrudResponseModel(is_success=True, message='更新成功')
@@ -397,7 +395,7 @@ class DictDataService:
                 for dict_type in list(set(delete_dict_type_list)):
                     dict_data_list = await cls.query_dict_data_list_services(query_db, dict_type)
                     await request.app.state.redis.set(
-                        f"{RedisInitKeyConfig.SYS_DICT.get('key')}:{dict_type}",
+                        f'{RedisInitKeyConfig.SYS_DICT.key}:{dict_type}',
                         json.dumps(CamelCaseUtil.transform_result(dict_data_list), ensure_ascii=False, default=str),
                     )
                 return CrudResponseModel(is_success=True, message='删除成功')

ruoyi-fastapi-backend/module_admin/service/login_service.py

@@ -7,7 +7,8 @@ from jose import JWTError, jwt
 from sqlalchemy.ext.asyncio import AsyncSession
 from typing import Dict, List, Optional, Union
 from config.constant import CommonConstant, MenuConstant
-from config.env import AppConfig, JwtConfig, RedisInitKeyConfig
+from config.enums import RedisInitKeyConfig
+from config.env import AppConfig, JwtConfig
 from config.get_db import get_db
 from exceptions.exception import LoginException, AuthException, ServiceException
 from module_admin.dao.login_dao import login_by_account
@@ -72,7 +73,7 @@ class LoginService:
         """
         await cls.__check_login_ip(request)
         account_lock = await request.app.state.redis.get(
-            f"{RedisInitKeyConfig.ACCOUNT_LOCK.get('key')}:{login_user.user_name}"
+            f'{RedisInitKeyConfig.ACCOUNT_LOCK.key}:{login_user.user_name}'
         )
         if login_user.user_name == account_lock:
             logger.warning('账号已锁定，请稍后再试')
@@ -97,23 +98,23 @@ class LoginService:
             raise LoginException(data='', message='用户不存在')
         if not PwdUtil.verify_password(login_user.password, user[0].password):
             cache_password_error_count = await request.app.state.redis.get(
-                f"{RedisInitKeyConfig.PASSWORD_ERROR_COUNT.get('key')}:{login_user.user_name}"
+                f'{RedisInitKeyConfig.PASSWORD_ERROR_COUNT.key}:{login_user.user_name}'
             )
             password_error_counted = 0
             if cache_password_error_count:
                 password_error_counted = cache_password_error_count
             password_error_count = int(password_error_counted) + 1
             await request.app.state.redis.set(
-                f"{RedisInitKeyConfig.PASSWORD_ERROR_COUNT.get('key')}:{login_user.user_name}",
+                f'{RedisInitKeyConfig.PASSWORD_ERROR_COUNT.key}:{login_user.user_name}',
                 password_error_count,
                 ex=timedelta(minutes=10),
             )
             if password_error_count > 5:
                 await request.app.state.redis.delete(
-                    f"{RedisInitKeyConfig.PASSWORD_ERROR_COUNT.get('key')}:{login_user.user_name}"
+                    f'{RedisInitKeyConfig.PASSWORD_ERROR_COUNT.key}:{login_user.user_name}'
                 )
                 await request.app.state.redis.set(
-                    f"{RedisInitKeyConfig.ACCOUNT_LOCK.get('key')}:{login_user.user_name}",
+                    f'{RedisInitKeyConfig.ACCOUNT_LOCK.key}:{login_user.user_name}',
                     login_user.user_name,
                     ex=timedelta(minutes=10),
                 )
@@ -124,9 +125,7 @@ class LoginService:
         if user[0].status == '1':
             logger.warning('用户已停用')
             raise LoginException(data='', message='用户已停用')
-        await request.app.state.redis.delete(
+        await request.app.state.redis.delete(f'{RedisInitKeyConfig.PASSWORD_ERROR_COUNT.key}:{login_user.user_name}')
-            f"{RedisInitKeyConfig.PASSWORD_ERROR_COUNT.get('key')}:{login_user.user_name}"
-        )
         return user
 
     @classmethod
@@ -137,9 +136,7 @@ class LoginService:
         :param request: Request对象
         :return: 校验结果
         """
-        black_ip_value = await request.app.state.redis.get(
+        black_ip_value = await request.app.state.redis.get(f'{RedisInitKeyConfig.SYS_CONFIG.key}:sys.login.blackIPList')
-            f"{RedisInitKeyConfig.SYS_CONFIG.get('key')}:sys.login.blackIPList"
-        )
         black_ip_list = black_ip_value.split(',') if black_ip_value else []
         if request.headers.get('X-Forwarded-For') in black_ip_list:
             logger.warning('当前IP禁止登录')
@@ -155,9 +152,7 @@ class LoginService:
         :param login_user: 登录用户对象
         :return: 校验结果
         """
-        captcha_value = await request.app.state.redis.get(
+        captcha_value = await request.app.state.redis.get(f'{RedisInitKeyConfig.CAPTCHA_CODES.key}:{login_user.uuid}')
-            f"{RedisInitKeyConfig.CAPTCHA_CODES.get('key')}:{login_user.uuid}"
-        )
         if not captcha_value:
             logger.warning('验证码已失效')
             raise LoginException(data='', message='验证码已失效')
@@ -218,24 +213,22 @@ class LoginService:
             logger.warning('用户token不合法')
             raise AuthException(data='', message='用户token不合法')
         if AppConfig.app_same_time_login:
-            redis_token = await request.app.state.redis.get(
+            redis_token = await request.app.state.redis.get(f'{RedisInitKeyConfig.ACCESS_TOKEN.key}:{session_id}')
-                f"{RedisInitKeyConfig.ACCESS_TOKEN.get('key')}:{session_id}"
-            )
         else:
             # 此方法可实现同一账号同一时间只能登录一次
             redis_token = await request.app.state.redis.get(
-                f"{RedisInitKeyConfig.ACCESS_TOKEN.get('key')}:{query_user.get('user_basic_info').user_id}"
+                f"{RedisInitKeyConfig.ACCESS_TOKEN.key}:{query_user.get('user_basic_info').user_id}"
             )
         if token == redis_token:
             if AppConfig.app_same_time_login:
                 await request.app.state.redis.set(
-                    f"{RedisInitKeyConfig.ACCESS_TOKEN.get('key')}:{session_id}",
+                    f'{RedisInitKeyConfig.ACCESS_TOKEN.key}:{session_id}',
                     redis_token,
                     ex=timedelta(minutes=JwtConfig.jwt_redis_expire_minutes),
                 )
             else:
                 await request.app.state.redis.set(
-                    f"{RedisInitKeyConfig.ACCESS_TOKEN.get('key')}:{query_user.get('user_basic_info').user_id}",
+                    f"{RedisInitKeyConfig.ACCESS_TOKEN.key}:{query_user.get('user_basic_info').user_id}",
                     redis_token,
                     ex=timedelta(minutes=JwtConfig.jwt_redis_expire_minutes),
                 )
@@ -386,15 +379,13 @@ class LoginService:
         """
         register_enabled = (
             True
-            if await request.app.state.redis.get(f"{RedisInitKeyConfig.SYS_CONFIG.get('key')}:sys.account.registerUser")
+            if await request.app.state.redis.get(f'{RedisInitKeyConfig.SYS_CONFIG.key}:sys.account.registerUser')
             == 'true'
             else False
         )
         captcha_enabled = (
             True
-            if await request.app.state.redis.get(
+            if await request.app.state.redis.get(f'{RedisInitKeyConfig.SYS_CONFIG.key}:sys.account.captchaEnabled')
-                f"{RedisInitKeyConfig.SYS_CONFIG.get('key')}:sys.account.captchaEnabled"
-            )
             == 'true'
             else False
         )
@@ -402,7 +393,7 @@ class LoginService:
             if register_enabled:
                 if captcha_enabled:
                     captcha_value = await request.app.state.redis.get(
-                        f"{RedisInitKeyConfig.CAPTCHA_CODES.get('key')}:{user_register.uuid}"
+                        f'{RedisInitKeyConfig.CAPTCHA_CODES.key}:{user_register.uuid}'
                     )
                     if not captcha_value:
                         raise ServiceException(message='验证码已失效')
@@ -430,9 +421,7 @@ class LoginService:
         :param user: 用户对象
         :return: 短信验证码对象
         """
-        redis_sms_result = await request.app.state.redis.get(
+        redis_sms_result = await request.app.state.redis.get(f'{RedisInitKeyConfig.SMS_CODE.key}:{user.session_id}')
-            f"{RedisInitKeyConfig.SMS_CODE.get('key')}:{user.session_id}"
-        )
         if redis_sms_result:
             return SmsCode(**dict(is_success=False, sms_code='', session_id='', message='短信验证码仍在有效期内'))
         is_user = await UserDao.get_user_by_name(query_db, user.user_name)
@@ -440,7 +429,7 @@ class LoginService:
             sms_code = str(random.randint(100000, 999999))
             session_id = str(uuid.uuid4())
             await request.app.state.redis.set(
-                f"{RedisInitKeyConfig.SMS_CODE.get('key')}:{session_id}", sms_code, ex=timedelta(minutes=2)
+                f'{RedisInitKeyConfig.SMS_CODE.key}:{session_id}', sms_code, ex=timedelta(minutes=2)
             )
             # 此处模拟调用短信服务
             message_service(sms_code)
@@ -460,7 +449,7 @@ class LoginService:
         :return: 重置结果
         """
         redis_sms_result = await request.app.state.redis.get(
-            f"{RedisInitKeyConfig.SMS_CODE.get('key')}:{forget_user.session_id}"
+            f'{RedisInitKeyConfig.SMS_CODE.key}:{forget_user.session_id}'
         )
         if forget_user.sms_code == redis_sms_result:
             forget_user.password = PwdUtil.get_password_hash(forget_user.password)
@@ -470,7 +459,7 @@ class LoginService:
         elif not redis_sms_result:
             result = dict(is_success=False, message='短信验证码已过期')
         else:
-            await request.app.state.redis.delete(f"{RedisInitKeyConfig.SMS_CODE.get('key')}:{forget_user.session_id}")
+            await request.app.state.redis.delete(f'{RedisInitKeyConfig.SMS_CODE.key}:{forget_user.session_id}')
             result = dict(is_success=False, message='短信验证码不正确')
 
         return CrudResponseModel(**result)
@@ -484,7 +473,7 @@ class LoginService:
         :param session_id: 会话编号
         :return: 退出登录结果
         """
-        await request.app.state.redis.delete(f"{RedisInitKeyConfig.ACCESS_TOKEN.get('key')}:{session_id}")
+        await request.app.state.redis.delete(f'{RedisInitKeyConfig.ACCESS_TOKEN.key}:{session_id}')
         # await request.app.state.redis.delete(f'{current_user.user.user_id}_access_token')
         # await request.app.state.redis.delete(f'{current_user.user.user_id}_session_id')
 
@@ -509,7 +498,7 @@ class RouterUtil:
             return ''
 
         return cls.get_route_name(menu.route_name, menu.path)
-    
+
     @classmethod
     def get_route_name(cls, name: str, path: str):
         """

ruoyi-fastapi-backend/module_admin/service/online_service.py

@@ -1,6 +1,7 @@
 from fastapi import Request
 from jose import jwt
-from config.env import JwtConfig, RedisInitKeyConfig
+from config.enums import RedisInitKeyConfig
+from config.env import JwtConfig
 from exceptions.exception import ServiceException
 from module_admin.entity.vo.common_vo import CrudResponseModel
 from module_admin.entity.vo.online_vo import DeleteOnlineModel, OnlineQueryModel
@@ -21,7 +22,7 @@ class OnlineService:
         :param query_object: 查询参数对象
         :return: 在线用户列表信息
         """
-        access_token_keys = await request.app.state.redis.keys(f"{RedisInitKeyConfig.ACCESS_TOKEN.get('key')}*")
+        access_token_keys = await request.app.state.redis.keys(f"{RedisInitKeyConfig.ACCESS_TOKEN.key}*")
         if not access_token_keys:
             access_token_keys = []
         access_token_values_list = [await request.app.state.redis.get(key) for key in access_token_keys]
@@ -69,7 +70,7 @@ class OnlineService:
         if page_object.token_ids:
             token_id_list = page_object.token_ids.split(',')
             for token_id in token_id_list:
-                await request.app.state.redis.delete(f"{RedisInitKeyConfig.ACCESS_TOKEN.get('key')}:{token_id}")
+                await request.app.state.redis.delete(f"{RedisInitKeyConfig.ACCESS_TOKEN.key}:{token_id}")
             return CrudResponseModel(is_success=True, message='强退成功')
         else:
             raise ServiceException(message='传入session_id为空')