def post(self, request, *args, **kwargs):
# 校验验证码
self.jarge_captcha(request)
serializer = self.get_serializer(data=request.data)
if serializer.is_valid():
user = serializer.object.get('user') or request.user
token = serializer.object.get('token')
response_data = jwt_response_payload_handler(token, user, request)
response = SuccessResponse(response_data)
if token:
username = user.username
session_id = jwt_get_session_id(token)
key = f"{self.prefix}_{session_id}_{username}"
if getattr(settings, "REDIS_ENABLE", False):
cache.set(key, token, self.ex.total_seconds())
self.save_login_infor(request, '登录成功', session_id=session_id)
if self.JWT_AUTH_COOKIE and token:
expiration = (datetime.datetime.utcnow() + self.ex)
response.set_cookie(self.JWT_AUTH_COOKIE,
token,
expires=expiration,
domain=settings.SESSION_COOKIE_DOMAIN,
httponly=False)
return response
self.save_login_infor(request, '登录失败，账户/密码不正确', False)
return ErrorResponse(data=serializer.errors, msg='账户/密码不正确')
def get_user_messages(self, request: Request, *args, **kwargs):
"""
获取用户自己消息列表
"""
queryset = self.filter_queryset(self.get_queryset())
queryset = queryset.filter(status=2)
is_read = request.query_params.get('is_read', None)
if is_read:
if is_read == 'False':
queryset = queryset.exclude(Q(messagepushuser_message_push__is_read=True),
Q(messagepushuser_message_push__user=request.user))
elif is_read == 'True':
queryset = queryset.filter(messagepushuser_message_push__is_read=True,
messagepushuser_message_push__user=request.user)
queryset = queryset.filter(is_reviewed=True).distinct()
page = self.paginate_queryset(queryset)
if hasattr(self, 'handle_logging'):
self.handle_logging(request, *args, **kwargs)
if page is not None:
if getattr(self, 'values_queryset', None):
return self.get_paginated_response(page)
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
if getattr(self, 'values_queryset', None):
return SuccessResponse(page)
serializer = self.get_serializer(queryset, many=True)
return SuccessResponse(serializer.data)
def get_user_details(self, request: Request, *args, **kwargs):
"""
获取用户详情
:param request:
:param args:
:param kwargs:
:return:
"""
userId = request.query_params.get('userId')
data = {
'posts':
PostSimpleSerializer(
Post.objects.filter(status='1').order_by('postSort'),
many=True).data,
'roles':
RoleSimpleSerializer(
Role.objects.filter(status='1').order_by('roleSort'),
many=True).data
}
if userId:
instance = self.queryset.get(id=userId)
serializer = self.get_serializer(instance)
data['data'] = serializer.data
data['postIds'] = [
ele.get('id') for ele in serializer.data.get('post')
]
data['roleIds'] = [
ele.get('id') for ele in serializer.data.get('role')
]
if hasattr(self, 'handle_logging'):
self.handle_logging(request,
instance=instance,
*args,
**kwargs)
return SuccessResponse(data)
def get_rate_info(self, request: Request, *args, **kwargs):
"""
获取使用率 监控信息
:param request:
:param args:
:param kwargs:
:return:
"""
pk = kwargs.get("pk")
queryset = self.filter_queryset(self.get_queryset())
queryset = queryset.filter(server__id=pk).order_by("create_datetime")
# 间隔取值
queryset_count = queryset.count()
Interval_num = 1 if queryset_count < 200 else int(queryset_count / 100)
queryset = queryset.values('cpu_sys', 'mem_num', 'mem_sys',
'create_datetime')[::Interval_num][:100]
data = {
"cpu": [],
"memory": [],
"datetime": [],
}
for ele in queryset:
data["cpu"].append(round(float(ele.get('cpu_sys', 0)), 2))
data["datetime"].append(
ele.get('create_datetime').strftime('%Y-%m-%d %H:%M:%S'))
data["memory"].append(
round(float(ele.get('mem_num', 0)), 4) and round(
float(ele.get('mem_sys', 0)) /
float(ele.get('mem_num', 0)) * 100, 2))
return SuccessResponse(data=data)
def update_is_read(self, request: Request, *args, **kwargs):
"""
修改为已读
"""
instance, _ = MessagePushUser.objects.get_or_create(message_push_id=kwargs.get('pk'), user=request.user)
instance.is_read = True
instance.save()
return SuccessResponse()
def get(self, request):
new_key = CaptchaStore.pick()
to_json_response = {
"key": new_key,
"image_url": captcha_image_url(new_key),
"audio_url": captcha_audio_url(new_key) if ca_settings.CAPTCHA_FLITE_PATH else None,
}
return SuccessResponse(to_json_response)
def post(self, request):
user = request.user
user.user_secret = uuid4()
user.save()
key = f"{self.prefix}_{user.username}"
if getattr(settings, "REDIS_ENABLE", False):
cache.delete(key)
return SuccessResponse()
def clean_all(self, request: Request, *args, **kwargs):
"""
清空定时任务日志
:param request:
:param args:
:param kwargs:
:return:
"""
self.get_queryset().delete()
return SuccessResponse(msg="清空成功")
def clearCache(self, request: Request, *args, **kwargs):
"""
清理键值缓存
:param request:
:param args:
:param kwargs:
:return:
"""
if getattr(settings, "REDIS_ENABLE", False):
cache.delete('system_dict_details')
return SuccessResponse(msg='清理成功！')
def get(self, request, *args, **kwargs):
# 获取内存使用率
memory_used_percent = get_memory_used_percent()
# 获取cpu使用率
cpu_used_percent = get_cpu_used_percent()
# 获取硬盘使用率
disk_used_percent = get_disk_used_percent()
return SuccessResponse(data={"memory_used_percent": memory_used_percent,
"cpu_used_percent": cpu_used_percent,
"disk_used_percent": disk_used_percent
})
def get_monitor_info(self, request: Request, *args, **kwargs):
"""
最新的服务器状态信息
:param request:
:param args:
:param kwargs:
:return:
"""
pk = kwargs.get("pk")
instance = Monitor.objects.filter(
server__id=pk).order_by("-create_datetime").first()
if not instance:
return ErrorResponse(msg="未找到服务器信息id")
serializer = self.get_serializer(instance)
data = serializer.data
return SuccessResponse(
data={
"cpu": {
"total": int(data.get('cpu_num'), 0),
"used": "", # cpu核心 可不传，如指cpu当前主频，该值可以传
"rate": float(data.get('cpu_sys', 0)) / 100,
"unit": "核心", # 默认单位 核心
},
"memory": {
"total":
int(int(data.get('mem_num', 0)) / 1024),
"used":
int(int(data.get('mem_sys', 0)) / 1024),
"rate":
int(data.get('mem_num', 0)) and round(
int(data.get('mem_sys', 0)) /
int(data.get('mem_num', 0)), 4),
"unit":
"MB", # 默认单位 MB
},
"disk": [
{
"dir_name":
ele.get('dir_name'),
"total":
int(int(ele.get('total', 0)) / 1024 / 1024 / 1024),
"used":
int(int(ele.get('disk_sys', 0)) / 1024 / 1024 / 1024),
"rate":
int(ele.get('total', 0)) and round(
int(ele.get('disk_sys', 0)) /
int(ele.get('total', 0)), 4),
"unit":
"GB", # 默认单位 GB
} for ele in SysFiles.objects.filter(monitor=instance).
values('dir_name', 'total', 'disk_sys')
]
})
def export(self, request: Request, *args, **kwargs):
"""
导出字典详情数据
:param request:
:param args:
:param kwargs:
:return:
"""
dictType = request.query_params.get('dictType')
field_data = ['字典详情主键', '字典标签', '字典键值', '是否默认', '字典状态', '字典排序', '创建者', '修改者', '备注']
data = ExportDictDetailsSerializer(DictDetails.objects.filter(dict_data__dictType=dictType), many=True).data
return SuccessResponse(export_excel_save_model(request, field_data, data, f'导出字典[{dictType}]详情数据.xls'))
def tree_select_list(self, request: Request, *args, **kwargs):
"""
递归获取部门树
:param request:
:param args:
:param kwargs:
:return:
"""
queryset = self.filter_queryset(self.get_queryset())
if hasattr(self, 'handle_logging'):
self.handle_logging(request, *args, **kwargs)
serializer = DeptTreeSerializer(queryset, many=True)
return SuccessResponse(serializer.data)
def profile(self, request: Request, *args, **kwargs):
"""
获取用户个人信息
:param request:
:param args:
:param kwargs:
:return:
"""
instance = self.queryset.get(id=request.user.id)
serializer = self.get_serializer(instance)
if hasattr(self, 'handle_logging'):
self.handle_logging(request, instance=instance, *args, **kwargs)
return SuccessResponse(serializer.data)
def change_status(self, request: Request, *args, **kwargs):
"""
修改用户状态
:param request:
:param args:
:param kwargs:
:return:
"""
instance = self.queryset.get(id=request.data.get('userId'))
instance.is_active = request.data.get('status')
instance.save()
serializer = self.get_serializer(instance)
if hasattr(self, 'handle_logging'):
self.handle_logging(request, instance=instance, *args, **kwargs)
return SuccessResponse(serializer.data)
def reset_pwd(self, request: Request, *args, **kwargs):
"""
重置密码
:param request:
:param args:
:param kwargs:
:return:
"""
instance = self.queryset.get(id=request.data.get('userId'))
serializer = self.get_serializer(instance)
instance.set_password(request.data.get('password'))
instance.save()
if hasattr(self, 'handle_logging'):
self.handle_logging(request, instance=instance, *args, **kwargs)
return SuccessResponse(serializer.data)
def get(self, request, format=None):
user_dict = UserProfileSerializer(request.user).data
permissions_list = [
'*:*:*'
] if user_dict.get('admin') else Menu.objects.filter(
role__userprofile=request.user).values_list('perms', flat=True)
delete_cache = request.user.delete_cache
return SuccessResponse({
'permissions': [ele for ele in permissions_list if ele],
'roles':
Role.objects.filter(userprofile=request.user).values_list(
'roleKey', flat=True),
'user':
user_dict
})
def put_avatar(self, request: Request, *args, **kwargs):
"""
更新用户头像
:param request:
:param args:
:param kwargs:
:return:
"""
instance = self.queryset.get(id=request.user.id)
instance.avatar = request.data.get('avatar_url', None)
instance.save()
serializer = self.get_serializer(instance)
if hasattr(self, 'handle_logging'):
self.handle_logging(request, instance=instance, *args, **kwargs)
return SuccessResponse(serializer.data)
def exclude_list(self, request: Request, *args, **kwargs):
"""
过滤剔除同级部门
:param request:
:param args:
:param kwargs:
:return:
"""
dept_queryset = Dept.objects.filter(id=kwargs.get('pk')).first()
parentId = dept_queryset.parentId if dept_queryset else ''
queryset = self.queryset.exclude(
parentId=parentId).order_by('orderNum')
if hasattr(self, 'handle_logging'):
self.handle_logging(request, *args, **kwargs)
serializer = self.get_serializer(queryset, many=True)
return SuccessResponse(serializer.data)
def get_config_key(self, request: Request, *args, **kwargs):
"""
根据 参数键名 查询参数数据信息
:param request:
:param args:
:param kwargs:
:return:
"""
config_key_dic = cache.get('system_configKey') if getattr(settings, "REDIS_ENABLE", False) else ""
if not config_key_dic:
queryset = self.filter_queryset(self.get_queryset())
config_key_dic = {ele.get('configKey'): ele.get('configValue') for ele in
queryset.values('configValue', 'configKey')}
if getattr(settings, "REDIS_ENABLE", False):
cache.set('system_configKey', config_key_dic, 84600)
return SuccessResponse(msg=config_key_dic.get(kwargs.get('pk'), ''))
def get_monitor_info():
"""
定时获取系统监控信息
:return:
"""
# 获取服务器
ip = getIP()
if not ip:
logger.error("无法获取到IP")
return
server_obj, create = Server.objects.get_or_create(ip=ip)
if create:
server_obj.name = ip
terse = ('terse' in sys.argv or '--terse' in sys.argv)
aliased = (not 'nonaliased' in sys.argv
and not '--nonaliased' in sys.argv)
server_obj.os = platform(aliased, terse)
server_obj.save()
# 获取CPU和内存信息
mem = psutil.virtual_memory()
monitor_obj = Monitor()
monitor_obj.cpu_num = psutil.cpu_count()
monitor_obj.cpu_sys = float(psutil.cpu_percent(0.1))
monitor_obj.mem_num = int(mem.total / 1024)
monitor_obj.mem_sys = int(mem.used / 1024)
monitor_obj.seconds = time.strftime(
"%d天 %H 小时 %M 分 %S 秒",
time.gmtime(int(time.time()) - int(psutil.boot_time())))
monitor_obj.server = server_obj
monitor_obj.save()
# 保存磁盘信息
for ele in psutil.disk_partitions():
disk = psutil.disk_usage('/')
sys_files_obj = SysFiles()
sys_files_obj.dir_name = ele.mountpoint
sys_files_obj.sys_type_name = ele.opts
sys_files_obj.type_name = ele.fstype
sys_files_obj.total = disk.total
sys_files_obj.disk_sys = disk.used
sys_files_obj.monitor = monitor_obj
sys_files_obj.save()
return SuccessResponse(msg="")
def put_profile(self, request: Request, *args, **kwargs):
"""
更新用户个人信息
:param request:
:param args:
:param kwargs:
:return:
"""
instance = self.queryset.get(id=request.user.id)
instance.name = request.data.get('name', None)
instance.mobile = request.data.get('mobile', None)
instance.email = request.data.get('email', None)
instance.gender = request.data.get('gender', None)
instance.save()
serializer = self.get_serializer(instance)
if hasattr(self, 'handle_logging'):
self.handle_logging(request, instance=instance, *args, **kwargs)
return SuccessResponse(serializer.data)
def role_dept_tree_select(self, request: Request, *args, **kwargs):
"""
根据角色ID查询部门树结构
:param request:
:param args:
:param kwargs:
:return:
"""
dept_queryset = Dept.objects.filter(
role__id=kwargs.get('pk')).values_list('id', flat=True)
queryset = self.filter_queryset(self.get_queryset())
if hasattr(self, 'handle_logging'):
self.handle_logging(request, *args, **kwargs)
serializer = DeptTreeSerializer(queryset, many=True)
return SuccessResponse({
'depts': serializer.data,
'checkedKeys': dept_queryset
})
def update_pwd(self, request: Request, *args, **kwargs):
"""
个人修改密码
:param request:
:param args:
:param kwargs:
:return:
"""
instance = self.queryset.get(id=request.user.id)
instance.password = request.data.get('newPassword', None)
if not authenticate(username=request.user.username,
password=request.data.get('oldPassword', None)):
return ErrorResponse(msg='旧密码不正确！')
instance.set_password(request.data.get('newPassword'))
instance.save()
serializer = self.get_serializer(instance)
if hasattr(self, 'handle_logging'):
self.handle_logging(request, instance=instance, *args, **kwargs)
return SuccessResponse(serializer.data)
def clearsavefile(self, request: Request, *args, **kwargs):
"""
清理废弃文件
:param request:
:param args:
:param kwargs:
:return:
"""
# 获取废弃文件列表
file_list = get_all_files(os.path.join(settings.MEDIA_ROOT, 'system'))
queryset_files = [os.path.join(os.path.join(settings.MEDIA_ROOT) + os.sep, ele) for ele in
list(self.get_queryset().values_list('file', flat=True))]
queryset_files_dir = set(map(lambda absdir: os.path.abspath(absdir), queryset_files))
delete_list = list(set(file_list) - queryset_files_dir)
# 进行文件删除操作
delete_files(delete_list)
# 递归删除空文件
remove_empty_dir(os.path.join(settings.MEDIA_ROOT, 'system'))
return SuccessResponse(msg=f"成功清理废弃文件{len(delete_list)}个")
def get(self, request, format=None):
kwargs = {}
if not request.user.is_superuser:
kwargs['role__userprofile'] = request.user
menus = Menu.objects.filter(**kwargs) \
.exclude(menuType='2').values('id', 'name', 'web_path', 'visible', 'status', 'isFrame', 'component_path',
'icon', 'parentId', 'orderNum', 'isCache').distinct()
data = []
sys_show_hide = DictDetails.get_default_dictValue('sys_show_hide')
for ele in menus:
data.append({
'id':
ele.get('id'),
'name':
ele.get('web_path', '').split('/')[-1]
and ele.get('web_path', '').split('/')[-1].capitalize(),
'path':
ele.get('web_path'),
'orderNum':
ele.get('orderNum'),
'hidden':
True if ele.get('visible') != '1' else False,
'redirect':
ele.get('web_path')
if ele.get('isFrame') == '1' else 'noRedirect',
'component':
ele.get('component_path') or 'Layout',
'meta': {
'title':
ele.get('name'),
'icon':
ele.get('icon'),
'noCache':
True if ele.get('isCache') == sys_show_hide else False
},
'parentId':
ele.get('parentId')
})
return SuccessResponse(data)
def dict_details_list(self, request: Request, *args, **kwargs):
"""
根据字典类型查询字典数据信息
:param request:
:param args:
:param kwargs:
:return:
"""
dict_details_dic = cache.get('system_dict_details', {}) if getattr(settings, "REDIS_ENABLE", False) else {}
if not dict_details_dic:
queryset = self.filter_queryset(self.get_queryset())
queryset_dic = queryset.order_by('sort').values('dict_data__dictType', 'dictLabel', 'dictValue',
'is_default')
for ele in queryset_dic:
dictType = ele.pop('dict_data__dictType')
if dictType in dict_details_dic:
dict_details_dic[dictType].append(ele)
else:
dict_details_dic[dictType] = [ele]
if getattr(settings, "REDIS_ENABLE", False):
cache.set('system_dict_details', dict_details_dic, 84600)
return SuccessResponse(dict_details_dic.get(kwargs.get('pk'), []))
def create(self, request: Request, *args, **kwargs):
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
self.perform_create(serializer)
headers = self.get_success_headers(serializer.data)
return SuccessResponse(serializer.data, status=201, headers=headers)
def enabled_monitor_info(self, request: Request, *args, **kwargs):
"""
更新和获取监控信息
:param request:
:param args:
:param kwargs:
:return:
"""
enabled = request.query_params.get('enabled', None)
save_days = request.query_params.get('save_days', None)
interval = request.query_params.get('interval', None)
# 定时获取系统监控信息
periodictask_obj = PeriodicTask.objects.filter(
task='apps.vadmin.monitor.tasks.get_monitor_info').first()
if not periodictask_obj:
intervalschedule_obj, _ = IntervalSchedule.objects.get_or_create(
every=5, period="seconds")
periodictask_obj = PeriodicTask()
periodictask_obj.task = "apps.vadmin.monitor.tasks.get_monitor_info"
periodictask_obj.name = "定时获取系统监控信息"
periodictask_obj.interval = intervalschedule_obj
periodictask_obj.enabled = False
periodictask_obj.save()
# 定时清理多余 系统监控信息
clean_task_obj = PeriodicTask.objects.filter(
task='apps.vadmin.monitor.tasks.clean_surplus_monitor_info').first(
)
if not clean_task_obj:
crontab_obj, _ = CrontabSchedule.objects.get_or_create(
day_of_month="*",
day_of_week="*",
hour="1",
minute="0",
month_of_year="*")
clean_task_obj = PeriodicTask()
clean_task_obj.task = "apps.vadmin.monitor.tasks.clean_surplus_monitor_info"
clean_task_obj.name = "定时清理多余-系统监控信息"
clean_task_obj.crontab = crontab_obj
clean_task_obj.enabled = True
clean_task_obj.save()
# 配置添加
config_obj = ConfigSettings.objects.filter(
configKey='sys.monitor.info.save_days').first()
if not config_obj:
config_obj = ConfigSettings()
config_obj.configKey = "sys.monitor.info.save_days"
config_obj.configName = "定时清理多余系统监控信息"
config_obj.configValue = "30"
config_obj.configType = "Y"
config_obj.status = "1"
config_obj.remark = "定时清理多余-系统监控信息，默认30天"
config_obj.save()
if enabled:
# 更新监控状态
periodictask_obj.enabled = True if enabled == "1" else False
periodictask_obj.save()
# 更新 定时清理多余 系统监控信息 状态
clean_task_obj.enabled = True if enabled == "1" else False
clean_task_obj.save()
# 更新保留天数
if save_days and config_obj:
config_obj.configValue = save_days
config_obj.save()
# 更新监控获取频率
if interval:
periodictask_obj.interval.every = interval
periodictask_obj.interval.save()
return SuccessResponse(
data={
"enabled": periodictask_obj.enabled,
"interval": periodictask_obj.interval.every,
"save_days": config_obj.configValue if config_obj else "30",
})
