feat: 初始化项目架构
This commit is contained in:
insistence
123
ruoyi-fastapi-backend/module_admin/service/cache_service.py
Normal file
123
ruoyi-fastapi-backend/module_admin/service/cache_service.py
Normal file
@@ -0,0 +1,123 @@
|
||||
from fastapi import Request
|
||||
from module_admin.entity.vo.cache_vo import *
|
||||
from config.env import RedisInitKeyConfig
|
||||
from config.get_redis import RedisUtil
|
||||
from module_admin.entity.vo.common_vo import CrudResponseModel
|
||||
|
||||
class CacheService:
|
||||
"""
|
||||
缓存监控模块服务层
|
||||
"""
|
||||
|
||||
@classmethod
|
||||
async def get_cache_monitor_statistical_info_services(cls, request: Request):
|
||||
"""
|
||||
获取缓存监控信息service
|
||||
:param request: Request对象
|
||||
:return: 缓存监控信息
|
||||
"""
|
||||
info = await request.app.state.redis.info()
|
||||
db_size = await request.app.state.redis.dbsize()
|
||||
command_stats_dict = await request.app.state.redis.info('commandstats')
|
||||
command_stats = [dict(name=key.split('_')[1], value=str(value.get('calls'))) for key, value in
|
||||
command_stats_dict.items()]
|
||||
result = CacheMonitorModel(
|
||||
commandStats=command_stats,
|
||||
dbSize=db_size,
|
||||
info=info
|
||||
)
|
||||
|
||||
return result
|
||||
|
||||
@classmethod
|
||||
def get_cache_monitor_cache_name_services(cls):
|
||||
"""
|
||||
获取缓存名称列表信息service
|
||||
:return: 缓存名称列表信息
|
||||
"""
|
||||
name_list = []
|
||||
for attr_name in dir(RedisInitKeyConfig):
|
||||
if not attr_name.startswith('__') and isinstance(getattr(RedisInitKeyConfig, attr_name), dict):
|
||||
name_list.append(
|
||||
CacheInfoModel(
|
||||
cacheKey="",
|
||||
cacheName=getattr(RedisInitKeyConfig, attr_name).get('key'),
|
||||
cacheValue="",
|
||||
remark=getattr(RedisInitKeyConfig, attr_name).get('remark')
|
||||
)
|
||||
)
|
||||
|
||||
return name_list
|
||||
|
||||
@classmethod
|
||||
async def get_cache_monitor_cache_key_services(cls, request: Request, cache_name: str):
|
||||
"""
|
||||
获取缓存键名列表信息service
|
||||
:param request: Request对象
|
||||
:param cache_name: 缓存名称
|
||||
:return: 缓存键名列表信息
|
||||
"""
|
||||
cache_keys = await request.app.state.redis.keys(f"{cache_name}*")
|
||||
cache_key_list = [key.split(':', 1)[1] for key in cache_keys if key.startswith(f"{cache_name}:")]
|
||||
|
||||
return cache_key_list
|
||||
|
||||
@classmethod
|
||||
async def get_cache_monitor_cache_value_services(cls, request: Request, cache_name: str, cache_key: str):
|
||||
"""
|
||||
获取缓存内容信息service
|
||||
:param request: Request对象
|
||||
:param cache_name: 缓存名称
|
||||
:param cache_key: 缓存键名
|
||||
:return: 缓存内容信息
|
||||
"""
|
||||
cache_value = await request.app.state.redis.get(f"{cache_name}:{cache_key}")
|
||||
|
||||
return CacheInfoModel(cacheKey=cache_key, cacheName=cache_name, cacheValue=cache_value, remark="")
|
||||
|
||||
@classmethod
|
||||
async def clear_cache_monitor_cache_name_services(cls, request: Request, cache_name: str):
|
||||
"""
|
||||
清除缓存名称对应所有键值service
|
||||
:param request: Request对象
|
||||
:param cache_name: 缓存名称
|
||||
:return: 操作缓存响应信息
|
||||
"""
|
||||
cache_keys = await request.app.state.redis.keys(f"{cache_name}*")
|
||||
if cache_keys:
|
||||
await request.app.state.redis.delete(*cache_keys)
|
||||
result = dict(is_success=True, message=f"{cache_name}对应键值清除成功")
|
||||
|
||||
return CrudResponseModel(**result)
|
||||
|
||||
@classmethod
|
||||
async def clear_cache_monitor_cache_key_services(cls, request: Request, cache_key: str):
|
||||
"""
|
||||
清除缓存名称对应所有键值service
|
||||
:param request: Request对象
|
||||
:param cache_key: 缓存键名
|
||||
:return: 操作缓存响应信息
|
||||
"""
|
||||
cache_keys = await request.app.state.redis.keys(f"*{cache_key}")
|
||||
if cache_keys:
|
||||
await request.app.state.redis.delete(*cache_keys)
|
||||
result = dict(is_success=True, message=f"{cache_key}清除成功")
|
||||
|
||||
return CrudResponseModel(**result)
|
||||
|
||||
@classmethod
|
||||
async def clear_cache_monitor_all_services(cls, request: Request):
|
||||
"""
|
||||
清除所有缓存service
|
||||
:param request: Request对象
|
||||
:return: 操作缓存响应信息
|
||||
"""
|
||||
cache_keys = await request.app.state.redis.keys()
|
||||
if cache_keys:
|
||||
await request.app.state.redis.delete(*cache_keys)
|
||||
|
||||
result = dict(is_success=True, message="所有缓存清除成功")
|
||||
await RedisUtil.init_sys_dict(request.app.state.redis)
|
||||
await RedisUtil.init_sys_config(request.app.state.redis)
|
||||
|
||||
return CrudResponseModel(**result)
|
||||
@@ -0,0 +1,48 @@
|
||||
from PIL import Image, ImageDraw, ImageFont
|
||||
import io
|
||||
import os
|
||||
import random
|
||||
import base64
|
||||
|
||||
|
||||
class CaptchaService:
|
||||
"""
|
||||
验证码模块服务层
|
||||
"""
|
||||
|
||||
@classmethod
|
||||
def create_captcha_image_service(cls):
|
||||
# 创建空白图像
|
||||
image = Image.new('RGB', (160, 60), color='#EAEAEA')
|
||||
|
||||
# 创建绘图对象
|
||||
draw = ImageDraw.Draw(image)
|
||||
|
||||
# 设置字体
|
||||
font = ImageFont.truetype(os.path.join(os.path.abspath(os.getcwd()), 'assets', 'font', 'Arial.ttf'), size=30)
|
||||
|
||||
# 生成两个0-9之间的随机整数
|
||||
num1 = random.randint(0, 9)
|
||||
num2 = random.randint(0, 9)
|
||||
# 从运算符列表中随机选择一个
|
||||
operational_character_list = ['+', '-', '*']
|
||||
operational_character = random.choice(operational_character_list)
|
||||
# 根据选择的运算符进行计算
|
||||
if operational_character == '+':
|
||||
result = num1 + num2
|
||||
elif operational_character == '-':
|
||||
result = num1 - num2
|
||||
else:
|
||||
result = num1 * num2
|
||||
# 绘制文本
|
||||
text = f"{num1} {operational_character} {num2} = ?"
|
||||
draw.text((25, 15), text, fill='blue', font=font)
|
||||
|
||||
# 将图像数据保存到内存中
|
||||
buffer = io.BytesIO()
|
||||
image.save(buffer, format='PNG')
|
||||
|
||||
# 将图像数据转换为base64字符串
|
||||
base64_string = base64.b64encode(buffer.getvalue()).decode()
|
||||
|
||||
return [base64_string, result]
|
||||
18
ruoyi-fastapi-backend/module_admin/service/common_service.py
Normal file
18
ruoyi-fastapi-backend/module_admin/service/common_service.py
Normal file
@@ -0,0 +1,18 @@
|
||||
import os
|
||||
from fastapi import UploadFile
|
||||
|
||||
|
||||
class CommonService:
|
||||
"""
|
||||
通用模块服务层
|
||||
"""
|
||||
|
||||
@classmethod
|
||||
def upload_service(cls, path: str, task_path: str, upload_id: str, file: UploadFile):
|
||||
|
||||
filepath = os.path.join(path, task_path, upload_id, f'{file.filename}')
|
||||
with open(filepath, 'wb') as f:
|
||||
# 流式写出大型文件，这里的10代表10MB
|
||||
for chunk in iter(lambda: file.file.read(1024 * 1024 * 10), b''):
|
||||
f.write(chunk)
|
||||
|
||||
190
ruoyi-fastapi-backend/module_admin/service/config_service.py
Normal file
190
ruoyi-fastapi-backend/module_admin/service/config_service.py
Normal file
@@ -0,0 +1,190 @@
|
||||
from fastapi import Request
|
||||
from config.env import RedisInitKeyConfig
|
||||
from module_admin.dao.config_dao import *
|
||||
from module_admin.entity.vo.common_vo import CrudResponseModel
|
||||
from utils.common_util import export_list2excel, CamelCaseUtil
|
||||
|
||||
|
||||
class ConfigService:
|
||||
"""
|
||||
参数配置管理模块服务层
|
||||
"""
|
||||
|
||||
@classmethod
|
||||
def get_config_list_services(cls, query_db: Session, query_object: ConfigQueryModel):
|
||||
"""
|
||||
获取参数配置列表信息service
|
||||
:param query_db: orm对象
|
||||
:param query_object: 查询参数对象
|
||||
:return: 参数配置列表信息对象
|
||||
"""
|
||||
config_list_result = ConfigDao.get_config_list(query_db, query_object)
|
||||
|
||||
return CamelCaseUtil.transform_result(config_list_result)
|
||||
|
||||
@classmethod
|
||||
async def init_cache_sys_config_services(cls, query_db: Session, redis):
|
||||
"""
|
||||
应用初始化：获取所有参数配置对应的键值对信息并缓存service
|
||||
:param query_db: orm对象
|
||||
:param redis: redis对象
|
||||
:return:
|
||||
"""
|
||||
# 获取以sys_config:开头的键列表
|
||||
keys = await redis.keys(f"{RedisInitKeyConfig.SYS_CONFIG.get('key')}:*")
|
||||
# 删除匹配的键
|
||||
if keys:
|
||||
await redis.delete(*keys)
|
||||
config_all = ConfigDao.get_config_list(query_db, ConfigQueryModel(**dict()))
|
||||
for config_obj in config_all:
|
||||
if config_obj.config_type == 'Y':
|
||||
await redis.set(f"{RedisInitKeyConfig.SYS_CONFIG.get('key')}:{config_obj.config_key}", config_obj.config_value)
|
||||
|
||||
@classmethod
|
||||
async def query_config_list_from_cache_services(cls, redis, config_key: str):
|
||||
"""
|
||||
从缓存获取参数键名对应值service
|
||||
:param redis: redis对象
|
||||
:param config_key: 参数键名
|
||||
:return: 参数键名对应值
|
||||
"""
|
||||
result = await redis.get(f"{RedisInitKeyConfig.SYS_CONFIG.get('key')}:{config_key}")
|
||||
|
||||
return result
|
||||
|
||||
@classmethod
|
||||
async def add_config_services(cls, request: Request, query_db: Session, page_object: ConfigModel):
|
||||
"""
|
||||
新增参数配置信息service
|
||||
:param request: Request对象
|
||||
:param query_db: orm对象
|
||||
:param page_object: 新增参数配置对象
|
||||
:return: 新增参数配置校验结果
|
||||
"""
|
||||
config = ConfigDao.get_config_detail_by_info(query_db, ConfigModel(configKey=page_object.config_key))
|
||||
if config:
|
||||
result = dict(is_success=False, message='参数键名已存在')
|
||||
else:
|
||||
try:
|
||||
ConfigDao.add_config_dao(query_db, page_object)
|
||||
query_db.commit()
|
||||
await cls.init_cache_sys_config_services(query_db, request.app.state.redis)
|
||||
result = dict(is_success=True, message='新增成功')
|
||||
except Exception as e:
|
||||
query_db.rollback()
|
||||
raise e
|
||||
|
||||
return CrudResponseModel(**result)
|
||||
|
||||
@classmethod
|
||||
async def edit_config_services(cls, request: Request, query_db: Session, page_object: ConfigModel):
|
||||
"""
|
||||
编辑参数配置信息service
|
||||
:param request: Request对象
|
||||
:param query_db: orm对象
|
||||
:param page_object: 编辑参数配置对象
|
||||
:return: 编辑参数配置校验结果
|
||||
"""
|
||||
edit_config = page_object.model_dump(exclude_unset=True)
|
||||
config_info = cls.config_detail_services(query_db, edit_config.get('config_id'))
|
||||
if config_info:
|
||||
if config_info.config_key != page_object.config_key or config_info.config_value != page_object.config_value:
|
||||
config = ConfigDao.get_config_detail_by_info(query_db, page_object)
|
||||
if config:
|
||||
result = dict(is_success=False, message='参数配置已存在')
|
||||
return CrudResponseModel(**result)
|
||||
try:
|
||||
ConfigDao.edit_config_dao(query_db, edit_config)
|
||||
query_db.commit()
|
||||
await cls.init_cache_sys_config_services(query_db, request.app.state.redis)
|
||||
result = dict(is_success=True, message='更新成功')
|
||||
except Exception as e:
|
||||
query_db.rollback()
|
||||
raise e
|
||||
else:
|
||||
result = dict(is_success=False, message='参数配置不存在')
|
||||
|
||||
return CrudResponseModel(**result)
|
||||
|
||||
@classmethod
|
||||
async def delete_config_services(cls, request: Request, query_db: Session, page_object: DeleteConfigModel):
|
||||
"""
|
||||
删除参数配置信息service
|
||||
:param request: Request对象
|
||||
:param query_db: orm对象
|
||||
:param page_object: 删除参数配置对象
|
||||
:return: 删除参数配置校验结果
|
||||
"""
|
||||
if page_object.config_ids.split(','):
|
||||
config_id_list = page_object.config_ids.split(',')
|
||||
try:
|
||||
for config_id in config_id_list:
|
||||
ConfigDao.delete_config_dao(query_db, ConfigModel(configId=config_id))
|
||||
query_db.commit()
|
||||
await cls.init_cache_sys_config_services(query_db, request.app.state.redis)
|
||||
result = dict(is_success=True, message='删除成功')
|
||||
except Exception as e:
|
||||
query_db.rollback()
|
||||
raise e
|
||||
else:
|
||||
result = dict(is_success=False, message='传入字典数据id为空')
|
||||
return CrudResponseModel(**result)
|
||||
|
||||
@classmethod
|
||||
def config_detail_services(cls, query_db: Session, config_id: int):
|
||||
"""
|
||||
获取参数配置详细信息service
|
||||
:param query_db: orm对象
|
||||
:param config_id: 参数配置id
|
||||
:return: 参数配置id对应的信息
|
||||
"""
|
||||
config = ConfigDao.get_config_detail_by_id(query_db, config_id=config_id)
|
||||
result = ConfigModel(**CamelCaseUtil.transform_result(config))
|
||||
|
||||
return result
|
||||
|
||||
@staticmethod
|
||||
def export_config_list_services(config_list: List):
|
||||
"""
|
||||
导出参数配置信息service
|
||||
:param config_list: 参数配置信息列表
|
||||
:return: 参数配置信息对应excel的二进制数据
|
||||
"""
|
||||
# 创建一个映射字典，将英文键映射到中文键
|
||||
mapping_dict = {
|
||||
"configId": "参数主键",
|
||||
"configName": "参数名称",
|
||||
"configKey": "参数键名",
|
||||
"configValue": "参数键值",
|
||||
"configType": "系统内置",
|
||||
"createBy": "创建者",
|
||||
"createTime": "创建时间",
|
||||
"updateBy": "更新者",
|
||||
"updateTime": "更新时间",
|
||||
"remark": "备注",
|
||||
}
|
||||
|
||||
data = config_list
|
||||
|
||||
for item in data:
|
||||
if item.get('configType') == 'Y':
|
||||
item['configType'] = '是'
|
||||
else:
|
||||
item['configType'] = '否'
|
||||
new_data = [{mapping_dict.get(key): value for key, value in item.items() if mapping_dict.get(key)} for item in data]
|
||||
binary_data = export_list2excel(new_data)
|
||||
|
||||
return binary_data
|
||||
|
||||
@classmethod
|
||||
async def refresh_sys_config_services(cls, request: Request, query_db: Session):
|
||||
"""
|
||||
刷新字典缓存信息service
|
||||
:param request: Request对象
|
||||
:param query_db: orm对象
|
||||
:return: 刷新字典缓存校验结果
|
||||
"""
|
||||
await cls.init_cache_sys_config_services(query_db, request.app.state.redis)
|
||||
result = dict(is_success=True, message='刷新成功')
|
||||
|
||||
return CrudResponseModel(**result)
|
||||
213
ruoyi-fastapi-backend/module_admin/service/dept_service.py
Normal file
213
ruoyi-fastapi-backend/module_admin/service/dept_service.py
Normal file
@@ -0,0 +1,213 @@
|
||||
from module_admin.dao.dept_dao import *
|
||||
from module_admin.entity.vo.common_vo import CrudResponseModel
|
||||
from utils.common_util import CamelCaseUtil
|
||||
|
||||
|
||||
class DeptService:
|
||||
"""
|
||||
部门管理模块服务层
|
||||
"""
|
||||
|
||||
@classmethod
|
||||
def get_dept_tree_services(cls, query_db: Session, page_object: DeptModel, data_scope_sql: str):
|
||||
"""
|
||||
获取部门树信息service
|
||||
:param query_db: orm对象
|
||||
:param page_object: 查询参数对象
|
||||
:param data_scope_sql: 数据权限对应的查询sql语句
|
||||
:return: 部门树信息对象
|
||||
"""
|
||||
dept_list_result = DeptDao.get_dept_list_for_tree(query_db, page_object, data_scope_sql)
|
||||
dept_tree_result = cls.list_to_tree(dept_list_result)
|
||||
|
||||
return dept_tree_result
|
||||
|
||||
@classmethod
|
||||
def get_dept_for_edit_option_services(cls, query_db: Session, page_object: DeptModel, data_scope_sql: str):
|
||||
"""
|
||||
获取部门编辑部门树信息service
|
||||
:param query_db: orm对象
|
||||
:param page_object: 查询参数对象
|
||||
:param data_scope_sql: 数据权限对应的查询sql语句
|
||||
:return: 部门树信息对象
|
||||
"""
|
||||
dept_list_result = DeptDao.get_dept_info_for_edit_option(query_db, page_object, data_scope_sql)
|
||||
|
||||
return CamelCaseUtil.transform_result(dept_list_result)
|
||||
|
||||
@classmethod
|
||||
def get_dept_list_services(cls, query_db: Session, page_object: DeptModel, data_scope_sql: str):
|
||||
"""
|
||||
获取部门列表信息service
|
||||
:param query_db: orm对象
|
||||
:param page_object: 分页查询参数对象
|
||||
:param data_scope_sql: 数据权限对应的查询sql语句
|
||||
:return: 部门列表信息对象
|
||||
"""
|
||||
dept_list_result = DeptDao.get_dept_list(query_db, page_object, data_scope_sql)
|
||||
|
||||
return CamelCaseUtil.transform_result(dept_list_result)
|
||||
|
||||
@classmethod
|
||||
def add_dept_services(cls, query_db: Session, page_object: DeptModel):
|
||||
"""
|
||||
新增部门信息service
|
||||
:param query_db: orm对象
|
||||
:param page_object: 新增部门对象
|
||||
:return: 新增部门校验结果
|
||||
"""
|
||||
parent_info = DeptDao.get_dept_by_id(query_db, page_object.parent_id)
|
||||
if parent_info:
|
||||
page_object.ancestors = f'{parent_info.ancestors},{page_object.parent_id}'
|
||||
else:
|
||||
page_object.ancestors = '0'
|
||||
dept = DeptDao.get_dept_detail_by_info(query_db, DeptModel(parentId=page_object.parent_id,
|
||||
deptName=page_object.dept_name))
|
||||
if dept:
|
||||
result = dict(is_success=False, message='同一部门下不允许存在同名的部门')
|
||||
else:
|
||||
try:
|
||||
DeptDao.add_dept_dao(query_db, page_object)
|
||||
query_db.commit()
|
||||
result = dict(is_success=True, message='新增成功')
|
||||
except Exception as e:
|
||||
query_db.rollback()
|
||||
raise e
|
||||
|
||||
return CrudResponseModel(**result)
|
||||
|
||||
@classmethod
|
||||
def edit_dept_services(cls, query_db: Session, page_object: DeptModel):
|
||||
"""
|
||||
编辑部门信息service
|
||||
:param query_db: orm对象
|
||||
:param page_object: 编辑部门对象
|
||||
:return: 编辑部门校验结果
|
||||
"""
|
||||
parent_info = DeptDao.get_dept_by_id(query_db, page_object.parent_id)
|
||||
if parent_info:
|
||||
page_object.ancestors = f'{parent_info.ancestors},{page_object.parent_id}'
|
||||
else:
|
||||
page_object.ancestors = '0'
|
||||
edit_dept = page_object.model_dump(exclude_unset=True)
|
||||
dept_info = cls.dept_detail_services(query_db, edit_dept.get('dept_id'))
|
||||
if dept_info:
|
||||
if dept_info.parent_id != page_object.parent_id or dept_info.dept_name != page_object.dept_name:
|
||||
dept = DeptDao.get_dept_detail_by_info(query_db, DeptModel(parentId=page_object.parent_id,
|
||||
deptName=page_object.dept_name))
|
||||
if dept:
|
||||
result = dict(is_success=False, message='同一部门下不允许存在同名的部门')
|
||||
return CrudResponseModel(**result)
|
||||
try:
|
||||
DeptDao.edit_dept_dao(query_db, edit_dept)
|
||||
cls.update_children_info(query_db, DeptModel(deptId=page_object.dept_id,
|
||||
ancestors=page_object.ancestors,
|
||||
updateBy=page_object.update_by,
|
||||
updateTime=page_object.update_time
|
||||
)
|
||||
)
|
||||
query_db.commit()
|
||||
result = dict(is_success=True, message='更新成功')
|
||||
except Exception as e:
|
||||
query_db.rollback()
|
||||
raise e
|
||||
else:
|
||||
result = dict(is_success=False, message='部门不存在')
|
||||
|
||||
return CrudResponseModel(**result)
|
||||
|
||||
@classmethod
|
||||
def delete_dept_services(cls, query_db: Session, page_object: DeleteDeptModel):
|
||||
"""
|
||||
删除部门信息service
|
||||
:param query_db: orm对象
|
||||
:param page_object: 删除部门对象
|
||||
:return: 删除部门校验结果
|
||||
"""
|
||||
if page_object.dept_ids.split(','):
|
||||
dept_id_list = page_object.dept_ids.split(',')
|
||||
ancestors = DeptDao.get_dept_all_ancestors(query_db)
|
||||
try:
|
||||
for dept_id in dept_id_list:
|
||||
for ancestor in ancestors:
|
||||
if dept_id in ancestor[0]:
|
||||
result = dict(is_success=False, message='该部门下有子部门，不允许删除')
|
||||
|
||||
return CrudResponseModel(**result)
|
||||
|
||||
DeptDao.delete_dept_dao(query_db, DeptModel(deptId=dept_id))
|
||||
query_db.commit()
|
||||
result = dict(is_success=True, message='删除成功')
|
||||
except Exception as e:
|
||||
query_db.rollback()
|
||||
raise e
|
||||
else:
|
||||
result = dict(is_success=False, message='传入部门id为空')
|
||||
return CrudResponseModel(**result)
|
||||
|
||||
@classmethod
|
||||
def dept_detail_services(cls, query_db: Session, dept_id: int):
|
||||
"""
|
||||
获取部门详细信息service
|
||||
:param query_db: orm对象
|
||||
:param dept_id: 部门id
|
||||
:return: 部门id对应的信息
|
||||
"""
|
||||
dept = DeptDao.get_dept_detail_by_id(query_db, dept_id=dept_id)
|
||||
result = DeptModel(**CamelCaseUtil.transform_result(dept))
|
||||
|
||||
return result
|
||||
|
||||
@classmethod
|
||||
def list_to_tree(cls, permission_list: list) -> list:
|
||||
"""
|
||||
工具方法：根据部门列表信息生成树形嵌套数据
|
||||
:param permission_list: 部门列表信息
|
||||
:return: 部门树形嵌套数据
|
||||
"""
|
||||
permission_list = [dict(id=item.dept_id, label=item.dept_name, parentId=item.parent_id) for item in
|
||||
permission_list]
|
||||
# 转成id为key的字典
|
||||
mapping: dict = dict(zip([i['id'] for i in permission_list], permission_list))
|
||||
|
||||
# 树容器
|
||||
container: list = []
|
||||
|
||||
for d in permission_list:
|
||||
# 如果找不到父级项，则是根节点
|
||||
parent: dict = mapping.get(d['parentId'])
|
||||
if parent is None:
|
||||
container.append(d)
|
||||
else:
|
||||
children: list = parent.get('children')
|
||||
if not children:
|
||||
children = []
|
||||
children.append(d)
|
||||
parent.update({'children': children})
|
||||
|
||||
return container
|
||||
|
||||
@classmethod
|
||||
def update_children_info(cls, query_db, page_object):
|
||||
"""
|
||||
工具方法：递归更新子部门信息
|
||||
:param query_db: orm对象
|
||||
:param page_object: 编辑部门对象
|
||||
:return:
|
||||
"""
|
||||
children_info = DeptDao.get_children_dept(query_db, page_object.dept_id)
|
||||
if children_info:
|
||||
for child in children_info:
|
||||
child.ancestors = f'{page_object.ancestors},{page_object.dept_id}'
|
||||
DeptDao.edit_dept_dao(query_db,
|
||||
dict(dept_id=child.dept_id,
|
||||
ancestors=child.ancestors,
|
||||
update_by=page_object.update_by,
|
||||
update_time=page_object.update_time
|
||||
)
|
||||
)
|
||||
cls.update_children_info(query_db, DeptModel(dept_id=child.dept_id,
|
||||
ancestors=child.ancestors,
|
||||
update_by=page_object.update_by,
|
||||
update_time=page_object.update_time
|
||||
))
|
||||
363
ruoyi-fastapi-backend/module_admin/service/dict_service.py
Normal file
363
ruoyi-fastapi-backend/module_admin/service/dict_service.py
Normal file
@@ -0,0 +1,363 @@
|
||||
from fastapi import Request
|
||||
import json
|
||||
from config.env import RedisInitKeyConfig
|
||||
from module_admin.dao.dict_dao import *
|
||||
from module_admin.entity.vo.common_vo import CrudResponseModel
|
||||
from utils.common_util import export_list2excel, CamelCaseUtil
|
||||
|
||||
|
||||
class DictTypeService:
|
||||
"""
|
||||
字典类型管理模块服务层
|
||||
"""
|
||||
|
||||
@classmethod
|
||||
def get_dict_type_list_services(cls, query_db: Session, query_object: DictTypeQueryModel):
|
||||
"""
|
||||
获取字典类型列表信息service
|
||||
:param query_db: orm对象
|
||||
:param query_object: 查询参数对象
|
||||
:return: 字典类型列表信息对象
|
||||
"""
|
||||
dict_type_list_result = DictTypeDao.get_dict_type_list(query_db, query_object)
|
||||
|
||||
return CamelCaseUtil.transform_result(dict_type_list_result)
|
||||
|
||||
@classmethod
|
||||
async def add_dict_type_services(cls, request: Request, query_db: Session, page_object: DictTypeModel):
|
||||
"""
|
||||
新增字典类型信息service
|
||||
:param request: Request对象
|
||||
:param query_db: orm对象
|
||||
:param page_object: 新增岗位对象
|
||||
:return: 新增字典类型校验结果
|
||||
"""
|
||||
dict_type = DictTypeDao.get_dict_type_detail_by_info(query_db, DictTypeModel(dictType=page_object.dict_type))
|
||||
if dict_type:
|
||||
result = dict(is_success=False, message='字典类型已存在')
|
||||
else:
|
||||
try:
|
||||
DictTypeDao.add_dict_type_dao(query_db, page_object)
|
||||
query_db.commit()
|
||||
await DictDataService.init_cache_sys_dict_services(query_db, request.app.state.redis)
|
||||
result = dict(is_success=True, message='新增成功')
|
||||
except Exception as e:
|
||||
query_db.rollback()
|
||||
raise e
|
||||
|
||||
return CrudResponseModel(**result)
|
||||
|
||||
@classmethod
|
||||
async def edit_dict_type_services(cls, request: Request, query_db: Session, page_object: DictTypeModel):
|
||||
"""
|
||||
编辑字典类型信息service
|
||||
:param request: Request对象
|
||||
:param query_db: orm对象
|
||||
:param page_object: 编辑字典类型对象
|
||||
:return: 编辑字典类型校验结果
|
||||
"""
|
||||
edit_dict_type = page_object.model_dump(exclude_unset=True)
|
||||
dict_type_info = cls.dict_type_detail_services(query_db, edit_dict_type.get('dict_id'))
|
||||
if dict_type_info:
|
||||
if dict_type_info.dict_type != page_object.dict_type or dict_type_info.dict_name != page_object.dict_name:
|
||||
dict_type = DictTypeDao.get_dict_type_detail_by_info(query_db, DictTypeModel(dictType=page_object.dict_type))
|
||||
if dict_type:
|
||||
result = dict(is_success=False, message='字典类型已存在')
|
||||
return CrudResponseModel(**result)
|
||||
try:
|
||||
if dict_type_info.dict_type != page_object.dict_type:
|
||||
query_dict_data = DictDataModel(dictType=dict_type_info.dict_type)
|
||||
dict_data_list = DictDataDao.get_dict_data_list(query_db, query_dict_data)
|
||||
for dict_data in dict_data_list:
|
||||
edit_dict_data = DictDataModel(dictCode=dict_data.dict_code, dictType=page_object.dict_type, updateBy=page_object.update_by).model_dump(exclude_unset=True)
|
||||
DictDataDao.edit_dict_data_dao(query_db, edit_dict_data)
|
||||
DictTypeDao.edit_dict_type_dao(query_db, edit_dict_type)
|
||||
query_db.commit()
|
||||
await DictDataService.init_cache_sys_dict_services(query_db, request.app.state.redis)
|
||||
result = dict(is_success=True, message='更新成功')
|
||||
except Exception as e:
|
||||
query_db.rollback()
|
||||
raise e
|
||||
else:
|
||||
result = dict(is_success=False, message='字典类型不存在')
|
||||
|
||||
return CrudResponseModel(**result)
|
||||
|
||||
@classmethod
|
||||
async def delete_dict_type_services(cls, request: Request, query_db: Session, page_object: DeleteDictTypeModel):
|
||||
"""
|
||||
删除字典类型信息service
|
||||
:param request: Request对象
|
||||
:param query_db: orm对象
|
||||
:param page_object: 删除字典类型对象
|
||||
:return: 删除字典类型校验结果
|
||||
"""
|
||||
if page_object.dict_ids.split(','):
|
||||
dict_id_list = page_object.dict_ids.split(',')
|
||||
try:
|
||||
for dict_id in dict_id_list:
|
||||
DictTypeDao.delete_dict_type_dao(query_db, DictTypeModel(dictId=dict_id))
|
||||
query_db.commit()
|
||||
await DictDataService.init_cache_sys_dict_services(query_db, request.app.state.redis)
|
||||
result = dict(is_success=True, message='删除成功')
|
||||
except Exception as e:
|
||||
query_db.rollback()
|
||||
raise e
|
||||
else:
|
||||
result = dict(is_success=False, message='传入字典类型id为空')
|
||||
return CrudResponseModel(**result)
|
||||
|
||||
@classmethod
|
||||
def dict_type_detail_services(cls, query_db: Session, dict_id: int):
|
||||
"""
|
||||
获取字典类型详细信息service
|
||||
:param query_db: orm对象
|
||||
:param dict_id: 字典类型id
|
||||
:return: 字典类型id对应的信息
|
||||
"""
|
||||
dict_type = DictTypeDao.get_dict_type_detail_by_id(query_db, dict_id=dict_id)
|
||||
result = DictTypeModel(**CamelCaseUtil.transform_result(dict_type))
|
||||
|
||||
return result
|
||||
|
||||
@staticmethod
|
||||
def export_dict_type_list_services(dict_type_list: List):
|
||||
"""
|
||||
导出字典类型信息service
|
||||
:param dict_type_list: 字典信息列表
|
||||
:return: 字典信息对应excel的二进制数据
|
||||
"""
|
||||
# 创建一个映射字典，将英文键映射到中文键
|
||||
mapping_dict = {
|
||||
"dictId": "字典编号",
|
||||
"dictName": "字典名称",
|
||||
"dictType": "字典类型",
|
||||
"status": "状态",
|
||||
"createBy": "创建者",
|
||||
"createTime": "创建时间",
|
||||
"updateBy": "更新者",
|
||||
"updateTime": "更新时间",
|
||||
"remark": "备注",
|
||||
}
|
||||
|
||||
data = dict_type_list
|
||||
|
||||
for item in data:
|
||||
if item.get('status') == '0':
|
||||
item['status'] = '正常'
|
||||
else:
|
||||
item['status'] = '停用'
|
||||
new_data = [{mapping_dict.get(key): value for key, value in item.items() if mapping_dict.get(key)} for item in data]
|
||||
binary_data = export_list2excel(new_data)
|
||||
|
||||
return binary_data
|
||||
|
||||
@classmethod
|
||||
async def refresh_sys_dict_services(cls, request: Request, query_db: Session):
|
||||
"""
|
||||
刷新字典缓存信息service
|
||||
:param request: Request对象
|
||||
:param query_db: orm对象
|
||||
:return: 刷新字典缓存校验结果
|
||||
"""
|
||||
await DictDataService.init_cache_sys_dict_services(query_db, request.app.state.redis)
|
||||
result = dict(is_success=True, message='刷新成功')
|
||||
|
||||
return CrudResponseModel(**result)
|
||||
|
||||
|
||||
class DictDataService:
|
||||
"""
|
||||
字典数据管理模块服务层
|
||||
"""
|
||||
|
||||
@classmethod
|
||||
def get_dict_data_list_services(cls, query_db: Session, query_object: DictDataModel):
|
||||
"""
|
||||
获取字典数据列表信息service
|
||||
:param query_db: orm对象
|
||||
:param query_object: 查询参数对象
|
||||
:return: 字典数据列表信息对象
|
||||
"""
|
||||
dict_data_list_result = DictDataDao.get_dict_data_list(query_db, query_object)
|
||||
|
||||
return CamelCaseUtil.transform_result(dict_data_list_result)
|
||||
|
||||
@classmethod
|
||||
def query_dict_data_list_services(cls, query_db: Session, dict_type: str):
|
||||
"""
|
||||
获取字典数据列表信息service
|
||||
:param query_db: orm对象
|
||||
:param dict_type: 字典类型
|
||||
:return: 字典数据列表信息对象
|
||||
"""
|
||||
dict_data_list_result = DictDataDao.query_dict_data_list(query_db, dict_type)
|
||||
|
||||
return dict_data_list_result
|
||||
|
||||
@classmethod
|
||||
async def init_cache_sys_dict_services(cls, query_db: Session, redis):
|
||||
"""
|
||||
应用初始化：获取所有字典类型对应的字典数据信息并缓存service
|
||||
:param query_db: orm对象
|
||||
:param redis: redis对象
|
||||
:return:
|
||||
"""
|
||||
# 获取以sys_dict:开头的键列表
|
||||
keys = await redis.keys(f"{RedisInitKeyConfig.SYS_DICT.get('key')}:*")
|
||||
# 删除匹配的键
|
||||
if keys:
|
||||
await redis.delete(*keys)
|
||||
dict_type_all = DictTypeDao.get_all_dict_type(query_db)
|
||||
for dict_type_obj in [item for item in dict_type_all if item.status == '0']:
|
||||
dict_type = dict_type_obj.dict_type
|
||||
dict_data_list = 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}", json.dumps(dict_data, ensure_ascii=False, default=str))
|
||||
|
||||
@classmethod
|
||||
async def query_dict_data_list_from_cache_services(cls, redis, dict_type: str):
|
||||
"""
|
||||
从缓存获取字典数据列表信息service
|
||||
:param redis: redis对象
|
||||
:param dict_type: 字典类型
|
||||
:return: 字典数据列表信息对象
|
||||
"""
|
||||
result = []
|
||||
dict_data_list_result = await redis.get(f"{RedisInitKeyConfig.SYS_DICT.get('key')}:{dict_type}")
|
||||
if dict_data_list_result:
|
||||
result = json.loads(dict_data_list_result)
|
||||
|
||||
return CamelCaseUtil.transform_result(result)
|
||||
|
||||
@classmethod
|
||||
async def add_dict_data_services(cls, request: Request, query_db: Session, page_object: DictDataModel):
|
||||
"""
|
||||
新增字典数据信息service
|
||||
:param request: Request对象
|
||||
:param query_db: orm对象
|
||||
:param page_object: 新增岗位对象
|
||||
:return: 新增字典数据校验结果
|
||||
"""
|
||||
dict_data = DictDataDao.get_dict_data_detail_by_info(query_db, page_object)
|
||||
if dict_data:
|
||||
result = dict(is_success=False, message='字典数据已存在')
|
||||
else:
|
||||
try:
|
||||
DictDataDao.add_dict_data_dao(query_db, page_object)
|
||||
query_db.commit()
|
||||
await cls.init_cache_sys_dict_services(query_db, request.app.state.redis)
|
||||
result = dict(is_success=True, message='新增成功')
|
||||
except Exception as e:
|
||||
query_db.rollback()
|
||||
raise e
|
||||
|
||||
return CrudResponseModel(**result)
|
||||
|
||||
@classmethod
|
||||
async def edit_dict_data_services(cls, request: Request, query_db: Session, page_object: DictDataModel):
|
||||
"""
|
||||
编辑字典数据信息service
|
||||
:param request: Request对象
|
||||
:param query_db: orm对象
|
||||
:param page_object: 编辑字典数据对象
|
||||
:return: 编辑字典数据校验结果
|
||||
"""
|
||||
edit_data_type = page_object.model_dump(exclude_unset=True)
|
||||
dict_data_info = cls.dict_data_detail_services(query_db, edit_data_type.get('dict_code'))
|
||||
if dict_data_info:
|
||||
if dict_data_info.dict_type != page_object.dict_type or dict_data_info.dict_label != page_object.dict_label or dict_data_info.dict_value != page_object.dict_value:
|
||||
dict_data = DictDataDao.get_dict_data_detail_by_info(query_db, page_object)
|
||||
if dict_data:
|
||||
result = dict(is_success=False, message='字典数据已存在')
|
||||
return CrudResponseModel(**result)
|
||||
try:
|
||||
DictDataDao.edit_dict_data_dao(query_db, edit_data_type)
|
||||
query_db.commit()
|
||||
await cls.init_cache_sys_dict_services(query_db, request.app.state.redis)
|
||||
result = dict(is_success=True, message='更新成功')
|
||||
except Exception as e:
|
||||
query_db.rollback()
|
||||
raise e
|
||||
else:
|
||||
result = dict(is_success=False, message='字典数据不存在')
|
||||
|
||||
return CrudResponseModel(**result)
|
||||
|
||||
@classmethod
|
||||
async def delete_dict_data_services(cls, request: Request, query_db: Session, page_object: DeleteDictDataModel):
|
||||
"""
|
||||
删除字典数据信息service
|
||||
:param request: Request对象
|
||||
:param query_db: orm对象
|
||||
:param page_object: 删除字典数据对象
|
||||
:return: 删除字典数据校验结果
|
||||
"""
|
||||
if page_object.dict_codes.split(','):
|
||||
dict_code_list = page_object.dict_codes.split(',')
|
||||
try:
|
||||
for dict_code in dict_code_list:
|
||||
DictDataDao.delete_dict_data_dao(query_db, DictDataModel(dictCode=dict_code))
|
||||
query_db.commit()
|
||||
await cls.init_cache_sys_dict_services(query_db, request.app.state.redis)
|
||||
result = dict(is_success=True, message='删除成功')
|
||||
except Exception as e:
|
||||
query_db.rollback()
|
||||
raise e
|
||||
else:
|
||||
result = dict(is_success=False, message='传入字典数据id为空')
|
||||
return CrudResponseModel(**result)
|
||||
|
||||
@classmethod
|
||||
def dict_data_detail_services(cls, query_db: Session, dict_code: int):
|
||||
"""
|
||||
获取字典数据详细信息service
|
||||
:param query_db: orm对象
|
||||
:param dict_code: 字典数据id
|
||||
:return: 字典数据id对应的信息
|
||||
"""
|
||||
dict_data = DictDataDao.get_dict_data_detail_by_id(query_db, dict_code=dict_code)
|
||||
result = DictDataModel(**CamelCaseUtil.transform_result(dict_data))
|
||||
|
||||
return result
|
||||
|
||||
@staticmethod
|
||||
def export_dict_data_list_services(dict_data_list: List):
|
||||
"""
|
||||
导出字典数据信息service
|
||||
:param dict_data_list: 字典数据信息列表
|
||||
:return: 字典数据信息对应excel的二进制数据
|
||||
"""
|
||||
# 创建一个映射字典，将英文键映射到中文键
|
||||
mapping_dict = {
|
||||
"dictCode": "字典编码",
|
||||
"dictSort": "字典标签",
|
||||
"dictLabel": "字典键值",
|
||||
"dictValue": "字典排序",
|
||||
"dictType": "字典类型",
|
||||
"cssClass": "样式属性",
|
||||
"listClass": "表格回显样式",
|
||||
"isDefault": "是否默认",
|
||||
"status": "状态",
|
||||
"createBy": "创建者",
|
||||
"createTime": "创建时间",
|
||||
"updateBy": "更新者",
|
||||
"updateTime": "更新时间",
|
||||
"remark": "备注",
|
||||
}
|
||||
|
||||
data = dict_data_list
|
||||
|
||||
for item in data:
|
||||
if item.get('status') == '0':
|
||||
item['status'] = '正常'
|
||||
else:
|
||||
item['status'] = '停用'
|
||||
if item.get('isDefault') == 'Y':
|
||||
item['isDefault'] = '是'
|
||||
else:
|
||||
item['isDefault'] = '否'
|
||||
new_data = [{mapping_dict.get(key): value for key, value in item.items() if mapping_dict.get(key)} for item in data]
|
||||
binary_data = export_list2excel(new_data)
|
||||
|
||||
return binary_data
|
||||
121
ruoyi-fastapi-backend/module_admin/service/job_log_service.py
Normal file
121
ruoyi-fastapi-backend/module_admin/service/job_log_service.py
Normal file
@@ -0,0 +1,121 @@
|
||||
from module_admin.dao.job_log_dao import *
|
||||
from module_admin.dao.dict_dao import DictDataDao
|
||||
from module_admin.entity.vo.common_vo import CrudResponseModel
|
||||
from utils.common_util import export_list2excel, CamelCaseUtil
|
||||
|
||||
|
||||
class JobLogService:
|
||||
"""
|
||||
定时任务日志管理模块服务层
|
||||
"""
|
||||
|
||||
@classmethod
|
||||
def get_job_log_list_services(cls, query_db: Session, query_object: JobLogQueryModel):
|
||||
"""
|
||||
获取定时任务日志列表信息service
|
||||
:param query_db: orm对象
|
||||
:param query_object: 查询参数对象
|
||||
:return: 定时任务日志列表信息对象
|
||||
"""
|
||||
job_log_list_result = JobLogDao.get_job_log_list(query_db, query_object)
|
||||
|
||||
return CamelCaseUtil.transform_result(job_log_list_result)
|
||||
|
||||
@classmethod
|
||||
def add_job_log_services(cls, query_db: Session, page_object: JobLogModel):
|
||||
"""
|
||||
新增定时任务日志信息service
|
||||
:param query_db: orm对象
|
||||
:param page_object: 新增定时任务日志对象
|
||||
:return: 新增定时任务日志校验结果
|
||||
"""
|
||||
try:
|
||||
JobLogDao.add_job_log_dao(query_db, page_object)
|
||||
query_db.commit()
|
||||
result = dict(is_success=True, message='新增成功')
|
||||
except Exception as e:
|
||||
query_db.rollback()
|
||||
result = dict(is_success=False, message=str(e))
|
||||
|
||||
return CrudResponseModel(**result)
|
||||
|
||||
@classmethod
|
||||
def delete_job_log_services(cls, query_db: Session, page_object: DeleteJobLogModel):
|
||||
"""
|
||||
删除定时任务日志信息service
|
||||
:param query_db: orm对象
|
||||
:param page_object: 删除定时任务日志对象
|
||||
:return: 删除定时任务日志校验结果
|
||||
"""
|
||||
if page_object.job_log_ids.split(','):
|
||||
job_log_id_list = page_object.job_log_ids.split(',')
|
||||
try:
|
||||
for job_log_id in job_log_id_list:
|
||||
JobLogDao.delete_job_log_dao(query_db, JobLogModel(jobLogId=job_log_id))
|
||||
query_db.commit()
|
||||
result = dict(is_success=True, message='删除成功')
|
||||
except Exception as e:
|
||||
query_db.rollback()
|
||||
raise e
|
||||
else:
|
||||
result = dict(is_success=False, message='传入定时任务日志id为空')
|
||||
return CrudResponseModel(**result)
|
||||
|
||||
@classmethod
|
||||
def clear_job_log_services(cls, query_db: Session):
|
||||
"""
|
||||
清除定时任务日志信息service
|
||||
:param query_db: orm对象
|
||||
:return: 清除定时任务日志校验结果
|
||||
"""
|
||||
try:
|
||||
JobLogDao.clear_job_log_dao(query_db)
|
||||
query_db.commit()
|
||||
result = dict(is_success=True, message='清除成功')
|
||||
except Exception as e:
|
||||
query_db.rollback()
|
||||
raise e
|
||||
|
||||
return CrudResponseModel(**result)
|
||||
|
||||
@staticmethod
|
||||
def export_job_log_list_services(query_db, job_log_list: List):
|
||||
"""
|
||||
导出定时任务日志信息service
|
||||
:param query_db: orm对象
|
||||
:param job_log_list: 定时任务日志信息列表
|
||||
:return: 定时任务日志信息对应excel的二进制数据
|
||||
"""
|
||||
# 创建一个映射字典，将英文键映射到中文键
|
||||
mapping_dict = {
|
||||
"jobLogId": "任务日志编码",
|
||||
"jobName": "任务名称",
|
||||
"jobGroup": "任务组名",
|
||||
"jobExecutor": "任务执行器",
|
||||
"invokeTarget": "调用目标字符串",
|
||||
"jobArgs": "位置参数",
|
||||
"jobKwargs": "关键字参数",
|
||||
"jobTrigger": "任务触发器",
|
||||
"jobMessage": "日志信息",
|
||||
"status": "执行状态",
|
||||
"exceptionInfo": "异常信息",
|
||||
"createTime": "创建时间",
|
||||
}
|
||||
|
||||
data = job_log_list
|
||||
job_group_list = DictDataDao.query_dict_data_list(query_db, dict_type='sys_job_group')
|
||||
job_group_option = [dict(label=item.dict_label, value=item.dict_value) for item in job_group_list]
|
||||
job_group_option_dict = {item.get('value'): item for item in job_group_option}
|
||||
|
||||
for item in data:
|
||||
if item.get('status') == '0':
|
||||
item['status'] = '正常'
|
||||
else:
|
||||
item['status'] = '暂停'
|
||||
if str(item.get('job_group')) in job_group_option_dict.keys():
|
||||
item['job_group'] = job_group_option_dict.get(str(item.get('job_group'))).get('label')
|
||||
new_data = [{mapping_dict.get(key): value for key, value in item.items() if mapping_dict.get(key)} for item in
|
||||
data]
|
||||
binary_data = export_list2excel(new_data)
|
||||
|
||||
return binary_data
|
||||
198
ruoyi-fastapi-backend/module_admin/service/job_service.py
Normal file
198
ruoyi-fastapi-backend/module_admin/service/job_service.py
Normal file
@@ -0,0 +1,198 @@
|
||||
from module_admin.dao.job_dao import *
|
||||
from module_admin.service.dict_service import Request, DictDataService
|
||||
from module_admin.entity.vo.common_vo import CrudResponseModel
|
||||
from utils.common_util import export_list2excel, CamelCaseUtil
|
||||
from config.get_scheduler import SchedulerUtil
|
||||
|
||||
|
||||
class JobService:
|
||||
"""
|
||||
定时任务管理模块服务层
|
||||
"""
|
||||
|
||||
@classmethod
|
||||
def get_job_list_services(cls, query_db: Session, query_object: JobModel):
|
||||
"""
|
||||
获取定时任务列表信息service
|
||||
:param query_db: orm对象
|
||||
:param query_object: 查询参数对象
|
||||
:return: 定时任务列表信息对象
|
||||
"""
|
||||
job_list_result = JobDao.get_job_list(query_db, query_object)
|
||||
|
||||
return CamelCaseUtil.transform_result(job_list_result)
|
||||
|
||||
@classmethod
|
||||
def add_job_services(cls, query_db: Session, page_object: JobModel):
|
||||
"""
|
||||
新增定时任务信息service
|
||||
:param query_db: orm对象
|
||||
:param page_object: 新增定时任务对象
|
||||
:return: 新增定时任务校验结果
|
||||
"""
|
||||
job = JobDao.get_job_detail_by_info(query_db, page_object)
|
||||
if job:
|
||||
result = dict(is_success=False, message='定时任务已存在')
|
||||
else:
|
||||
try:
|
||||
JobDao.add_job_dao(query_db, page_object)
|
||||
job_info = JobDao.get_job_detail_by_info(query_db, page_object)
|
||||
if job_info.status == '0':
|
||||
SchedulerUtil.add_scheduler_job(job_info=job_info)
|
||||
query_db.commit()
|
||||
result = dict(is_success=True, message='新增成功')
|
||||
except Exception as e:
|
||||
query_db.rollback()
|
||||
raise e
|
||||
|
||||
return CrudResponseModel(**result)
|
||||
|
||||
@classmethod
|
||||
def edit_job_services(cls, query_db: Session, page_object: EditJobModel):
|
||||
"""
|
||||
编辑定时任务信息service
|
||||
:param query_db: orm对象
|
||||
:param page_object: 编辑定时任务对象
|
||||
:return: 编辑定时任务校验结果
|
||||
"""
|
||||
edit_job = page_object.model_dump(exclude_unset=True)
|
||||
if page_object.type == 'status':
|
||||
del edit_job['type']
|
||||
job_info = cls.job_detail_services(query_db, edit_job.get('job_id'))
|
||||
if job_info:
|
||||
if page_object.type != 'status' and (job_info.job_name != page_object.job_name or job_info.job_group != page_object.job_group or job_info.invoke_target != page_object.invoke_target or job_info.cron_expression != page_object.cron_expression):
|
||||
job = JobDao.get_job_detail_by_info(query_db, page_object)
|
||||
if job:
|
||||
result = dict(is_success=False, message='定时任务已存在')
|
||||
return CrudResponseModel(**result)
|
||||
try:
|
||||
JobDao.edit_job_dao(query_db, edit_job)
|
||||
query_job = SchedulerUtil.get_scheduler_job(job_id=edit_job.get('job_id'))
|
||||
if query_job:
|
||||
SchedulerUtil.remove_scheduler_job(job_id=edit_job.get('job_id'))
|
||||
if edit_job.get('status') == '0':
|
||||
SchedulerUtil.add_scheduler_job(job_info=job_info)
|
||||
query_db.commit()
|
||||
result = dict(is_success=True, message='更新成功')
|
||||
except Exception as e:
|
||||
query_db.rollback()
|
||||
raise e
|
||||
else:
|
||||
result = dict(is_success=False, message='定时任务不存在')
|
||||
|
||||
return CrudResponseModel(**result)
|
||||
|
||||
@classmethod
|
||||
def execute_job_once_services(cls, query_db: Session, page_object: JobModel):
|
||||
"""
|
||||
执行一次定时任务service
|
||||
:param query_db: orm对象
|
||||
:param page_object: 定时任务对象
|
||||
:return: 执行一次定时任务结果
|
||||
"""
|
||||
query_job = SchedulerUtil.get_scheduler_job(job_id=page_object.job_id)
|
||||
if query_job:
|
||||
SchedulerUtil.remove_scheduler_job(job_id=page_object.job_id)
|
||||
job_info = cls.job_detail_services(query_db, page_object.job_id)
|
||||
if job_info:
|
||||
SchedulerUtil.execute_scheduler_job_once(job_info=job_info)
|
||||
result = dict(is_success=True, message='执行成功')
|
||||
else:
|
||||
result = dict(is_success=False, message='定时任务不存在')
|
||||
|
||||
return CrudResponseModel(**result)
|
||||
|
||||
@classmethod
|
||||
def delete_job_services(cls, query_db: Session, page_object: DeleteJobModel):
|
||||
"""
|
||||
删除定时任务信息service
|
||||
:param query_db: orm对象
|
||||
:param page_object: 删除定时任务对象
|
||||
:return: 删除定时任务校验结果
|
||||
"""
|
||||
if page_object.job_ids.split(','):
|
||||
job_id_list = page_object.job_ids.split(',')
|
||||
try:
|
||||
for job_id in job_id_list:
|
||||
JobDao.delete_job_dao(query_db, JobModel(jobId=job_id))
|
||||
query_db.commit()
|
||||
result = dict(is_success=True, message='删除成功')
|
||||
except Exception as e:
|
||||
query_db.rollback()
|
||||
raise e
|
||||
else:
|
||||
result = dict(is_success=False, message='传入定时任务id为空')
|
||||
return CrudResponseModel(**result)
|
||||
|
||||
@classmethod
|
||||
def job_detail_services(cls, query_db: Session, job_id: int):
|
||||
"""
|
||||
获取定时任务详细信息service
|
||||
:param query_db: orm对象
|
||||
:param job_id: 定时任务id
|
||||
:return: 定时任务id对应的信息
|
||||
"""
|
||||
job = JobDao.get_job_detail_by_id(query_db, job_id=job_id)
|
||||
result = JobModel(**CamelCaseUtil.transform_result(job))
|
||||
|
||||
return result
|
||||
|
||||
@staticmethod
|
||||
async def export_job_list_services(request: Request, job_list: List):
|
||||
"""
|
||||
导出定时任务信息service
|
||||
:param request: Request对象
|
||||
:param job_list: 定时任务信息列表
|
||||
:return: 定时任务信息对应excel的二进制数据
|
||||
"""
|
||||
# 创建一个映射字典，将英文键映射到中文键
|
||||
mapping_dict = {
|
||||
"jobId": "任务编码",
|
||||
"jobName": "任务名称",
|
||||
"jobGroup": "任务组名",
|
||||
"jobExecutor": "任务执行器",
|
||||
"invokeTarget": "调用目标字符串",
|
||||
"jobArgs": "位置参数",
|
||||
"jobKwargs": "关键字参数",
|
||||
"cronExpression": "cron执行表达式",
|
||||
"misfirePolicy": "计划执行错误策略",
|
||||
"concurrent": "是否并发执行",
|
||||
"status": "状态",
|
||||
"createBy": "创建者",
|
||||
"createTime": "创建时间",
|
||||
"updateBy": "更新者",
|
||||
"updateTime": "更新时间",
|
||||
"remark": "备注",
|
||||
}
|
||||
|
||||
data = job_list
|
||||
job_group_list = await DictDataService.query_dict_data_list_from_cache_services(request.app.state.redis, dict_type='sys_job_group')
|
||||
job_group_option = [dict(label=item.get('dictLabel'), value=item.get('dictValue')) for item in job_group_list]
|
||||
job_group_option_dict = {item.get('value'): item for item in job_group_option}
|
||||
job_executor_list = await DictDataService.query_dict_data_list_from_cache_services(request.app.state.redis, dict_type='sys_job_executor')
|
||||
job_executor_option = [dict(label=item.get('dictLabel'), value=item.get('dictValue')) for item in job_executor_list]
|
||||
job_executor_option_dict = {item.get('value'): item for item in job_executor_option}
|
||||
|
||||
for item in data:
|
||||
if item.get('status') == '0':
|
||||
item['status'] = '正常'
|
||||
else:
|
||||
item['status'] = '暂停'
|
||||
if str(item.get('jobGroup')) in job_group_option_dict.keys():
|
||||
item['jobGroup'] = job_group_option_dict.get(str(item.get('jobGroup'))).get('label')
|
||||
if str(item.get('jobExecutor')) in job_executor_option_dict.keys():
|
||||
item['jobExecutor'] = job_executor_option_dict.get(str(item.get('jobExecutor'))).get('label')
|
||||
if item.get('misfirePolicy') == '1':
|
||||
item['misfirePolicy'] = '立即执行'
|
||||
elif item.get('misfirePolicy') == '2':
|
||||
item['misfirePolicy'] = '执行一次'
|
||||
else:
|
||||
item['misfirePolicy'] = '放弃执行'
|
||||
if item.get('concurrent') == '0':
|
||||
item['concurrent'] = '允许'
|
||||
else:
|
||||
item['concurrent'] = '禁止'
|
||||
new_data = [{mapping_dict.get(key): value for key, value in item.items() if mapping_dict.get(key)} for item in data]
|
||||
binary_data = export_list2excel(new_data)
|
||||
|
||||
return binary_data
|
||||
242
ruoyi-fastapi-backend/module_admin/service/log_service.py
Normal file
242
ruoyi-fastapi-backend/module_admin/service/log_service.py
Normal file
@@ -0,0 +1,242 @@
|
||||
from module_admin.dao.log_dao import *
|
||||
from module_admin.service.dict_service import Request, DictDataService
|
||||
from module_admin.entity.vo.common_vo import CrudResponseModel
|
||||
from utils.common_util import export_list2excel, CamelCaseUtil
|
||||
|
||||
|
||||
class OperationLogService:
|
||||
"""
|
||||
操作日志管理模块服务层
|
||||
"""
|
||||
|
||||
@classmethod
|
||||
def get_operation_log_list_services(cls, query_db: Session, query_object: OperLogQueryModel):
|
||||
"""
|
||||
获取操作日志列表信息service
|
||||
:param query_db: orm对象
|
||||
:param query_object: 查询参数对象
|
||||
:return: 操作日志列表信息对象
|
||||
"""
|
||||
operation_log_list_result = OperationLogDao.get_operation_log_list(query_db, query_object)
|
||||
|
||||
return CamelCaseUtil.transform_result(operation_log_list_result)
|
||||
|
||||
@classmethod
|
||||
def add_operation_log_services(cls, query_db: Session, page_object: OperLogModel):
|
||||
"""
|
||||
新增操作日志service
|
||||
:param query_db: orm对象
|
||||
:param page_object: 新增操作日志对象
|
||||
:return: 新增操作日志校验结果
|
||||
"""
|
||||
try:
|
||||
OperationLogDao.add_operation_log_dao(query_db, page_object)
|
||||
query_db.commit()
|
||||
result = dict(is_success=True, message='新增成功')
|
||||
except Exception as e:
|
||||
query_db.rollback()
|
||||
result = dict(is_success=False, message=str(e))
|
||||
|
||||
return CrudResponseModel(**result)
|
||||
|
||||
@classmethod
|
||||
def delete_operation_log_services(cls, query_db: Session, page_object: DeleteOperLogModel):
|
||||
"""
|
||||
删除操作日志信息service
|
||||
:param query_db: orm对象
|
||||
:param page_object: 删除操作日志对象
|
||||
:return: 删除操作日志校验结果
|
||||
"""
|
||||
if page_object.oper_ids.split(','):
|
||||
oper_id_list = page_object.oper_ids.split(',')
|
||||
try:
|
||||
for oper_id in oper_id_list:
|
||||
OperationLogDao.delete_operation_log_dao(query_db, OperLogModel(operId=oper_id))
|
||||
query_db.commit()
|
||||
result = dict(is_success=True, message='删除成功')
|
||||
except Exception as e:
|
||||
query_db.rollback()
|
||||
raise e
|
||||
else:
|
||||
result = dict(is_success=False, message='传入操作日志id为空')
|
||||
return CrudResponseModel(**result)
|
||||
|
||||
@classmethod
|
||||
def clear_operation_log_services(cls, query_db: Session):
|
||||
"""
|
||||
清除操作日志信息service
|
||||
:param query_db: orm对象
|
||||
:return: 清除操作日志校验结果
|
||||
"""
|
||||
try:
|
||||
OperationLogDao.clear_operation_log_dao(query_db)
|
||||
query_db.commit()
|
||||
result = dict(is_success=True, message='清除成功')
|
||||
except Exception as e:
|
||||
query_db.rollback()
|
||||
raise e
|
||||
|
||||
return CrudResponseModel(**result)
|
||||
|
||||
@classmethod
|
||||
async def export_operation_log_list_services(cls, request: Request, operation_log_list: List):
|
||||
"""
|
||||
导出操作日志信息service
|
||||
:param request: Request对象
|
||||
:param operation_log_list: 操作日志信息列表
|
||||
:return: 操作日志信息对应excel的二进制数据
|
||||
"""
|
||||
# 创建一个映射字典，将英文键映射到中文键
|
||||
mapping_dict = {
|
||||
"operId": "日志编号",
|
||||
"title": "系统模块",
|
||||
"businessType": "操作类型",
|
||||
"method": "方法名称",
|
||||
"requestMethod": "请求方式",
|
||||
"operName": "操作人员",
|
||||
"deptName": "部门名称",
|
||||
"operUrl": "请求URL",
|
||||
"operIp": "操作地址",
|
||||
"operLocation": "操作地点",
|
||||
"operParam": "请求参数",
|
||||
"jsonResult": "返回参数",
|
||||
"status": "操作状态",
|
||||
"error_msg": "错误消息",
|
||||
"operTime": "操作日期",
|
||||
"costTime": "消耗时间（毫秒）"
|
||||
}
|
||||
|
||||
data = operation_log_list
|
||||
operation_type_list = await DictDataService.query_dict_data_list_from_cache_services(request.app.state.redis, dict_type='sys_oper_type')
|
||||
operation_type_option = [dict(label=item.get('dictLabel'), value=item.get('dictValue')) for item in operation_type_list]
|
||||
operation_type_option_dict = {item.get('value'): item for item in operation_type_option}
|
||||
|
||||
for item in data:
|
||||
if item.get('status') == 0:
|
||||
item['status'] = '成功'
|
||||
else:
|
||||
item['status'] = '失败'
|
||||
if str(item.get('businessType')) in operation_type_option_dict.keys():
|
||||
item['businessType'] = operation_type_option_dict.get(str(item.get('businessType'))).get('label')
|
||||
|
||||
new_data = [{mapping_dict.get(key): value for key, value in item.items() if mapping_dict.get(key)} for item in data]
|
||||
binary_data = export_list2excel(new_data)
|
||||
|
||||
return binary_data
|
||||
|
||||
|
||||
class LoginLogService:
|
||||
"""
|
||||
登录日志管理模块服务层
|
||||
"""
|
||||
|
||||
@classmethod
|
||||
def get_login_log_list_services(cls, query_db: Session, query_object: LoginLogQueryModel):
|
||||
"""
|
||||
获取登录日志列表信息service
|
||||
:param query_db: orm对象
|
||||
:param query_object: 查询参数对象
|
||||
:return: 登录日志列表信息对象
|
||||
"""
|
||||
operation_log_list_result = LoginLogDao.get_login_log_list(query_db, query_object)
|
||||
|
||||
return CamelCaseUtil.transform_result(operation_log_list_result)
|
||||
|
||||
@classmethod
|
||||
def add_login_log_services(cls, query_db: Session, page_object: LogininforModel):
|
||||
"""
|
||||
新增登录日志service
|
||||
:param query_db: orm对象
|
||||
:param page_object: 新增登录日志对象
|
||||
:return: 新增登录日志校验结果
|
||||
"""
|
||||
try:
|
||||
LoginLogDao.add_login_log_dao(query_db, page_object)
|
||||
query_db.commit()
|
||||
result = dict(is_success=True, message='新增成功')
|
||||
except Exception as e:
|
||||
query_db.rollback()
|
||||
result = dict(is_success=False, message=str(e))
|
||||
|
||||
return CrudResponseModel(**result)
|
||||
|
||||
@classmethod
|
||||
def delete_login_log_services(cls, query_db: Session, page_object: DeleteLoginLogModel):
|
||||
"""
|
||||
删除操作日志信息service
|
||||
:param query_db: orm对象
|
||||
:param page_object: 删除操作日志对象
|
||||
:return: 删除操作日志校验结果
|
||||
"""
|
||||
if page_object.info_ids.split(','):
|
||||
info_id_list = page_object.info_ids.split(',')
|
||||
try:
|
||||
for info_id in info_id_list:
|
||||
LoginLogDao.delete_login_log_dao(query_db, LogininforModel(infoId=info_id))
|
||||
query_db.commit()
|
||||
result = dict(is_success=True, message='删除成功')
|
||||
except Exception as e:
|
||||
query_db.rollback()
|
||||
raise e
|
||||
else:
|
||||
result = dict(is_success=False, message='传入登录日志id为空')
|
||||
return CrudResponseModel(**result)
|
||||
|
||||
@classmethod
|
||||
def clear_login_log_services(cls, query_db: Session):
|
||||
"""
|
||||
清除操作日志信息service
|
||||
:param query_db: orm对象
|
||||
:return: 清除操作日志校验结果
|
||||
"""
|
||||
try:
|
||||
LoginLogDao.clear_login_log_dao(query_db)
|
||||
query_db.commit()
|
||||
result = dict(is_success=True, message='清除成功')
|
||||
except Exception as e:
|
||||
query_db.rollback()
|
||||
raise e
|
||||
|
||||
return CrudResponseModel(**result)
|
||||
|
||||
@classmethod
|
||||
async def unlock_user_services(cls, request: Request, unlock_user: UnlockUser):
|
||||
locked_user = await request.app.state.redis.get(f"account_lock:{unlock_user.user_name}")
|
||||
if locked_user:
|
||||
await request.app.state.redis.delete(f"account_lock:{unlock_user.user_name}")
|
||||
result = dict(is_success=True, message='解锁成功')
|
||||
else:
|
||||
result = dict(is_success=False, message='该用户未锁定')
|
||||
return CrudResponseModel(**result)
|
||||
|
||||
@staticmethod
|
||||
def export_login_log_list_services(login_log_list: List):
|
||||
"""
|
||||
导出登录日志信息service
|
||||
:param login_log_list: 登录日志信息列表
|
||||
:return: 登录日志信息对应excel的二进制数据
|
||||
"""
|
||||
# 创建一个映射字典，将英文键映射到中文键
|
||||
mapping_dict = {
|
||||
"infoId": "访问编号",
|
||||
"userName": "用户名称",
|
||||
"ipaddr": "登录地址",
|
||||
"loginLocation": "登录地点",
|
||||
"browser": "浏览器",
|
||||
"os": "操作系统",
|
||||
"status": "登录状态",
|
||||
"msg": "操作信息",
|
||||
"loginTime": "登录日期"
|
||||
}
|
||||
|
||||
data = login_log_list
|
||||
|
||||
for item in data:
|
||||
if item.get('status') == '0':
|
||||
item['status'] = '成功'
|
||||
else:
|
||||
item['status'] = '失败'
|
||||
new_data = [{mapping_dict.get(key): value for key, value in item.items() if mapping_dict.get(key)} for item in data]
|
||||
binary_data = export_list2excel(new_data)
|
||||
|
||||
return binary_data
|
||||
316
ruoyi-fastapi-backend/module_admin/service/login_service.py
Normal file
316
ruoyi-fastapi-backend/module_admin/service/login_service.py
Normal file
@@ -0,0 +1,316 @@
|
||||
from fastapi import Request, Form
|
||||
from fastapi import Depends
|
||||
from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
|
||||
from jose import JWTError, jwt
|
||||
import random
|
||||
import uuid
|
||||
from datetime import timedelta
|
||||
from module_admin.service.user_service import *
|
||||
from module_admin.entity.vo.login_vo import *
|
||||
from module_admin.entity.vo.common_vo import CrudResponseModel
|
||||
from module_admin.dao.login_dao import *
|
||||
from config.env import JwtConfig, RedisInitKeyConfig
|
||||
from utils.common_util import CamelCaseUtil
|
||||
from utils.pwd_util import *
|
||||
from utils.response_util import *
|
||||
from utils.message_util import *
|
||||
from config.get_db import get_db
|
||||
|
||||
oauth2_scheme = OAuth2PasswordBearer(tokenUrl="login")
|
||||
|
||||
|
||||
class CustomOAuth2PasswordRequestForm(OAuth2PasswordRequestForm):
|
||||
"""
|
||||
自定义OAuth2PasswordRequestForm类，增加验证码及会话编号参数
|
||||
"""
|
||||
def __init__(
|
||||
self,
|
||||
grant_type: str = Form(default=None, regex="password"),
|
||||
username: str = Form(),
|
||||
password: str = Form(),
|
||||
scope: str = Form(default=""),
|
||||
client_id: Optional[str] = Form(default=None),
|
||||
client_secret: Optional[str] = Form(default=None),
|
||||
code: Optional[str] = Form(default=""),
|
||||
uuid: Optional[str] = Form(default=""),
|
||||
login_info: Optional[Dict[str, str]] = Form(default=None)
|
||||
):
|
||||
super().__init__(grant_type=grant_type, username=username, password=password,
|
||||
scope=scope, client_id=client_id, client_secret=client_secret)
|
||||
self.code = code
|
||||
self.uuid = uuid
|
||||
self.login_info = login_info
|
||||
|
||||
|
||||
class LoginService:
|
||||
"""
|
||||
登录模块服务层
|
||||
"""
|
||||
@classmethod
|
||||
async def authenticate_user(cls, request: Request, query_db: Session, login_user: UserLogin):
|
||||
"""
|
||||
根据用户名密码校验用户登录
|
||||
:param request: Request对象
|
||||
:param query_db: orm对象
|
||||
:param login_user: 登录用户对象
|
||||
:return: 校验结果
|
||||
"""
|
||||
account_lock = await request.app.state.redis.get(
|
||||
f"{RedisInitKeyConfig.ACCOUNT_LOCK.get('key')}:{login_user.user_name}")
|
||||
if login_user.user_name == account_lock:
|
||||
logger.warning("账号已锁定，请稍后再试")
|
||||
raise LoginException(data="", message="账号已锁定，请稍后再试")
|
||||
# 判断是否开启验证码，开启则验证，否则不验证
|
||||
if login_user.captcha_enabled:
|
||||
await cls.__check_login_captcha(request, login_user)
|
||||
user = login_by_account(query_db, login_user.user_name)
|
||||
if not user:
|
||||
logger.warning("用户不存在")
|
||||
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}")
|
||||
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}", 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}")
|
||||
await request.app.state.redis.set(
|
||||
f"{RedisInitKeyConfig.ACCOUNT_LOCK.get('key')}:{login_user.user_name}", login_user.user_name,
|
||||
ex=timedelta(minutes=10))
|
||||
logger.warning("10分钟内密码已输错超过5次，账号已锁定，请10分钟后再试")
|
||||
raise LoginException(data="", message="10分钟内密码已输错超过5次，账号已锁定，请10分钟后再试")
|
||||
logger.warning("密码错误")
|
||||
raise LoginException(data="", message="密码错误")
|
||||
if user[0].status == '1':
|
||||
logger.warning("用户已停用")
|
||||
raise LoginException(data="", message="用户已停用")
|
||||
await request.app.state.redis.delete(
|
||||
f"{RedisInitKeyConfig.PASSWORD_ERROR_COUNT.get('key')}:{login_user.user_name}")
|
||||
return user
|
||||
|
||||
@classmethod
|
||||
async def __check_login_captcha(cls, request: Request, login_user: UserLogin):
|
||||
"""
|
||||
校验用户登录验证码
|
||||
:param request: Request对象
|
||||
:param login_user: 登录用户对象
|
||||
:return: 校验结果
|
||||
"""
|
||||
captcha_value = await request.app.state.redis.get(
|
||||
f"{RedisInitKeyConfig.CAPTCHA_CODES.get('key')}:{login_user.uuid}")
|
||||
if not captcha_value:
|
||||
logger.warning("验证码已失效")
|
||||
raise LoginException(data="", message="验证码已失效")
|
||||
if login_user.code != str(captcha_value):
|
||||
logger.warning("验证码错误")
|
||||
raise LoginException(data="", message="验证码错误")
|
||||
return True
|
||||
|
||||
@classmethod
|
||||
def create_access_token(cls, data: dict, expires_delta: Union[timedelta, None] = None):
|
||||
"""
|
||||
根据登录信息创建当前用户token
|
||||
:param data: 登录信息
|
||||
:param expires_delta: token有效期
|
||||
:return: token
|
||||
"""
|
||||
to_encode = data.copy()
|
||||
if expires_delta:
|
||||
expire = datetime.utcnow() + expires_delta
|
||||
else:
|
||||
expire = datetime.utcnow() + timedelta(minutes=15)
|
||||
to_encode.update({"exp": expire})
|
||||
encoded_jwt = jwt.encode(to_encode, JwtConfig.SECRET_KEY, algorithm=JwtConfig.ALGORITHM)
|
||||
return encoded_jwt
|
||||
|
||||
@classmethod
|
||||
async def get_current_user(cls, request: Request = Request, token: str = Depends(oauth2_scheme),
|
||||
query_db: Session = Depends(get_db)):
|
||||
"""
|
||||
根据token获取当前用户信息
|
||||
:param request: Request对象
|
||||
:param token: 用户token
|
||||
:param query_db: orm对象
|
||||
:return: 当前用户信息对象
|
||||
:raise: 令牌异常AuthException
|
||||
"""
|
||||
# if token[:6] != 'Bearer':
|
||||
# logger.warning("用户token不合法")
|
||||
# raise AuthException(data="", message="用户token不合法")
|
||||
try:
|
||||
if token.startswith('Bearer'):
|
||||
token = token.split(' ')[1]
|
||||
payload = jwt.decode(token, JwtConfig.SECRET_KEY, algorithms=[JwtConfig.ALGORITHM])
|
||||
user_id: str = payload.get("user_id")
|
||||
session_id: str = payload.get("session_id")
|
||||
if user_id is None:
|
||||
logger.warning("用户token不合法")
|
||||
raise AuthException(data="", message="用户token不合法")
|
||||
token_data = TokenData(user_id=int(user_id))
|
||||
except JWTError:
|
||||
logger.warning("用户token已失效，请重新登录")
|
||||
raise AuthException(data="", message="用户token已失效，请重新登录")
|
||||
query_user = UserDao.get_user_by_id(query_db, user_id=token_data.user_id)
|
||||
if query_user.get('user_basic_info') is None:
|
||||
logger.warning("用户token不合法")
|
||||
raise AuthException(data="", message="用户token不合法")
|
||||
redis_token = await request.app.state.redis.get(f"{RedisInitKeyConfig.ACCESS_TOKEN.get('key')}:{session_id}")
|
||||
# 此方法可实现同一账号同一时间只能登录一次
|
||||
# redis_token = await request.app.state.redis.get(f"{RedisInitKeyConfig.ACCESS_TOKEN.get('key')}:{user.user_basic_info.user_id}")
|
||||
if token == redis_token:
|
||||
await request.app.state.redis.set(f"{RedisInitKeyConfig.ACCESS_TOKEN.get('key')}:{session_id}", redis_token,
|
||||
ex=timedelta(minutes=JwtConfig.REDIS_TOKEN_EXPIRE_MINUTES))
|
||||
# await request.app.state.redis.set(f"{RedisInitKeyConfig.ACCESS_TOKEN.get('key')}:{user.user_basic_info.user_id}", redis_token,
|
||||
# ex=timedelta(minutes=JwtConfig.REDIS_TOKEN_EXPIRE_MINUTES))
|
||||
|
||||
role_id_list = [item.role_id for item in query_user.get('user_role_info')]
|
||||
if 1 in role_id_list:
|
||||
permissions = ['*:*:*']
|
||||
else:
|
||||
permissions = [row.perms for row in query_user.get('user_menu_info')]
|
||||
post_ids = ','.join([str(row.post_id) for row in query_user.get('user_post_info')])
|
||||
role_ids = ','.join([str(row.role_id) for row in query_user.get('user_role_info')])
|
||||
roles = [row.role_key for row in query_user.get('user_role_info')]
|
||||
|
||||
current_user = CurrentUserModel(
|
||||
permissions=permissions,
|
||||
roles=roles,
|
||||
user=UserInfoModel(
|
||||
**CamelCaseUtil.transform_result(query_user.get('user_basic_info')),
|
||||
postIds=post_ids,
|
||||
roleIds=role_ids,
|
||||
dept=CamelCaseUtil.transform_result(query_user.get('user_dept_info')),
|
||||
role=CamelCaseUtil.transform_result(query_user.get('user_role_info'))
|
||||
)
|
||||
)
|
||||
return current_user
|
||||
else:
|
||||
logger.warning("用户token已失效，请重新登录")
|
||||
raise AuthException(data="", message="用户token已失效，请重新登录")
|
||||
|
||||
@classmethod
|
||||
async def get_current_user_routers(cls, user_id: int, query_db: Session):
|
||||
"""
|
||||
根据用户id获取当前用户路由信息
|
||||
:param user_id: 用户id
|
||||
:param query_db: orm对象
|
||||
:return: 当前用户路由信息对象
|
||||
"""
|
||||
query_user = UserDao.get_user_by_id(query_db, user_id=user_id)
|
||||
user_router_menu = [row for row in query_user.get('user_menu_info') if row.menu_type in ['M', 'C']]
|
||||
user_router = cls.__generate_user_router_menu(0, user_router_menu)
|
||||
return user_router
|
||||
|
||||
@classmethod
|
||||
def __generate_user_router_menu(cls, pid: int, permission_list):
|
||||
"""
|
||||
工具方法：根据菜单信息生成路由信息树形嵌套数据
|
||||
:param pid: 菜单id
|
||||
:param permission_list: 菜单列表信息
|
||||
:return: 路由信息树形嵌套数据
|
||||
"""
|
||||
router_list = []
|
||||
for permission in permission_list:
|
||||
if permission.parent_id == pid:
|
||||
children = cls.__generate_user_router_menu(permission.menu_id, permission_list)
|
||||
router_list_data = {}
|
||||
if permission.menu_type == 'M':
|
||||
router_list_data['name'] = permission.path.capitalize()
|
||||
router_list_data['path'] = f'/{permission.path}'
|
||||
router_list_data['hidden'] = False if permission.visible == '0' else True
|
||||
if permission.is_frame == 1:
|
||||
router_list_data['redirect'] = 'noRedirect'
|
||||
if permission.parent_id == 0:
|
||||
router_list_data['component'] = 'Layout'
|
||||
else:
|
||||
router_list_data['component'] = 'ParentView'
|
||||
if children:
|
||||
router_list_data['alwaysShow'] = True
|
||||
router_list_data['children'] = children
|
||||
router_list_data['meta'] = {
|
||||
'title': permission.menu_name,
|
||||
'icon': permission.icon,
|
||||
'noCache': False if permission.is_cache == '0' else True,
|
||||
'link': permission.path if permission.is_frame == 0 else None
|
||||
}
|
||||
elif permission.menu_type == 'C':
|
||||
router_list_data['name'] = permission.path.capitalize()
|
||||
router_list_data['path'] = permission.path
|
||||
router_list_data['hidden'] = False if permission.visible == '0' else True
|
||||
router_list_data['component'] = permission.component
|
||||
router_list_data['meta'] = {
|
||||
'title': permission.menu_name,
|
||||
'icon': permission.icon,
|
||||
'noCache': False if permission.is_cache == '0' else True,
|
||||
'link': permission.path if permission.is_frame == 0 else None
|
||||
}
|
||||
router_list.append(router_list_data)
|
||||
|
||||
return router_list
|
||||
|
||||
|
||||
async def get_sms_code_services(request: Request, query_db: Session, user: ResetUserModel):
|
||||
"""
|
||||
获取短信验证码service
|
||||
:param request: Request对象
|
||||
:param query_db: orm对象
|
||||
:param user: 用户对象
|
||||
:return: 短信验证码对象
|
||||
"""
|
||||
redis_sms_result = await request.app.state.redis.get(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 = UserDao.get_user_by_name(query_db, user.user_name)
|
||||
if is_user:
|
||||
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))
|
||||
# 此处模拟调用短信服务
|
||||
message_service(sms_code)
|
||||
|
||||
return SmsCode(**dict(is_success=True, sms_code=sms_code, session_id=session_id, message='获取成功'))
|
||||
|
||||
return SmsCode(**dict(is_success=False, sms_code='', session_id='', message='用户不存在'))
|
||||
|
||||
|
||||
async def forget_user_services(request: Request, query_db: Session, forget_user: ResetUserModel):
|
||||
"""
|
||||
用户忘记密码services
|
||||
:param request: Request对象
|
||||
:param query_db: orm对象
|
||||
:param forget_user: 重置用户对象
|
||||
:return: 重置结果
|
||||
"""
|
||||
redis_sms_result = await request.app.state.redis.get(f"{RedisInitKeyConfig.SMS_CODE.get('key')}:{forget_user.session_id}")
|
||||
if forget_user.sms_code == redis_sms_result:
|
||||
forget_user.password = PwdUtil.get_password_hash(forget_user.password)
|
||||
forget_user.user_id = UserDao.get_user_by_name(query_db, forget_user.user_name).user_id
|
||||
edit_result = UserService.reset_user_services(query_db, forget_user)
|
||||
result = edit_result.dict()
|
||||
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}")
|
||||
result = dict(is_success=False, message='短信验证码不正确')
|
||||
|
||||
return CrudResponseModel(**result)
|
||||
|
||||
|
||||
async def logout_services(request: Request, session_id: str):
|
||||
"""
|
||||
退出登录services
|
||||
:param request: Request对象
|
||||
: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'{current_user.user.user_id}_access_token')
|
||||
# await request.app.state.redis.delete(f'{current_user.user.user_id}_session_id')
|
||||
|
||||
return True
|
||||
171
ruoyi-fastapi-backend/module_admin/service/menu_service.py
Normal file
171
ruoyi-fastapi-backend/module_admin/service/menu_service.py
Normal file
@@ -0,0 +1,171 @@
|
||||
from module_admin.entity.vo.user_vo import CurrentUserModel
|
||||
from module_admin.entity.vo.role_vo import RoleMenuQueryModel
|
||||
from module_admin.entity.vo.common_vo import CrudResponseModel
|
||||
from module_admin.dao.role_dao import RoleDao
|
||||
from module_admin.dao.menu_dao import *
|
||||
from utils.common_util import CamelCaseUtil
|
||||
|
||||
|
||||
class MenuService:
|
||||
"""
|
||||
菜单管理模块服务层
|
||||
"""
|
||||
|
||||
@classmethod
|
||||
def get_menu_tree_services(cls, query_db: Session, current_user: Optional[CurrentUserModel] = None):
|
||||
"""
|
||||
获取菜单树信息service
|
||||
:param query_db: orm对象
|
||||
:param current_user: 当前用户对象
|
||||
:return: 菜单树信息对象
|
||||
"""
|
||||
menu_list_result = MenuDao.get_menu_list_for_tree(query_db, current_user.user.user_id, current_user.user.role)
|
||||
menu_tree_result = cls.list_to_tree(menu_list_result)
|
||||
|
||||
return menu_tree_result
|
||||
|
||||
@classmethod
|
||||
def get_role_menu_tree_services(cls, query_db: Session, role_id: int, current_user: Optional[CurrentUserModel] = None):
|
||||
"""
|
||||
根据角色id获取菜单树信息service
|
||||
:param query_db: orm对象
|
||||
:param role_id: 角色id
|
||||
:param current_user: 当前用户对象
|
||||
:return: 当前角色id的菜单树信息对象
|
||||
"""
|
||||
menu_list_result = MenuDao.get_menu_list_for_tree(query_db, current_user.user.user_id, current_user.user.role)
|
||||
menu_tree_result = cls.list_to_tree(menu_list_result)
|
||||
role_menu_list = RoleDao.get_role_menu_dao(query_db, role_id)
|
||||
checked_keys = [row.menu_id for row in role_menu_list]
|
||||
result = RoleMenuQueryModel(
|
||||
menus=menu_tree_result,
|
||||
checkedKeys=checked_keys
|
||||
)
|
||||
|
||||
return result
|
||||
|
||||
@classmethod
|
||||
def get_menu_list_services(cls, query_db: Session, page_object: MenuQueryModel, current_user: Optional[CurrentUserModel] = None):
|
||||
"""
|
||||
获取菜单列表信息service
|
||||
:param query_db: orm对象
|
||||
:param page_object: 分页查询参数对象
|
||||
:param current_user: 当前用户对象
|
||||
:return: 菜单列表信息对象
|
||||
"""
|
||||
menu_list_result = MenuDao.get_menu_list(query_db, page_object, current_user.user.user_id, current_user.user.role)
|
||||
|
||||
return CamelCaseUtil.transform_result(menu_list_result)
|
||||
|
||||
@classmethod
|
||||
def add_menu_services(cls, query_db: Session, page_object: MenuModel):
|
||||
"""
|
||||
新增菜单信息service
|
||||
:param query_db: orm对象
|
||||
:param page_object: 新增菜单对象
|
||||
:return: 新增菜单校验结果
|
||||
"""
|
||||
menu = MenuDao.get_menu_detail_by_info(query_db, MenuModel(parentId=page_object.parent_id, menuName=page_object.menu_name, menuType=page_object.menu_type))
|
||||
if menu:
|
||||
result = dict(is_success=False, message='同一目录下不允许存在同名同类型的菜单')
|
||||
else:
|
||||
try:
|
||||
MenuDao.add_menu_dao(query_db, page_object)
|
||||
query_db.commit()
|
||||
result = dict(is_success=True, message='新增成功')
|
||||
except Exception as e:
|
||||
query_db.rollback()
|
||||
raise e
|
||||
|
||||
return CrudResponseModel(**result)
|
||||
|
||||
@classmethod
|
||||
def edit_menu_services(cls, query_db: Session, page_object: MenuModel):
|
||||
"""
|
||||
编辑菜单信息service
|
||||
:param query_db: orm对象
|
||||
:param page_object: 编辑部门对象
|
||||
:return: 编辑菜单校验结果
|
||||
"""
|
||||
edit_menu = page_object.model_dump(exclude_unset=True)
|
||||
menu_info = cls.menu_detail_services(query_db, edit_menu.get('menu_id'))
|
||||
if menu_info:
|
||||
if menu_info.parent_id != page_object.parent_id or menu_info.menu_name != page_object.menu_name or menu_info.menu_type != page_object.menu_type:
|
||||
menu = MenuDao.get_menu_detail_by_info(query_db, MenuModel(parentId=page_object.parent_id, menuName=page_object.menu_name, menuType=page_object.menu_type))
|
||||
if menu:
|
||||
result = dict(is_success=False, message='同一目录下不允许存在同名同类型的菜单')
|
||||
return CrudResponseModel(**result)
|
||||
try:
|
||||
MenuDao.edit_menu_dao(query_db, edit_menu)
|
||||
query_db.commit()
|
||||
result = dict(is_success=True, message='更新成功')
|
||||
except Exception as e:
|
||||
query_db.rollback()
|
||||
raise e
|
||||
else:
|
||||
result = dict(is_success=False, message='菜单不存在')
|
||||
|
||||
return CrudResponseModel(**result)
|
||||
|
||||
@classmethod
|
||||
def delete_menu_services(cls, query_db: Session, page_object: DeleteMenuModel):
|
||||
"""
|
||||
删除菜单信息service
|
||||
:param query_db: orm对象
|
||||
:param page_object: 删除菜单对象
|
||||
:return: 删除菜单校验结果
|
||||
"""
|
||||
if page_object.menu_ids.split(','):
|
||||
menu_id_list = page_object.menu_ids.split(',')
|
||||
try:
|
||||
for menu_id in menu_id_list:
|
||||
MenuDao.delete_menu_dao(query_db, MenuModel(menuId=menu_id))
|
||||
query_db.commit()
|
||||
result = dict(is_success=True, message='删除成功')
|
||||
except Exception as e:
|
||||
query_db.rollback()
|
||||
raise e
|
||||
else:
|
||||
result = dict(is_success=False, message='传入菜单id为空')
|
||||
return CrudResponseModel(**result)
|
||||
|
||||
@classmethod
|
||||
def menu_detail_services(cls, query_db: Session, menu_id: int):
|
||||
"""
|
||||
获取菜单详细信息service
|
||||
:param query_db: orm对象
|
||||
:param menu_id: 菜单id
|
||||
:return: 菜单id对应的信息
|
||||
"""
|
||||
menu = MenuDao.get_menu_detail_by_id(query_db, menu_id=menu_id)
|
||||
result = MenuModel(**CamelCaseUtil.transform_result(menu))
|
||||
|
||||
return result
|
||||
|
||||
@classmethod
|
||||
def list_to_tree(cls, permission_list: list) -> list:
|
||||
"""
|
||||
工具方法：根据菜单列表信息生成树形嵌套数据
|
||||
:param permission_list: 菜单列表信息
|
||||
:return: 菜单树形嵌套数据
|
||||
"""
|
||||
permission_list = [dict(id=item.menu_id, label=item.menu_name, parentId=item.parent_id) for item in permission_list]
|
||||
# 转成id为key的字典
|
||||
mapping: dict = dict(zip([i['id'] for i in permission_list], permission_list))
|
||||
|
||||
# 树容器
|
||||
container: list = []
|
||||
|
||||
for d in permission_list:
|
||||
# 如果找不到父级项，则是根节点
|
||||
parent: dict = mapping.get(d['parentId'])
|
||||
if parent is None:
|
||||
container.append(d)
|
||||
else:
|
||||
children: list = parent.get('children')
|
||||
if not children:
|
||||
children = []
|
||||
children.append(d)
|
||||
parent.update({'children': children})
|
||||
|
||||
return container
|
||||
106
ruoyi-fastapi-backend/module_admin/service/notice_service.py
Normal file
106
ruoyi-fastapi-backend/module_admin/service/notice_service.py
Normal file
@@ -0,0 +1,106 @@
|
||||
from module_admin.dao.notice_dao import *
|
||||
from module_admin.entity.vo.common_vo import CrudResponseModel
|
||||
from utils.common_util import export_list2excel, CamelCaseUtil
|
||||
|
||||
|
||||
class NoticeService:
|
||||
"""
|
||||
通知公告管理模块服务层
|
||||
"""
|
||||
|
||||
@classmethod
|
||||
def get_notice_list_services(cls, query_db: Session, query_object: NoticeQueryModel):
|
||||
"""
|
||||
获取通知公告列表信息service
|
||||
:param query_db: orm对象
|
||||
:param query_object: 查询参数对象
|
||||
:return: 通知公告列表信息对象
|
||||
"""
|
||||
notice_list_result = NoticeDao.get_notice_list(query_db, query_object)
|
||||
|
||||
return CamelCaseUtil.transform_result(notice_list_result)
|
||||
|
||||
@classmethod
|
||||
def add_notice_services(cls, query_db: Session, page_object: NoticeModel):
|
||||
"""
|
||||
新增通知公告信息service
|
||||
:param query_db: orm对象
|
||||
:param page_object: 新增通知公告对象
|
||||
:return: 新增通知公告校验结果
|
||||
"""
|
||||
notice = NoticeDao.get_notice_detail_by_info(query_db, page_object)
|
||||
if notice:
|
||||
result = dict(is_success=False, message='通知公告已存在')
|
||||
else:
|
||||
try:
|
||||
NoticeDao.add_notice_dao(query_db, page_object)
|
||||
query_db.commit()
|
||||
result = dict(is_success=True, message='新增成功')
|
||||
except Exception as e:
|
||||
query_db.rollback()
|
||||
raise e
|
||||
|
||||
return CrudResponseModel(**result)
|
||||
|
||||
@classmethod
|
||||
def edit_notice_services(cls, query_db: Session, page_object: NoticeModel):
|
||||
"""
|
||||
编辑通知公告信息service
|
||||
:param query_db: orm对象
|
||||
:param page_object: 编辑通知公告对象
|
||||
:return: 编辑通知公告校验结果
|
||||
"""
|
||||
edit_notice = page_object.model_dump(exclude_unset=True)
|
||||
notice_info = cls.notice_detail_services(query_db, edit_notice.get('notice_id'))
|
||||
if notice_info:
|
||||
if notice_info.notice_title != page_object.notice_title or notice_info.notice_type != page_object.notice_type or notice_info.notice_content != page_object.notice_content:
|
||||
notice = NoticeDao.get_notice_detail_by_info(query_db, page_object)
|
||||
if notice:
|
||||
result = dict(is_success=False, message='通知公告已存在')
|
||||
return CrudResponseModel(**result)
|
||||
try:
|
||||
NoticeDao.edit_notice_dao(query_db, edit_notice)
|
||||
query_db.commit()
|
||||
result = dict(is_success=True, message='更新成功')
|
||||
except Exception as e:
|
||||
query_db.rollback()
|
||||
raise e
|
||||
else:
|
||||
result = dict(is_success=False, message='通知公告不存在')
|
||||
|
||||
return CrudResponseModel(**result)
|
||||
|
||||
@classmethod
|
||||
def delete_notice_services(cls, query_db: Session, page_object: DeleteNoticeModel):
|
||||
"""
|
||||
删除通知公告信息service
|
||||
:param query_db: orm对象
|
||||
:param page_object: 删除通知公告对象
|
||||
:return: 删除通知公告校验结果
|
||||
"""
|
||||
if page_object.notice_ids.split(','):
|
||||
notice_id_list = page_object.notice_ids.split(',')
|
||||
try:
|
||||
for notice_id in notice_id_list:
|
||||
NoticeDao.delete_notice_dao(query_db, NoticeModel(noticeId=notice_id))
|
||||
query_db.commit()
|
||||
result = dict(is_success=True, message='删除成功')
|
||||
except Exception as e:
|
||||
query_db.rollback()
|
||||
raise e
|
||||
else:
|
||||
result = dict(is_success=False, message='传入通知公告id为空')
|
||||
return CrudResponseModel(**result)
|
||||
|
||||
@classmethod
|
||||
def notice_detail_services(cls, query_db: Session, notice_id: int):
|
||||
"""
|
||||
获取通知公告详细信息service
|
||||
:param query_db: orm对象
|
||||
:param notice_id: 通知公告id
|
||||
:return: 通知公告id对应的信息
|
||||
"""
|
||||
notice = NoticeDao.get_notice_detail_by_id(query_db, notice_id=notice_id)
|
||||
result = NoticeModel(**CamelCaseUtil.transform_result(notice))
|
||||
|
||||
return result
|
||||
71
ruoyi-fastapi-backend/module_admin/service/online_service.py
Normal file
71
ruoyi-fastapi-backend/module_admin/service/online_service.py
Normal file
@@ -0,0 +1,71 @@
|
||||
from fastapi import Request
|
||||
from jose import jwt
|
||||
from config.env import JwtConfig, RedisInitKeyConfig
|
||||
from module_admin.entity.vo.online_vo import *
|
||||
from module_admin.entity.vo.common_vo import CrudResponseModel
|
||||
from utils.common_util import CamelCaseUtil
|
||||
|
||||
|
||||
class OnlineService:
|
||||
"""
|
||||
在线用户管理模块服务层
|
||||
"""
|
||||
|
||||
@classmethod
|
||||
async def get_online_list_services(cls, request: Request, query_object: OnlineQueryModel):
|
||||
"""
|
||||
获取在线用户表信息service
|
||||
:param request: Request对象
|
||||
:param query_object: 查询参数对象
|
||||
:return: 在线用户列表信息
|
||||
"""
|
||||
access_token_keys = await request.app.state.redis.keys(f"{RedisInitKeyConfig.ACCESS_TOKEN.get('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]
|
||||
online_info_list = []
|
||||
for item in access_token_values_list:
|
||||
payload = jwt.decode(item, JwtConfig.SECRET_KEY, algorithms=[JwtConfig.ALGORITHM])
|
||||
online_dict = dict(
|
||||
token_id=payload.get('session_id'),
|
||||
user_name=payload.get('user_name'),
|
||||
dept_name=payload.get('dept_name'),
|
||||
ipaddr=payload.get('login_info').get('ipaddr'),
|
||||
login_location=payload.get('login_info').get('loginLocation'),
|
||||
browser=payload.get('login_info').get('browser'),
|
||||
os=payload.get('login_info').get('os'),
|
||||
login_time=payload.get('login_info').get('loginTime')
|
||||
)
|
||||
if query_object.user_name and not query_object.ipaddr:
|
||||
if query_object.user_name == payload.get('login_info').get('ipaddr'):
|
||||
online_info_list = [online_dict]
|
||||
break
|
||||
elif not query_object.user_name and query_object.ipaddr:
|
||||
if query_object.ipaddr == payload.get('ipaddr'):
|
||||
online_info_list = [online_dict]
|
||||
break
|
||||
elif query_object.user_name and query_object.ipaddr:
|
||||
if query_object.user_name == payload.get('user_name') and query_object.ipaddr == payload.get('login_info').get('ipaddr'):
|
||||
online_info_list = [online_dict]
|
||||
break
|
||||
else:
|
||||
online_info_list.append(online_dict)
|
||||
|
||||
return CamelCaseUtil.transform_result(online_info_list)
|
||||
|
||||
@classmethod
|
||||
async def delete_online_services(cls, request: Request, page_object: DeleteOnlineModel):
|
||||
"""
|
||||
强退在线用户信息service
|
||||
:param request: Request对象
|
||||
:param page_object: 强退在线用户对象
|
||||
:return: 强退在线用户校验结果
|
||||
"""
|
||||
if page_object.token_ids.split(','):
|
||||
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}")
|
||||
result = dict(is_success=True, message='强退成功')
|
||||
else:
|
||||
result = dict(is_success=False, message='传入session_id为空')
|
||||
return CrudResponseModel(**result)
|
||||
138
ruoyi-fastapi-backend/module_admin/service/post_service.py
Normal file
138
ruoyi-fastapi-backend/module_admin/service/post_service.py
Normal file
@@ -0,0 +1,138 @@
|
||||
from module_admin.dao.post_dao import *
|
||||
from module_admin.entity.vo.common_vo import CrudResponseModel
|
||||
from utils.common_util import export_list2excel, CamelCaseUtil
|
||||
|
||||
|
||||
class PostService:
|
||||
"""
|
||||
岗位管理模块服务层
|
||||
"""
|
||||
@classmethod
|
||||
def get_post_list_services(cls, query_db: Session, query_object: PostModel):
|
||||
"""
|
||||
获取岗位列表信息service
|
||||
:param query_db: orm对象
|
||||
:param query_object: 查询参数对象
|
||||
:return: 岗位列表信息对象
|
||||
"""
|
||||
post_list_result = PostDao.get_post_list(query_db, query_object)
|
||||
|
||||
return CamelCaseUtil.transform_result(post_list_result)
|
||||
|
||||
@classmethod
|
||||
def add_post_services(cls, query_db: Session, page_object: PostModel):
|
||||
"""
|
||||
新增岗位信息service
|
||||
:param query_db: orm对象
|
||||
:param page_object: 新增岗位对象
|
||||
:return: 新增岗位校验结果
|
||||
"""
|
||||
post = PostDao.get_post_detail_by_info(query_db, PostModel(postName=page_object.post_name))
|
||||
if post:
|
||||
result = dict(is_success=False, message='岗位名称已存在')
|
||||
else:
|
||||
try:
|
||||
PostDao.add_post_dao(query_db, page_object)
|
||||
query_db.commit()
|
||||
result = dict(is_success=True, message='新增成功')
|
||||
except Exception as e:
|
||||
query_db.rollback()
|
||||
raise e
|
||||
|
||||
return CrudResponseModel(**result)
|
||||
|
||||
@classmethod
|
||||
def edit_post_services(cls, query_db: Session, page_object: PostModel):
|
||||
"""
|
||||
编辑岗位信息service
|
||||
:param query_db: orm对象
|
||||
:param page_object: 编辑岗位对象
|
||||
:return: 编辑岗位校验结果
|
||||
"""
|
||||
edit_post = page_object.model_dump(exclude_unset=True)
|
||||
post_info = cls.post_detail_services(query_db, edit_post.get('post_id'))
|
||||
if post_info:
|
||||
if post_info.post_name != page_object.post_name:
|
||||
post = PostDao.get_post_detail_by_info(query_db, PostModel(postName=page_object.post_name))
|
||||
if post:
|
||||
result = dict(is_success=False, message='岗位名称已存在')
|
||||
return CrudResponseModel(**result)
|
||||
try:
|
||||
PostDao.edit_post_dao(query_db, edit_post)
|
||||
query_db.commit()
|
||||
result = dict(is_success=True, message='更新成功')
|
||||
except Exception as e:
|
||||
query_db.rollback()
|
||||
raise e
|
||||
else:
|
||||
result = dict(is_success=False, message='岗位不存在')
|
||||
|
||||
return CrudResponseModel(**result)
|
||||
|
||||
@classmethod
|
||||
def delete_post_services(cls, query_db: Session, page_object: DeletePostModel):
|
||||
"""
|
||||
删除岗位信息service
|
||||
:param query_db: orm对象
|
||||
:param page_object: 删除岗位对象
|
||||
:return: 删除岗位校验结果
|
||||
"""
|
||||
if page_object.post_ids.split(','):
|
||||
post_id_list = page_object.post_ids.split(',')
|
||||
try:
|
||||
for post_id in post_id_list:
|
||||
PostDao.delete_post_dao(query_db, PostModel(postId=post_id))
|
||||
query_db.commit()
|
||||
result = dict(is_success=True, message='删除成功')
|
||||
except Exception as e:
|
||||
query_db.rollback()
|
||||
raise e
|
||||
else:
|
||||
result = dict(is_success=False, message='传入岗位id为空')
|
||||
return CrudResponseModel(**result)
|
||||
|
||||
@classmethod
|
||||
def post_detail_services(cls, query_db: Session, post_id: int):
|
||||
"""
|
||||
获取岗位详细信息service
|
||||
:param query_db: orm对象
|
||||
:param post_id: 岗位id
|
||||
:return: 岗位id对应的信息
|
||||
"""
|
||||
post = PostDao.get_post_detail_by_id(query_db, post_id=post_id)
|
||||
result = PostModel(**CamelCaseUtil.transform_result(post))
|
||||
|
||||
return result
|
||||
|
||||
@staticmethod
|
||||
def export_post_list_services(post_list: List):
|
||||
"""
|
||||
导出岗位信息service
|
||||
:param post_list: 岗位信息列表
|
||||
:return: 岗位信息对应excel的二进制数据
|
||||
"""
|
||||
# 创建一个映射字典，将英文键映射到中文键
|
||||
mapping_dict = {
|
||||
"postId": "岗位编号",
|
||||
"postCode": "岗位编码",
|
||||
"postName": "岗位名称",
|
||||
"postSort": "显示顺序",
|
||||
"status": "状态",
|
||||
"createBy": "创建者",
|
||||
"createTime": "创建时间",
|
||||
"updateBy": "更新者",
|
||||
"updateTime": "更新时间",
|
||||
"remark": "备注",
|
||||
}
|
||||
|
||||
data = post_list
|
||||
|
||||
for item in data:
|
||||
if item.get('status') == '0':
|
||||
item['status'] = '正常'
|
||||
else:
|
||||
item['status'] = '停用'
|
||||
new_data = [{mapping_dict.get(key): value for key, value in item.items() if mapping_dict.get(key)} for item in data]
|
||||
binary_data = export_list2excel(new_data)
|
||||
|
||||
return binary_data
|
||||
256
ruoyi-fastapi-backend/module_admin/service/role_service.py
Normal file
256
ruoyi-fastapi-backend/module_admin/service/role_service.py
Normal file
@@ -0,0 +1,256 @@
|
||||
from module_admin.entity.vo.user_vo import UserInfoModel, UserRoleQueryModel
|
||||
from module_admin.entity.vo.common_vo import CrudResponseModel
|
||||
from module_admin.dao.user_dao import UserDao
|
||||
from module_admin.dao.role_dao import *
|
||||
from utils.common_util import export_list2excel, CamelCaseUtil
|
||||
|
||||
|
||||
class RoleService:
|
||||
"""
|
||||
角色管理模块服务层
|
||||
"""
|
||||
|
||||
@classmethod
|
||||
def get_role_select_option_services(cls, query_db: Session):
|
||||
"""
|
||||
获取角色列表不分页信息service
|
||||
:param query_db: orm对象
|
||||
:return: 角色列表不分页信息对象
|
||||
"""
|
||||
role_list_result = RoleDao.get_role_select_option_dao(query_db)
|
||||
|
||||
return CamelCaseUtil.transform_result(role_list_result)
|
||||
|
||||
@classmethod
|
||||
def get_role_dept_tree_services(cls, query_db: Session, role_id: int):
|
||||
"""
|
||||
根据角色id获取部门树信息service
|
||||
:param query_db: orm对象
|
||||
:param role_id: 角色id
|
||||
:return: 当前角色id的部门树信息对象
|
||||
"""
|
||||
role_dept_list = RoleDao.get_role_dept_dao(query_db, role_id)
|
||||
checked_keys = [row.dept_id for row in role_dept_list]
|
||||
result = RoleDeptQueryModel(
|
||||
checkedKeys=checked_keys
|
||||
)
|
||||
|
||||
return result
|
||||
|
||||
@classmethod
|
||||
def get_role_list_services(cls, query_db: Session, query_object: RoleQueryModel):
|
||||
"""
|
||||
获取角色列表信息service
|
||||
:param query_db: orm对象
|
||||
:param query_object: 查询参数对象
|
||||
:return: 角色列表信息对象
|
||||
"""
|
||||
role_list_result = RoleDao.get_role_list(query_db, query_object)
|
||||
|
||||
return CamelCaseUtil.transform_result(role_list_result)
|
||||
|
||||
@classmethod
|
||||
def add_role_services(cls, query_db: Session, page_object: AddRoleModel):
|
||||
"""
|
||||
新增角色信息service
|
||||
:param query_db: orm对象
|
||||
:param page_object: 新增角色对象
|
||||
:return: 新增角色校验结果
|
||||
"""
|
||||
add_role = RoleModel(**page_object.model_dump(by_alias=True))
|
||||
role_name = RoleDao.get_role_by_info(query_db, RoleModel(roleName=page_object.role_name))
|
||||
role_key = RoleDao.get_role_by_info(query_db, RoleModel(roleKey=page_object.role_key))
|
||||
if role_name:
|
||||
result = dict(is_success=False, message='角色名称已存在')
|
||||
elif role_key:
|
||||
result = dict(is_success=False, message='权限字符已存在')
|
||||
else:
|
||||
try:
|
||||
add_result = RoleDao.add_role_dao(query_db, add_role)
|
||||
role_id = add_result.role_id
|
||||
if page_object.menu_ids:
|
||||
for menu in page_object.menu_ids:
|
||||
RoleDao.add_role_menu_dao(query_db, RoleMenuModel(roleId=role_id, menuId=menu))
|
||||
query_db.commit()
|
||||
result = dict(is_success=True, message='新增成功')
|
||||
except Exception as e:
|
||||
query_db.rollback()
|
||||
raise e
|
||||
|
||||
return CrudResponseModel(**result)
|
||||
|
||||
@classmethod
|
||||
def edit_role_services(cls, query_db: Session, page_object: AddRoleModel):
|
||||
"""
|
||||
编辑角色信息service
|
||||
:param query_db: orm对象
|
||||
:param page_object: 编辑角色对象
|
||||
:return: 编辑角色校验结果
|
||||
"""
|
||||
edit_role = page_object.model_dump(exclude_unset=True)
|
||||
if page_object.type != 'status':
|
||||
del edit_role['menu_ids']
|
||||
if page_object.type == 'status':
|
||||
del edit_role['type']
|
||||
role_info = cls.role_detail_services(query_db, edit_role.get('role_id'))
|
||||
if role_info:
|
||||
if page_object.type != 'status' and role_info.role_name != page_object.role_name:
|
||||
role_name = RoleDao.get_role_by_info(query_db, RoleModel(roleName=page_object.role_name))
|
||||
if role_name:
|
||||
result = dict(is_success=False, message='角色名称已存在')
|
||||
return CrudResponseModel(**result)
|
||||
elif page_object.type != 'status' and role_info.role_key != page_object.role_key:
|
||||
role_key = RoleDao.get_role_by_info(query_db, RoleModel(roleKey=page_object.role_key))
|
||||
if role_key:
|
||||
result = dict(is_success=False, message='权限字符已存在')
|
||||
return CrudResponseModel(**result)
|
||||
try:
|
||||
RoleDao.edit_role_dao(query_db, edit_role)
|
||||
if page_object.type != 'status':
|
||||
RoleDao.delete_role_menu_dao(query_db, RoleMenuModel(roleId=page_object.role_id))
|
||||
if page_object.menu_ids:
|
||||
for menu in page_object.menu_ids:
|
||||
RoleDao.add_role_menu_dao(query_db, RoleMenuModel(roleId=page_object.role_id, menuId=menu))
|
||||
query_db.commit()
|
||||
result = dict(is_success=True, message='更新成功')
|
||||
except Exception as e:
|
||||
query_db.rollback()
|
||||
raise e
|
||||
else:
|
||||
result = dict(is_success=False, message='角色不存在')
|
||||
|
||||
return CrudResponseModel(**result)
|
||||
|
||||
@classmethod
|
||||
def role_datascope_services(cls, query_db: Session, page_object: AddRoleModel):
|
||||
"""
|
||||
分配角色数据权限service
|
||||
:param query_db: orm对象
|
||||
:param page_object: 角色数据权限对象
|
||||
:return: 分配角色数据权限结果
|
||||
"""
|
||||
edit_role = page_object.model_dump(exclude_unset=True)
|
||||
del edit_role['dept_ids']
|
||||
role_info = cls.role_detail_services(query_db, edit_role.get('role_id'))
|
||||
if role_info:
|
||||
if role_info.role_name != page_object.role_name:
|
||||
role_name = RoleDao.get_role_by_info(query_db, RoleModel(roleName=page_object.role_name))
|
||||
if role_name:
|
||||
result = dict(is_success=False, message='角色名称已存在')
|
||||
return CrudResponseModel(**result)
|
||||
elif role_info.role_key != page_object.role_key:
|
||||
role_key = RoleDao.get_role_by_info(query_db, RoleModel(roleKey=page_object.role_key))
|
||||
if role_key:
|
||||
result = dict(is_success=False, message='权限字符已存在')
|
||||
return CrudResponseModel(**result)
|
||||
try:
|
||||
RoleDao.edit_role_dao(query_db, edit_role)
|
||||
RoleDao.delete_role_dept_dao(query_db, RoleDeptModel(roleId=page_object.role_id))
|
||||
if page_object.dept_ids and page_object.data_scope == '2':
|
||||
for dept in page_object.dept_ids:
|
||||
RoleDao.add_role_dept_dao(query_db, RoleDeptModel(roleId=page_object.role_id, deptId=dept))
|
||||
query_db.commit()
|
||||
result = dict(is_success=True, message='分配成功')
|
||||
except Exception as e:
|
||||
query_db.rollback()
|
||||
raise e
|
||||
else:
|
||||
result = dict(is_success=False, message='角色不存在')
|
||||
|
||||
return CrudResponseModel(**result)
|
||||
|
||||
@classmethod
|
||||
def delete_role_services(cls, query_db: Session, page_object: DeleteRoleModel):
|
||||
"""
|
||||
删除角色信息service
|
||||
:param query_db: orm对象
|
||||
:param page_object: 删除角色对象
|
||||
:return: 删除角色校验结果
|
||||
"""
|
||||
if page_object.role_ids.split(','):
|
||||
role_id_list = page_object.role_ids.split(',')
|
||||
try:
|
||||
for role_id in role_id_list:
|
||||
role_id_dict = dict(roleId=role_id, updateBy=page_object.update_by, updateTime=page_object.update_time)
|
||||
RoleDao.delete_role_menu_dao(query_db, RoleMenuModel(**role_id_dict))
|
||||
RoleDao.delete_role_dao(query_db, RoleModel(**role_id_dict))
|
||||
query_db.commit()
|
||||
result = dict(is_success=True, message='删除成功')
|
||||
except Exception as e:
|
||||
query_db.rollback()
|
||||
raise e
|
||||
else:
|
||||
result = dict(is_success=False, message='传入角色id为空')
|
||||
return CrudResponseModel(**result)
|
||||
|
||||
@classmethod
|
||||
def role_detail_services(cls, query_db: Session, role_id: int):
|
||||
"""
|
||||
获取角色详细信息service
|
||||
:param query_db: orm对象
|
||||
:param role_id: 角色id
|
||||
:return: 角色id对应的信息
|
||||
"""
|
||||
role = RoleDao.get_role_detail_by_id(query_db, role_id=role_id)
|
||||
result = RoleModel(**CamelCaseUtil.transform_result(role))
|
||||
|
||||
return result
|
||||
|
||||
@staticmethod
|
||||
def export_role_list_services(role_list: List):
|
||||
"""
|
||||
导出角色列表信息service
|
||||
:param role_list: 角色信息列表
|
||||
:return: 角色列表信息对象
|
||||
"""
|
||||
# 创建一个映射字典，将英文键映射到中文键
|
||||
mapping_dict = {
|
||||
"roleId": "角色编号",
|
||||
"roleName": "角色名称",
|
||||
"roleKey": "权限字符",
|
||||
"roleSort": "显示顺序",
|
||||
"status": "状态",
|
||||
"createBy": "创建者",
|
||||
"createTime": "创建时间",
|
||||
"updateBy": "更新者",
|
||||
"updateTime": "更新时间",
|
||||
"remark": "备注",
|
||||
}
|
||||
|
||||
data = role_list
|
||||
|
||||
for item in data:
|
||||
if item.get('status') == '0':
|
||||
item['status'] = '正常'
|
||||
else:
|
||||
item['status'] = '停用'
|
||||
new_data = [{mapping_dict.get(key): value for key, value in item.items() if mapping_dict.get(key)} for item in data]
|
||||
binary_data = export_list2excel(new_data)
|
||||
|
||||
return binary_data
|
||||
|
||||
@classmethod
|
||||
def get_role_user_allocated_list_services(cls, query_db: Session, page_object: UserRoleQueryModel):
|
||||
"""
|
||||
根据角色id获取已分配用户列表
|
||||
:param query_db: orm对象
|
||||
:param page_object: 用户关联角色对象
|
||||
:return: 已分配用户列表
|
||||
"""
|
||||
query_user_list = UserDao.get_user_role_allocated_list_by_role_id(query_db, page_object)
|
||||
allocated_list = [UserInfoModel(**CamelCaseUtil.transform_result(row)) for row in query_user_list]
|
||||
|
||||
return allocated_list
|
||||
|
||||
@classmethod
|
||||
def get_role_user_unallocated_list_services(cls, query_db: Session, page_object: UserRoleQueryModel):
|
||||
"""
|
||||
根据角色id获取未分配用户列表
|
||||
:param query_db: orm对象
|
||||
:param page_object: 用户关联角色对象
|
||||
:return: 未分配用户列表
|
||||
"""
|
||||
query_user_list = UserDao.get_user_role_unallocated_list_by_role_id(query_db, page_object)
|
||||
unallocated_list = [UserInfoModel(**CamelCaseUtil.transform_result(row)) for row in query_user_list]
|
||||
|
||||
return unallocated_list
|
||||
94
ruoyi-fastapi-backend/module_admin/service/server_service.py
Normal file
94
ruoyi-fastapi-backend/module_admin/service/server_service.py
Normal file
@@ -0,0 +1,94 @@
|
||||
import psutil
|
||||
from utils.common_util import bytes2human
|
||||
import platform
|
||||
import socket
|
||||
import os
|
||||
import time
|
||||
from module_admin.entity.vo.server_vo import *
|
||||
|
||||
|
||||
class ServerService:
|
||||
"""
|
||||
服务监控模块服务层
|
||||
"""
|
||||
|
||||
@staticmethod
|
||||
def get_server_monitor_info():
|
||||
# CPU信息
|
||||
# 获取CPU总核心数
|
||||
cpu_num = psutil.cpu_count(logical=True)
|
||||
cpu_usage_percent = psutil.cpu_times_percent()
|
||||
cpu_used = cpu_usage_percent.user
|
||||
cpu_sys = cpu_usage_percent.system
|
||||
cpu_free = cpu_usage_percent.idle
|
||||
cpu = CpuInfo(cpuNum=cpu_num, used=cpu_used, sys=cpu_sys, free=cpu_free)
|
||||
|
||||
# 内存信息
|
||||
memory_info = psutil.virtual_memory()
|
||||
memory_total = bytes2human(memory_info.total)
|
||||
memory_used = bytes2human(memory_info.used)
|
||||
memory_free = bytes2human(memory_info.free)
|
||||
memory_usage = memory_info.percent
|
||||
mem = MemoryInfo(total=memory_total, used=memory_used, free=memory_free, usage=memory_usage)
|
||||
|
||||
# 主机信息
|
||||
# 获取主机名
|
||||
hostname = socket.gethostname()
|
||||
# 获取IP
|
||||
computer_ip = socket.gethostbyname(hostname)
|
||||
os_name = platform.platform()
|
||||
computer_name = platform.node()
|
||||
os_arch = platform.machine()
|
||||
user_dir = os.path.abspath(os.getcwd())
|
||||
sys = SysInfo(computerIp=computer_ip, computerName=computer_name, osArch=os_arch, osName=os_name, userDir=user_dir)
|
||||
|
||||
# python解释器信息
|
||||
current_pid = os.getpid()
|
||||
current_process = psutil.Process(current_pid)
|
||||
python_name = current_process.name()
|
||||
python_version = platform.python_version()
|
||||
python_home = current_process.exe()
|
||||
start_time_stamp = current_process.create_time()
|
||||
start_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(start_time_stamp))
|
||||
current_time_stamp = time.time()
|
||||
difference = current_time_stamp - start_time_stamp
|
||||
# 将时间差转换为天、小时和分钟数
|
||||
days = int(difference // (24 * 60 * 60)) # 每天的秒数
|
||||
hours = int((difference % (24 * 60 * 60)) // (60 * 60)) # 每小时的秒数
|
||||
minutes = int((difference % (60 * 60)) // 60) # 每分钟的秒数
|
||||
run_time = f"{days}天{hours}小时{minutes}分钟"
|
||||
# 获取当前Python程序的pid
|
||||
pid = os.getpid()
|
||||
# 获取该进程的内存信息
|
||||
current_process_memory_info = psutil.Process(pid).memory_info()
|
||||
py = PyInfo(
|
||||
name=python_name,
|
||||
version=python_version,
|
||||
startTime=start_time,
|
||||
runTime=run_time,
|
||||
home=python_home,
|
||||
total=bytes2human(memory_info.available),
|
||||
used=bytes2human(current_process_memory_info.rss),
|
||||
free=bytes2human(memory_info.available - current_process_memory_info.rss),
|
||||
usage=round((current_process_memory_info.rss / memory_info.available) * 100, 2)
|
||||
)
|
||||
|
||||
# 磁盘信息
|
||||
io = psutil.disk_partitions()
|
||||
sys_files = []
|
||||
for i in io:
|
||||
o = psutil.disk_usage(i.device)
|
||||
disk_data = SysFiles(
|
||||
dirName=i.device,
|
||||
sysTypeName=i.fstype,
|
||||
typeName="本地固定磁盘（" + i.mountpoint.replace('\\', '') + "）",
|
||||
total=bytes2human(o.total),
|
||||
used=bytes2human(o.used),
|
||||
free=bytes2human(o.free),
|
||||
usage=f'{psutil.disk_usage(i.device).percent}%'
|
||||
)
|
||||
sys_files.append(disk_data)
|
||||
|
||||
result = ServerMonitorModel(cpu=cpu, mem=mem, sys=sys, py=py, sysFiles=sys_files)
|
||||
|
||||
return result
|
||||
475
ruoyi-fastapi-backend/module_admin/service/user_service.py
Normal file
475
ruoyi-fastapi-backend/module_admin/service/user_service.py
Normal file
@@ -0,0 +1,475 @@
|
||||
from fastapi import UploadFile
|
||||
from module_admin.service.role_service import RoleService
|
||||
from module_admin.service.post_service import PostService
|
||||
from module_admin.entity.vo.common_vo import CrudResponseModel
|
||||
from module_admin.dao.user_dao import *
|
||||
from utils.pwd_util import *
|
||||
from utils.common_util import *
|
||||
|
||||
|
||||
class UserService:
|
||||
"""
|
||||
用户管理模块服务层
|
||||
"""
|
||||
|
||||
@classmethod
|
||||
def get_user_list_services(cls, query_db: Session, query_object: UserQueryModel, data_scope_sql: str):
|
||||
"""
|
||||
获取用户列表信息service
|
||||
:param query_db: orm对象
|
||||
:param query_object: 查询参数对象
|
||||
:param data_scope_sql: 数据权限对应的查询sql语句
|
||||
:return: 用户列表信息对象
|
||||
"""
|
||||
query_result = UserDao.get_user_list(query_db, query_object, data_scope_sql)
|
||||
user_list_result = []
|
||||
if query_result:
|
||||
user_list_result = [{**CamelCaseUtil.transform_result(row[0]), 'dept': CamelCaseUtil.transform_result(row[1])} for row in query_result]
|
||||
|
||||
return user_list_result
|
||||
|
||||
@classmethod
|
||||
def add_user_services(cls, query_db: Session, page_object: AddUserModel):
|
||||
"""
|
||||
新增用户信息service
|
||||
:param query_db: orm对象
|
||||
:param page_object: 新增用户对象
|
||||
:return: 新增用户校验结果
|
||||
"""
|
||||
add_user = UserModel(**page_object.model_dump(by_alias=True))
|
||||
user = UserDao.get_user_by_info(query_db, UserModel(userName=page_object.user_name))
|
||||
if user:
|
||||
result = dict(is_success=False, message='用户名已存在')
|
||||
else:
|
||||
try:
|
||||
add_result = UserDao.add_user_dao(query_db, add_user)
|
||||
user_id = add_result.user_id
|
||||
if page_object.role_ids:
|
||||
for role in page_object.role_ids:
|
||||
UserDao.add_user_role_dao(query_db, UserRoleModel(userId=user_id, roleId=role))
|
||||
if page_object.post_ids:
|
||||
for post in page_object.post_ids:
|
||||
UserDao.add_user_post_dao(query_db, UserPostModel(userId=user_id, postId=post))
|
||||
query_db.commit()
|
||||
result = dict(is_success=True, message='新增成功')
|
||||
except Exception as e:
|
||||
query_db.rollback()
|
||||
raise e
|
||||
|
||||
return CrudResponseModel(**result)
|
||||
|
||||
@classmethod
|
||||
def edit_user_services(cls, query_db: Session, page_object: EditUserModel):
|
||||
"""
|
||||
编辑用户信息service
|
||||
:param query_db: orm对象
|
||||
:param page_object: 编辑用户对象
|
||||
:return: 编辑用户校验结果
|
||||
"""
|
||||
edit_user = page_object.model_dump(exclude_unset=True)
|
||||
if page_object.type != 'status' and page_object.type != 'avatar' and page_object.type != 'pwd':
|
||||
del edit_user['role_ids']
|
||||
del edit_user['post_ids']
|
||||
del edit_user['role']
|
||||
if page_object.type == 'status' or page_object.type == 'avatar' or page_object.type == 'pwd':
|
||||
del edit_user['type']
|
||||
user_info = cls.user_detail_services(query_db, edit_user.get('user_id'))
|
||||
if user_info:
|
||||
if page_object.type != 'status' and page_object.type != 'avatar' and page_object.type == 'pwd' and user_info.data.user_name != page_object.user_name:
|
||||
user = UserDao.get_user_by_info(query_db, UserModel(userName=page_object.user_name))
|
||||
if user:
|
||||
result = dict(is_success=False, message='用户名已存在')
|
||||
return CrudResponseModel(**result)
|
||||
try:
|
||||
UserDao.edit_user_dao(query_db, edit_user)
|
||||
if page_object.type != 'status' and page_object.type != 'avatar':
|
||||
UserDao.delete_user_role_dao(query_db, UserRoleModel(userId=page_object.user_id))
|
||||
UserDao.delete_user_post_dao(query_db, UserPostModel(userId=page_object.user_id))
|
||||
if page_object.role_ids:
|
||||
for role in page_object.role_ids:
|
||||
UserDao.add_user_role_dao(query_db, UserRoleModel(userId=page_object.user_id, roleId=role))
|
||||
if page_object.post_ids:
|
||||
for post in page_object.post_ids:
|
||||
UserDao.add_user_post_dao(query_db, UserPostModel(userId=page_object.user_id, postId=post))
|
||||
query_db.commit()
|
||||
result = dict(is_success=True, message='更新成功')
|
||||
except Exception as e:
|
||||
query_db.rollback()
|
||||
raise e
|
||||
else:
|
||||
result = dict(is_success=False, message='用户不存在')
|
||||
|
||||
return CrudResponseModel(**result)
|
||||
|
||||
@classmethod
|
||||
def delete_user_services(cls, query_db: Session, page_object: DeleteUserModel):
|
||||
"""
|
||||
删除用户信息service
|
||||
:param query_db: orm对象
|
||||
:param page_object: 删除用户对象
|
||||
:return: 删除用户校验结果
|
||||
"""
|
||||
if page_object.user_ids.split(','):
|
||||
user_id_list = page_object.user_ids.split(',')
|
||||
try:
|
||||
for user_id in user_id_list:
|
||||
user_id_dict = dict(userId=user_id, updateBy=page_object.update_by, updateTime=page_object.update_time)
|
||||
UserDao.delete_user_role_dao(query_db, UserRoleModel(**user_id_dict))
|
||||
UserDao.delete_user_post_dao(query_db, UserPostModel(**user_id_dict))
|
||||
UserDao.delete_user_dao(query_db, UserModel(**user_id_dict))
|
||||
query_db.commit()
|
||||
result = dict(is_success=True, message='删除成功')
|
||||
except Exception as e:
|
||||
query_db.rollback()
|
||||
raise e
|
||||
else:
|
||||
result = dict(is_success=False, message='传入用户id为空')
|
||||
return CrudResponseModel(**result)
|
||||
|
||||
@classmethod
|
||||
def user_detail_services(cls, query_db: Session, user_id: Union[int, str]):
|
||||
"""
|
||||
获取用户详细信息service
|
||||
:param query_db: orm对象
|
||||
:param user_id: 用户id
|
||||
:return: 用户id对应的信息
|
||||
"""
|
||||
posts = PostService.get_post_list_services(query_db, PostModel(**{}))
|
||||
roles = RoleService.get_role_select_option_services(query_db)
|
||||
if user_id != '':
|
||||
query_user = UserDao.get_user_detail_by_id(query_db, user_id=user_id)
|
||||
post_ids = ','.join([str(row.post_id) for row in query_user.get('user_post_info')])
|
||||
post_ids_list = [row.post_id for row in query_user.get('user_post_info')]
|
||||
role_ids = ','.join([str(row.role_id) for row in query_user.get('user_role_info')])
|
||||
role_ids_list = [row.role_id for row in query_user.get('user_role_info')]
|
||||
|
||||
return UserDetailModel(
|
||||
data=UserInfoModel(
|
||||
**CamelCaseUtil.transform_result(query_user.get('user_basic_info')),
|
||||
postIds=post_ids,
|
||||
roleIds=role_ids,
|
||||
dept=CamelCaseUtil.transform_result(query_user.get('user_dept_info')),
|
||||
role=CamelCaseUtil.transform_result(query_user.get('user_role_info'))
|
||||
),
|
||||
postIds=post_ids_list,
|
||||
posts=posts,
|
||||
roleIds=role_ids_list,
|
||||
roles=roles
|
||||
)
|
||||
|
||||
return UserDetailModel(
|
||||
posts=posts,
|
||||
roles=roles
|
||||
)
|
||||
|
||||
@classmethod
|
||||
def user_profile_services(cls, query_db: Session, user_id: int):
|
||||
"""
|
||||
获取用户详细信息service
|
||||
:param query_db: orm对象
|
||||
:param user_id: 用户id
|
||||
:return: 用户id对应的信息
|
||||
"""
|
||||
query_user = UserDao.get_user_detail_by_id(query_db, user_id=user_id)
|
||||
post_ids = ','.join([str(row.post_id) for row in query_user.get('user_post_info')])
|
||||
post_group = ','.join([row.post_name for row in query_user.get('user_post_info')])
|
||||
role_ids = ','.join([str(row.role_id) for row in query_user.get('user_role_info')])
|
||||
role_group = ','.join([row.role_name for row in query_user.get('user_role_info')])
|
||||
|
||||
return UserProfileModel(
|
||||
data=UserInfoModel(
|
||||
**CamelCaseUtil.transform_result(query_user.get('user_basic_info')),
|
||||
postIds=post_ids,
|
||||
roleIds=role_ids,
|
||||
dept=CamelCaseUtil.transform_result(query_user.get('user_dept_info')),
|
||||
role=CamelCaseUtil.transform_result(query_user.get('user_role_info'))
|
||||
),
|
||||
postGroup=post_group,
|
||||
roleGroup=role_group
|
||||
)
|
||||
|
||||
@classmethod
|
||||
def reset_user_services(cls, query_db: Session, page_object: ResetUserModel):
|
||||
"""
|
||||
重置用户密码service
|
||||
:param query_db: orm对象
|
||||
:param page_object: 重置用户对象
|
||||
:return: 重置用户校验结果
|
||||
"""
|
||||
reset_user = page_object.model_dump(exclude_unset=True)
|
||||
if page_object.old_password:
|
||||
user = UserDao.get_user_detail_by_id(query_db, user_id=page_object.user_id).get('user_basic_info')
|
||||
if not PwdUtil.verify_password(page_object.old_password, user.password):
|
||||
result = dict(is_success=False, message='旧密码不正确')
|
||||
return CrudResponseModel(**result)
|
||||
else:
|
||||
del reset_user['old_password']
|
||||
if page_object.sms_code and page_object.session_id:
|
||||
del reset_user['sms_code']
|
||||
del reset_user['session_id']
|
||||
try:
|
||||
UserDao.edit_user_dao(query_db, reset_user)
|
||||
query_db.commit()
|
||||
result = dict(is_success=True, message='重置成功')
|
||||
except Exception as e:
|
||||
query_db.rollback()
|
||||
raise e
|
||||
|
||||
return CrudResponseModel(**result)
|
||||
|
||||
@classmethod
|
||||
async def batch_import_user_services(cls, query_db: Session, file: UploadFile, update_support: bool, current_user: CurrentUserModel):
|
||||
"""
|
||||
批量导入用户service
|
||||
:param query_db: orm对象
|
||||
:param file: 用户导入文件对象
|
||||
:param update_support: 用户存在时是否更新
|
||||
:param current_user: 当前用户对象
|
||||
:return: 批量导入用户结果
|
||||
"""
|
||||
header_dict = {
|
||||
"部门编号": "dept_id",
|
||||
"登录名称": "user_name",
|
||||
"用户名称": "nick_name",
|
||||
"用户邮箱": "email",
|
||||
"手机号码": "phonenumber",
|
||||
"用户性别": "sex",
|
||||
"帐号状态": "status"
|
||||
}
|
||||
contents = await file.read()
|
||||
df = pd.read_excel(io.BytesIO(contents))
|
||||
await file.close()
|
||||
df.rename(columns=header_dict, inplace=True)
|
||||
add_error_result = []
|
||||
count = 0
|
||||
try:
|
||||
for index, row in df.iterrows():
|
||||
count = count + 1
|
||||
if row['sex'] == '男':
|
||||
row['sex'] = '0'
|
||||
if row['sex'] == '女':
|
||||
row['sex'] = '1'
|
||||
if row['sex'] == '未知':
|
||||
row['sex'] = '2'
|
||||
if row['status'] == '正常':
|
||||
row['status'] = '0'
|
||||
if row['status'] == '停用':
|
||||
row['status'] = '1'
|
||||
add_user = UserModel(
|
||||
deptId=row['dept_id'],
|
||||
userName=row['user_name'],
|
||||
password=PwdUtil.get_password_hash('123456'),
|
||||
nickName=row['nick_name'],
|
||||
email=row['email'],
|
||||
phonenumber=str(row['phonenumber']),
|
||||
sex=row['sex'],
|
||||
status=row['status'],
|
||||
createBy=current_user.user.user_name,
|
||||
updateBy=current_user.user.user_name
|
||||
)
|
||||
user_info = UserDao.get_user_by_info(query_db, UserModel(userName=row['user_name']))
|
||||
if user_info:
|
||||
if update_support:
|
||||
edit_user = UserModel(
|
||||
userId=user_info.user_id,
|
||||
deptId=row['dept_id'],
|
||||
userName=row['user_name'],
|
||||
nickName=row['nick_name'],
|
||||
email=row['email'],
|
||||
phonenumber=str(row['phonenumber']),
|
||||
sex=row['sex'],
|
||||
status=row['status'],
|
||||
updateBy=current_user.user.user_name
|
||||
).model_dump(exclude_unset=True)
|
||||
UserDao.edit_user_dao(query_db, edit_user)
|
||||
else:
|
||||
add_error_result.append(f"{count}.用户账号{row['user_name']}已存在")
|
||||
else:
|
||||
UserDao.add_user_dao(query_db, add_user)
|
||||
query_db.commit()
|
||||
result = dict(is_success=True, message='\n'.join(add_error_result))
|
||||
except Exception as e:
|
||||
query_db.rollback()
|
||||
raise e
|
||||
|
||||
return CrudResponseModel(**result)
|
||||
|
||||
@staticmethod
|
||||
def get_user_import_template_services():
|
||||
"""
|
||||
获取用户导入模板service
|
||||
:return: 用户导入模板excel的二进制数据
|
||||
"""
|
||||
header_list = ["部门编号", "登录名称", "用户名称", "用户邮箱", "手机号码", "用户性别", "帐号状态"]
|
||||
selector_header_list = ["用户性别", "帐号状态"]
|
||||
option_list = [{"用户性别": ["男", "女", "未知"]}, {"帐号状态": ["正常", "停用"]}]
|
||||
binary_data = get_excel_template(header_list=header_list, selector_header_list=selector_header_list, option_list=option_list)
|
||||
|
||||
return binary_data
|
||||
|
||||
@staticmethod
|
||||
def export_user_list_services(user_list: List):
|
||||
"""
|
||||
导出用户信息service
|
||||
:param user_list: 用户信息列表
|
||||
:return: 用户信息对应excel的二进制数据
|
||||
"""
|
||||
# 创建一个映射字典，将英文键映射到中文键
|
||||
mapping_dict = {
|
||||
"userId": "用户编号",
|
||||
"userName": "用户名称",
|
||||
"nickName": "用户昵称",
|
||||
"deptName": "部门",
|
||||
"email": "邮箱地址",
|
||||
"phonenumber": "手机号码",
|
||||
"sex": "性别",
|
||||
"status": "状态",
|
||||
"createBy": "创建者",
|
||||
"createTime": "创建时间",
|
||||
"updateBy": "更新者",
|
||||
"updateTime": "更新时间",
|
||||
"remark": "备注",
|
||||
}
|
||||
|
||||
data = user_list
|
||||
|
||||
for item in data:
|
||||
if item.get('status') == '0':
|
||||
item['status'] = '正常'
|
||||
else:
|
||||
item['status'] = '停用'
|
||||
if item.get('sex') == '0':
|
||||
item['sex'] = '男'
|
||||
elif item.get('sex') == '1':
|
||||
item['sex'] = '女'
|
||||
else:
|
||||
item['sex'] = '未知'
|
||||
new_data = [{mapping_dict.get(key): value for key, value in item.items() if mapping_dict.get(key)} for item in data]
|
||||
binary_data = export_list2excel(new_data)
|
||||
|
||||
return binary_data
|
||||
|
||||
@classmethod
|
||||
def get_user_role_allocated_list_services(cls, query_db: Session, page_object: UserRoleQueryModel):
|
||||
"""
|
||||
根据用户id获取已分配角色列表
|
||||
:param query_db: orm对象
|
||||
:param page_object: 用户关联角色对象
|
||||
:return: 已分配角色列表
|
||||
"""
|
||||
query_user = UserDao.get_user_detail_by_id(query_db, page_object.user_id)
|
||||
post_ids = ','.join([str(row.post_id) for row in query_user.get('user_post_info')])
|
||||
role_ids = ','.join([str(row.role_id) for row in query_user.get('user_role_info')])
|
||||
user = UserInfoModel(
|
||||
**CamelCaseUtil.transform_result(query_user.get('user_basic_info')),
|
||||
postIds=post_ids,
|
||||
roleIds=role_ids,
|
||||
dept=CamelCaseUtil.transform_result(query_user.get('user_dept_info')),
|
||||
role=CamelCaseUtil.transform_result(query_user.get('user_role_info'))
|
||||
)
|
||||
query_role_list = [SelectedRoleModel(**row) for row in RoleService.get_role_select_option_services(query_db)]
|
||||
for model_a in query_role_list:
|
||||
for model_b in user.role:
|
||||
if model_a.role_id == model_b.role_id:
|
||||
model_a.flag = True
|
||||
result = UserRoleResponseModel(
|
||||
roles=query_role_list,
|
||||
user=user
|
||||
)
|
||||
|
||||
return result
|
||||
|
||||
@classmethod
|
||||
def add_user_role_services(cls, query_db: Session, page_object: CrudUserRoleModel):
|
||||
"""
|
||||
新增用户关联角色信息service
|
||||
:param query_db: orm对象
|
||||
:param page_object: 新增用户关联角色对象
|
||||
:return: 新增用户关联角色校验结果
|
||||
"""
|
||||
if page_object.user_id and page_object.role_ids:
|
||||
role_id_list = page_object.role_ids.split(',')
|
||||
try:
|
||||
for role_id in role_id_list:
|
||||
user_role = cls.detail_user_role_services(query_db, UserRoleModel(userId=page_object.user_id, roleId=role_id))
|
||||
if user_role:
|
||||
continue
|
||||
else:
|
||||
UserDao.add_user_role_dao(query_db, UserRoleModel(userId=page_object.user_id, roleId=role_id))
|
||||
query_db.commit()
|
||||
result = dict(is_success=True, message='分配成功')
|
||||
except Exception as e:
|
||||
query_db.rollback()
|
||||
raise e
|
||||
elif page_object.user_id and not page_object.role_ids:
|
||||
try:
|
||||
UserDao.delete_user_role_by_user_and_role_dao(query_db, UserRoleModel(userId=page_object.user_id))
|
||||
query_db.commit()
|
||||
result = dict(is_success=True, message='分配成功')
|
||||
except Exception as e:
|
||||
query_db.rollback()
|
||||
raise e
|
||||
elif page_object.user_ids and page_object.role_id:
|
||||
user_id_list = page_object.user_ids.split(',')
|
||||
try:
|
||||
for user_id in user_id_list:
|
||||
user_role = cls.detail_user_role_services(query_db, UserRoleModel(userId=user_id, roleId=page_object.role_id))
|
||||
if user_role:
|
||||
continue
|
||||
else:
|
||||
UserDao.add_user_role_dao(query_db, UserRoleModel(userId=user_id, roleId=page_object.role_id))
|
||||
query_db.commit()
|
||||
result = dict(is_success=True, message='新增成功')
|
||||
except Exception as e:
|
||||
query_db.rollback()
|
||||
raise e
|
||||
else:
|
||||
result = dict(is_success=False, message='不满足新增条件')
|
||||
|
||||
return CrudResponseModel(**result)
|
||||
|
||||
@classmethod
|
||||
def delete_user_role_services(cls, query_db: Session, page_object: CrudUserRoleModel):
|
||||
"""
|
||||
删除用户关联角色信息service
|
||||
:param query_db: orm对象
|
||||
:param page_object: 删除用户关联角色对象
|
||||
:return: 删除用户关联角色校验结果
|
||||
"""
|
||||
if (page_object.user_id and page_object.role_id) or (page_object.user_ids and page_object.role_id):
|
||||
if page_object.user_id and page_object.role_id:
|
||||
try:
|
||||
UserDao.delete_user_role_by_user_and_role_dao(query_db, UserRoleModel(userId=page_object.user_id, roleId=page_object.role_id))
|
||||
query_db.commit()
|
||||
result = dict(is_success=True, message='删除成功')
|
||||
except Exception as e:
|
||||
query_db.rollback()
|
||||
raise e
|
||||
elif page_object.user_ids and page_object.role_id:
|
||||
user_id_list = page_object.user_ids.split(',')
|
||||
try:
|
||||
for user_id in user_id_list:
|
||||
UserDao.delete_user_role_by_user_and_role_dao(query_db, UserRoleModel(userId=user_id, roleId=page_object.role_id))
|
||||
query_db.commit()
|
||||
result = dict(is_success=True, message='删除成功')
|
||||
except Exception as e:
|
||||
query_db.rollback()
|
||||
raise e
|
||||
else:
|
||||
result = dict(is_success=False, message='不满足删除条件')
|
||||
else:
|
||||
result = dict(is_success=False, message='传入用户角色关联信息为空')
|
||||
|
||||
return CrudResponseModel(**result)
|
||||
|
||||
@classmethod
|
||||
def detail_user_role_services(cls, query_db: Session, page_object: UserRoleModel):
|
||||
"""
|
||||
获取用户关联角色详细信息service
|
||||
:param query_db: orm对象
|
||||
:param page_object: 用户关联角色对象
|
||||
:return: 用户关联角色详细信息
|
||||
"""
|
||||
user_role = UserDao.get_user_role_detail(query_db, page_object)
|
||||
|
||||
return user_role
|
||||
Reference in New Issue
Block a user