def role_add_permission(request):
"""
角色增加权限
:param request:
:return:
"""
try:
request_data = common.print_header_data(request)
role_id = common.check_request_int_field(request_data, 'role_id')
if isinstance(role_id, Response):
return role_id
permission_id_list = common.check_request_list_or_dict_field(
request_data, 'permission_id_list')
if isinstance(permission_id_list, Response):
return permission_id_list
role_select = Group.objects.filter(id=role_id)
if role_select.exists():
if role_select[0].permissions.all():
role_select[0].permissions.clear()
for permission_id in permission_id_list:
role_select[0].permissions.add(permission_id)
return common.ui_message_response(200, '角色添加权限成功', 'success',
status.HTTP_200_OK)
else:
return common.ui_message_response(400, '角色不存在', '角色不存在')
except Exception:
traceback.print_exc()
return common.ui_message_response(
500, '服务器内部错误', '服务器内部错误', status.HTTP_500_INTERNAL_SERVER_ERROR)
def show_local_audit(request):
try:
request_data = common.print_header_data(request) # 获取请求数据
start_pos, end_pos, page_size = common.get_page_data(
request_data) # 获取页码数据
query_terms = get_local_audit_query_terms(request_data) # 构造查询参数
query_data = AuditManagement.objects.filter(**query_terms).order_by(
'-id')[start_pos:end_pos] # 过滤查询，若query_terms={}，相当于all
serializer_data = serialize('json',
query_data,
fields=('log_id', 'user', 'opt_type',
'event_type', 'message', 'time'))
list_data = json.loads(serializer_data)
show_data = []
for data in list_data:
fields = data['fields']
fields['time'] = fields['time'].replace('T',
' ') # 去除时间显示时多出的字符'T'
show_data.append(fields)
return common.ui_message_response(200, '查询成功', show_data,
status.HTTP_200_OK)
except Exception:
traceback.print_exc()
return common.ui_message_response(
500, '服务器内部错误', '服务器内部错误', status.HTTP_500_INTERNAL_SERVER_ERROR)
def group_query_permission(request):
"""
角色查询权限
:param request:
:return:
"""
try:
request_data = common.print_header_data(request)
role_id = common.check_request_int_field(request_data, 'role_id')
if isinstance(role_id, Response):
return role_id
result_list = []
role_select = Group.objects.filter(id=role_id)
for group in role_select:
query_result = group.permissions.all()
for permission in query_result:
if len(permission.codename.split('|')) > 1:
result_list.append(permission.id)
return common.ui_message_response(
200, '查询成功', {'permission_id_list': result_list},
status.HTTP_200_OK)
except Exception:
traceback.print_exc()
return common.ui_message_response(
500, '服务器内部错误', '服务器内部错误', status.HTTP_500_INTERNAL_SERVER_ERROR)
def user_logout(request):
"""
用户注销
:param request:
:return:
"""
# logout(request)
try:
request_data = common.print_header_data(request) # 获取请求数据
# 获取请求参数
login_id = request_data.get('username')
if login_id is not None:
common.generate_system_log(request_data, u'用户操作', u'注销操作',
login_id + u'注销成功')
return common.ui_message_response(200, '注销成功', '注销成功',
status.HTTP_200_OK)
else:
common.generate_system_log(request_data, u'用户操作', u'注销操作',
u'用户名未知')
return common.ui_message_response(400, '用户名参数为空', "用户名参数为空")
except Exception:
common.generate_system_log(request_data, u'用户操作', u'注销操作', u'注销模块出现异常')
traceback.print_exc()
return common.ui_message_response(
500, '服务器内部错误', '服务器内部错误', status.HTTP_500_INTERNAL_SERVER_ERROR)
def user_query_permission(request):
"""
用户查询权限
:param request:
:return:
"""
try:
request_data = common.print_header_data(request)
user_name = request_data.get('username')
# user_name = "admin"
user_select = User.objects.filter(username=user_name)
if user_select.exists():
result_list = []
groups = user_select[0].groups.all()
for group in groups:
query_result = group.permissions.all()
for permission in query_result:
if len(permission.codename.split('|')) > 1:
result_list.append(permission.id)
# result_list = list(user_select[0].get_all_permissions())
return common.ui_message_response(
200, '查询成功' + json.dumps(result_list),
{'permission_id_list': result_list}, status.HTTP_200_OK)
else:
return common.ui_message_response(400, '用户不存在', '用户不存在')
except Exception:
traceback.print_exc()
return common.ui_message_response(
500, '服务器内部错误', '服务器内部错误', status.HTTP_500_INTERNAL_SERVER_ERROR)
def role_query_all(request):
"""
查询所有角色的信息
:param request:
:return:
"""
try:
request_data = common.print_header_data(request)
result = {}
role_list = []
role_name = request_data.get('rolename')
request_data = common.print_header_data(request)
start_pos, end_pos, page_size = common.get_page_data(request_data)
if role_name is not None:
query_terms = {}
query_terms['name__contains'] = role_name
query_role = Group.objects.filter(**query_terms)
else:
query_role = Group.objects.all()
query_role = query_role.order_by('-id')
role_count = query_role.count()
for role in query_role:
role_dict = {}
role_dict['id'] = role.id
role_dict['name'] = role.name
role_list.append(role_dict)
result['query_role'] = role_list[start_pos:end_pos]
result['role_count'] = role_count
return common.ui_message_response(200, "查询成功: " + json.dumps(result),
result, status.HTTP_200_OK)
except Exception:
traceback.print_exc()
return common.ui_message_response(
500, '服务器内部错误', '服务器内部错误', status.HTTP_500_INTERNAL_SERVER_ERROR)
def change_user_info(request):
"""
修改用户信息
:param request:
:return:
"""
try:
request_data = common.print_header_data(request)
user_id = common.check_request_int_field(request_data, 'user_id')
if isinstance(request_data, Response):
return user_id
username = request_data.get('username')
role_id = common.check_request_list_or_dict_field(
request_data, 'role_id')
if isinstance(role_id, Response):
return role_id
if username:
User.objects.filter(id=user_id).update(username=username)
user_query = User.objects.filter(id=user_id)
if user_query.exists():
if user_query[0].groups.all():
user_query[0].groups.clear()
group_select = Group.objects.filter(id__in=role_id)
for group in group_select:
user_query[0].groups.add(group)
else:
return common.ui_message_response(400, '用户不存在', '用户不存在')
return common.ui_message_response(200, '用户信息修改成功', '用户信息修改成功',
status.HTTP_200_OK)
except Exception:
traceback.print_exc()
return common.ui_message_response(
500, '服务器内部错误', '服务器内部错误', status.HTTP_500_INTERNAL_SERVER_ERROR)
def change_role_info(request):
"""
修改角色信息
:param request:
:return:
"""
try:
request_data = common.print_header_data(request)
role_id = common.check_request_int_field(request_data, 'role_id')
if isinstance(role_id, Response):
return role_id
role_name = request_data.get('rolename')
if role_name is not None:
if not Group.objects.filter(id=role_id).exists():
return common.ui_message_response(400, '该角色不存在', "该角色不存在")
query_data = Group.objects.filter(name=role_name)
if query_data.exists():
return common.ui_message_response(400, '角色名已经被占用', "角色名已经被占用")
else:
Group.objects.filter(id=role_id).update(name=role_name)
return common.ui_message_response(200, '角色信息修改成功', '角色信息修改成功',
status.HTTP_200_OK)
return common.ui_message_response(400, '请求中没有rolename参数',
'请求中没有rolename参数')
except Exception:
traceback.print_exc()
return common.ui_message_response(
500, '角色信息修改失败', '角色信息修改失败', status.HTTP_500_INTERNAL_SERVER_ERROR)
def send_management_info(request):
try:
center_info = ManagementCenterInfo.objects.all()
if not center_info.exists():
return common.ui_message_response(400, '管理系统信息不存在', '管理系统信息不存在')
data = serialize('json', center_info,
fields=('center_id', 'soft_version', 'device_ca', 'organs', 'address', 'address_code',
'contact', 'mem_total', 'interface', 'cpu_info', 'disk_info', 'access_time')
) # 序列化
list_data = json.loads(data)
fields = list_data[0]['fields']
fields['cpu_info'] = json.loads(fields['cpu_info'])
fields['disk_info'] = json.loads(fields['disk_info'])
fields['interface'] = json.loads(fields['interface'])
fields['contact'] = json.loads(fields['contact'])
print "management_center_info:", pu.pretty_print_format(fields)
if config.const.UPLOAD_DIRECTOR and check_global_director_connection():
command_data = json.dumps(fields, ensure_ascii=False).encode('utf-8')
common_header = ccd.get_common_command_header_of_center('CENTER_STATUS', 'CENTER_STATUS_INFO')
ccd.upload_json_2_director_of_center(common_header, 'CENTER_STATUS_INFO', command_data, rule_id='0',
async_level=0)
return common.ui_message_response(200, '发送管理中心信息成功', {}, status.HTTP_200_OK)
except Exception:
traceback.print_exc()
return common.ui_message_response(500, '服务器内部错误', '服务器内部错误',
status.HTTP_500_INTERNAL_SERVER_ERROR)
def reset_user_password(request):
"""
重置用户密码
:param request:
:return:
"""
try:
request_data = common.print_header_data(request)
user_data = lc.trans_user_change_password(request_data)
user = User.objects.get(id=user_data['id'])
username = user.username
if user is not None:
user.set_password(str(su.get_md5('123456')).upper())
user.save()
User.objects.filter(username=username).update(
last_update_time=du.get_current_time())
common.generate_system_log(request_data, u' 用户操作', u'重置密码操作',
username + u'重置密码成功')
return common.ui_message_response(200, '修改密码成功', "success",
status.HTTP_200_OK)
else:
common.generate_system_log(request_data, u' 用户操作', u'重置密码操作',
username + u'重置密码失败')
return common.ui_message_response(400, '用户不存在', '用户不存在')
except Exception:
traceback.print_exc()
return common.ui_message_response(
500, '服务器内部错误', '服务器内部错误', status.HTTP_500_INTERNAL_SERVER_ERROR)
def send_running_status(request, retract=0):
import psutil
try:
time.sleep(1)
cpu_usage = int(psutil.cpu_percent(interval=1))
psutil.cpu_stats()
mem_usage = int(psutil.virtual_memory().percent)
disk_usage = int(psutil.disk_usage('/').free / 1024 / 1024 / 1024) # 单位GB
command_data = json.dumps({
'mem': mem_usage,
'cpu': cpu_usage,
'disk': disk_usage,
'time': time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
}, ensure_ascii=False).encode('utf-8')
print command_data
if config.const.UPLOAD_DIRECTOR and check_global_director_connection():
common_header = ccd.get_common_command_header_of_center('CENTER_STATUS', 'CENTER_STATUS_SYSTEM')
ccd.upload_json_2_director_of_center(common_header, 'CENTER_STATUS', command_data, rule_id='0',
async_level=1)
return common.ui_message_response(200, '发送管理中心状态成功', {}, status.HTTP_200_OK)
except Exception:
traceback.print_exc()
return common.ui_message_response(500, '服务器内部错误', '服务器内部错误',
status.HTTP_500_INTERNAL_SERVER_ERROR)
def send_audit(request, retract=0):
try:
if config.const.UPLOAD_DIRECTOR and check_global_director_connection():
query_data = AuditManagement.objects.filter(is_send_command=0)
if not query_data.exists():
return common.ui_message_response(400, '不存在可发送的审计信息', '不存在可发送的审计信息')
serializer_data = serialize('json', query_data,
fields=('log_id', 'user', 'opt_type', 'event_type',
'message', 'time')
)
list_data = json.loads(serializer_data)
command_data = []
for data in list_data:
fields = data['fields']
fields['id'] = fields.pop('log_id')
fields['time'] = fields['time'].replace('T', ' ') # 去除时间显示时多出的字符'T'
command_data.append(fields)
common_header = ccd.get_common_command_header_of_center('AUDIT', 'CENTER_AUDIT')
command_data = json.dumps(command_data, ensure_ascii=False).encode('utf-8')
ccd.upload_json_2_director_of_center(common_header, 'CENTER_AUDIT', command_data, async_level=3)
# 修改为已发送
update_id_list = [d['pk'] for d in list_data]
AuditManagement.objects.filter(id__in=update_id_list).update(is_send_command=1)
return common.ui_message_response(200, '发送管理中心审计日志成功', {}, status.HTTP_200_OK)
except Exception:
traceback.print_exc()
return common.ui_message_response(500, '服务器内部错误', '服务器内部错误',
status.HTTP_500_INTERNAL_SERVER_ERROR)
def user_change_password(request):
"""
修改用户密码
:param request:
:return:
"""
try:
request_data = common.print_header_data(request)
user_data = lc.trans_user_change_password(request_data)
print user_data
username = user_data['username']
user = auth.authenticate(**{
'username': username,
'password': user_data['old_password']
})
if user is not None:
user.set_password(user_data['new_password'])
user.save()
User.objects.filter(username=username).update(
last_update_time=du.get_current_time())
common.generate_system_log(request_data, u' 用户操作', u'修改密码操作',
username + u'修改密码成功')
return common.ui_message_response(200, '修改密码成功', "success",
status.HTTP_200_OK)
else:
common.generate_system_log(request_data, u' 用户操作', u'修改密码操作',
username + u'修改密码失败')
return common.ui_message_response(400, '原密码输入错误', '原密码输入错误')
except Exception:
traceback.print_exc()
return common.ui_message_response(
500, '服务器内部错误', '服务器内部错误', status.HTTP_500_INTERNAL_SERVER_ERROR)
def show_audit_log(request):
try:
request_data = common.print_header_data(request) # 获取请求数据
start_pos, end_pos, page_size = common.get_page_data(request_data) # 获取页码数据
query_terms = get_audit_log_query_terms(request_data) # 构造查询参数
query_data = AuditLog.objects.filter(**query_terms).order_by('-id')[
start_pos:end_pos] # 过滤查询，若query_terms={}，相当于all
serializer_data = serialize('json', query_data,
fields=('device_id', 'log_type', 'filename', 'time',
'receive_time', 'save_path'))
list_data = json.loads(serializer_data)
show_data = []
for data in list_data:
fields = data['fields']
fields['time'] = fields['time'].replace('T', ' ') # 去除时间显示时多出的字符'T'
fields['receive_time'] = fields['receive_time'].replace('T', ' ') # 去除时间显示时多出的字符'T'
fields['file_name'] = fields.pop('filename')
fields['file_path'] = common.MEDIA_ROOT + fields.pop('save_path')
show_data.append(fields)
return common.ui_message_response(200, '查询成功', show_data, status.HTTP_200_OK)
except Exception:
traceback.print_exc()
return common.ui_message_response(500, '服务器内部错误', '服务器内部错误',
status.HTTP_500_INTERNAL_SERVER_ERROR)
def check_ui_upload_cmd_validity(cmd, plug_id, plug_cmd, cmd_type_list):
"""
检查UI下发插件相关操作和命令的数据合法性，主要包括cmd，plug_id
:param cmd: 在cmd_type_list中插件操作或命令对应的索引
:param plug_id: 上传的插件ID
:param plug_cmd: 入库的插件信息字典
:param cmd_type_list: 插件操作或命令对应的类型
:return: plug_cmd
"""
if cmd is None:
return common.ui_message_response(400, '没有cmd参数', '没有cmd参数')
else:
try:
cmd = int(cmd)
plug_cmd['cmd'] = cmd_type_list[cmd - 1]
except Exception:
return common.ui_message_response(400, '参数cmd不是数字', '参数cmd不符合要求')
if plug_id is None:
return common.ui_message_response(400, '没有plug_id参数', '没有plug_id参数')
else:
try:
plug_cmd['plug_id'] = int(plug_id)
except Exception:
return common.ui_message_response(400, '参数plug_id不是数字',
'参数plug_id不符合要求')
def send_detector_info(request, retract=0):
try:
if config.const.DIRECTOR_VERSION and check_global_director_connection(
):
detector_info = Detector.objects.filter(device_status=1,
is_effective=1)
if not detector_info.exists():
return common.ui_message_response(400, '不存在可上报至指挥中心的检测器',
'不存在可上报至指挥中心的检测器')
data = serialize('json',
detector_info,
fields=('device_id', 'soft_version', 'organs',
'address', 'address_code', 'contact',
'mem_total', 'interface', 'cpu_info',
'disk_info', 'register_time',
'auth_time')) # 序列化
list_data = json.loads(data)
command_data = []
for info in list_data:
fields = info['fields']
if fields['register_time'] is not None:
fields['register_time'] = fields['register_time'].replace(
'T', ' ')
else:
fields['register_time'] = '0000-00-00 00:00:00'
if fields['auth_time'] is not None:
fields['access_time'] = fields.pop('auth_time').replace(
'T', ' ')
else:
fields['access_time'] = '0000-00-00 00:00:00'
fields['cpu_info'] = json.loads(fields['cpu_info'])
fields['disk_info'] = json.loads(fields['disk_info'])
fields['interface'] = json.loads(fields['interface'])
fields['contact'] = json.loads(fields['contact'])
command_data.append(fields)
# print "detector_data:", pu.pretty_print_format(command_data)
command_data = json.dumps(command_data,
ensure_ascii=False).encode('utf-8')
common_header = ccd.get_common_command_header_of_center(
'JCQ_STATUS', 'JCQ_STATUS_INFO')
ccd.upload_json_2_director_of_center(common_header,
'JCQ_STATUS_INFO',
command_data,
rule_id='0',
async_level=0)
return common.ui_message_response(200, '发送检测器信息成功', {},
status.HTTP_200_OK)
except Exception:
traceback.print_exc()
return common.ui_message_response(
500, '服务器内部错误', '服务器内部错误', status.HTTP_500_INTERNAL_SERVER_ERROR)
def user_login(request):
"""
登录校验
:param request:
:return:
"""
try:
result = {}
user_data = {}
role_result = {}
request_data = common.print_header_data(request)
username = request_data.get('username')
# user_data['username'] = '******'
# username = '******'
user_data['username'] = username
password = request_data.get('password')
# user_data['password'] = str(su.get_md5('123456')).upper()
# password = str(su.get_md5('123456')).upper()
user_data['password'] = password
if User.objects.filter(username=username):
user = auth.authenticate(**user_data)
if user:
# django.contrib.auth.login(request, user)
result['username'] = user_data['username']
user_query = User.objects.filter(username=result['username'])
user_query.update(last_login=du.get_current_time())
group_query = user_query[0].groups.all()
for group in group_query:
permission_id_list = []
permission_query = group.permissions.all()
for permission in permission_query:
permission_id_list.append(permission.id)
role_result[group.name] = permission_id_list
result['role'] = role_result
common.generate_system_log(request_data, u'用户操作', u'登录操作',
username + u'登录成功')
result['flag'] = "success"
print "login result:", result
return common.ui_message_response(200, '登录成功', result,
status.HTTP_200_OK)
else:
common.generate_system_log(request_data, u'用户操作', u'登录操作',
username + u'密码错误')
return common.ui_message_response(400, '密码错误', '密码错误')
else:
common.generate_system_log(request_data, u'用户操作', u'登录操作',
u'用户名不存在')
return common.ui_message_response(400, '用户名不存在', '用户名不存在')
except Exception:
traceback.print_exc()
common.generate_system_log(request_data, u'用户操作', u'登录操作', u'登录模块出现异常')
return common.ui_message_response(
500, '服务器内部错误', '服务器内部错误', status.HTTP_500_INTERNAL_SERVER_ERROR)
def show_local_audit_count(request):
try:
request_data = common.print_header_data(request) # 获取请求数据
query_terms = get_local_audit_query_terms(request_data) # 构造查询参数
count = AuditManagement.objects.filter(**query_terms).count() # 数据条数
show_data = {'count': count}
return common.ui_message_response(200, '查询成功', show_data, status.HTTP_200_OK)
except Exception:
traceback.print_exc()
return common.ui_message_response(500, '服务器内部错误', '服务器内部错误',
status.HTTP_500_INTERNAL_SERVER_ERROR)
def query_all_permissions(request):
"""
查询全部权限
:param request:
:return:
"""
try:
result = {}
content_type_id_list = []
result_list = []
query_result_list = {}
query_result = Permission.objects.all()
for permission in query_result:
content_type_id_list.append(permission.content_type_id)
content_type_id_list = list(set(content_type_id_list))
for content_type_id in content_type_id_list:
query_result = Permission.objects.filter(
content_type_id=content_type_id)
query_result_list_button = []
for permission in query_result:
query_result_dict_button = {}
query_result_dict_menu = {}
codename_list = permission.codename.split('|')
if codename_list[-1] == 'menu':
query_result_dict_menu['id'] = permission.id
query_result_dict_menu['name'] = permission.name
query_result_dict_menu[
'content_type_id'] = permission.content_type_id
query_result_list['menu'] = query_result_dict_menu
elif codename_list[-1] == 'button':
query_result_dict_button['id'] = permission.id
query_result_dict_button['name'] = permission.name
query_result_dict_button[
'content_type_id'] = permission.content_type_id
query_result_list_button.append(query_result_dict_button)
else:
query_result_list_button = []
query_result_list = {}
if query_result_list_button:
query_result_list['button'] = query_result_list_button
if query_result_list:
ss = json.loads(json.dumps(query_result_list))
result_list.append(ss)
result['all_permissions'] = result_list
return common.ui_message_response(200, '查询成功', result,
status.HTTP_200_OK)
except Exception:
traceback.print_exc()
return common.ui_message_response(
500, '服务器内部错误', '服务器内部错误', status.HTTP_500_INTERNAL_SERVER_ERROR)
def get_role_number(request):
"""
获取角色数量
:param request:
:return:
"""
try:
result = {}
query_result = Group.objects.all()
role_count = query_result.count()
result['role_count'] = role_count
return common.ui_message_response(200, '查询成功', result,
status.HTTP_200_OK)
except Exception:
traceback.print_exc()
return common.ui_message_response(
500, '服务器内部错误', '服务器内部错误', status.HTTP_500_INTERNAL_SERVER_ERROR)
def role_remove_all_user(request):
"""
角色删除所有用户
:param request:
:return:
"""
try:
request_data = common.print_header_data(request)
role_name = request_data.get('role_name')
group_select = Group.objects.filter(name=role_name)
for group in group_select:
group.user_set.clear()
return common.ui_message_response(200, '删除成功', '删除成功',
status.HTTP_200_OK)
except Exception:
traceback.print_exc()
return common.ui_message_response(
500, '服务器内部错误', '服务器内部错误', status.HTTP_500_INTERNAL_SERVER_ERROR)
def user_remove_all(request):
"""
用户退出所有角色
:param request:
:return:
"""
try:
# username = request.get('username')
username = "******"
user_select = User.objects.filter(username=username)
for user in user_select:
user.groups.clear()
return common.ui_message_response(200, '给用户' + username + "清空角色成功",
'success', status.HTTP_200_OK)
except Exception:
traceback.print_exc()
return common.ui_message_response(
500, '服务器内部错误', '服务器内部错误', status.HTTP_500_INTERNAL_SERVER_ERROR)
def user_registration(request):
"""
注册用户信息，创建用户名和密码,auth模块不存储用户密码明文而是存储一个Hash值, 比如迭代使用Md5算法.
:param request:
:return:
"""
try:
request_data = common.print_header_data(request)
user_data = lc.trans_user_registration_info(request_data)
if 'password' not in user_data:
user_data['password'] = str(su.get_md5('123456')).upper()
user_name = user_data['username']
if 'role_id' in user_data:
role_id = user_data['role_id']
del user_data['role_id']
else:
role_id = 3 # 默认角色
user_data['is_active'] = '1'
user_data['is_staff'] = '1'
print "user_data:", user_data
if user_data:
query_data = User.objects.filter(username=user_name)
if query_data.exists():
common.generate_system_log(request_data, u'用户操作', u'注册操作',
user_name + u'注册失败，用户名被占用')
return common.ui_message_response(400, '用户名已经被占用', "用户名已经被占用")
else:
user = User.objects.create_user(**user_data)
user.save()
if role_id:
group_select = Group.objects.filter(id=role_id)
for group in group_select:
user.groups.add(group)
common.generate_system_log(request_data, u'用户操作', u'注册操作',
user_name + u'注册成功')
return common.ui_message_response(200, '用户注册成功', "success",
status.HTTP_200_OK)
except Exception:
traceback.print_exc()
common.generate_system_log(request_data, u' 用户操作', u'注册操作',
user_name + u'注册失败，注册出现错误')
return common.ui_message_response(
500, '服务器内部错误', '服务器内部错误', status.HTTP_500_INTERNAL_SERVER_ERROR)
def get_user_number(request):
"""
获取用户数量
:param request:
:return:
"""
try:
result = {}
query_terms = {}
request_data = common.print_header_data(request)
query_result = User.objects.filter(**query_terms)
user_count = query_result.count()
result['user_count'] = user_count
return common.ui_message_response(200, '查询成功', result,
status.HTTP_200_OK)
except Exception:
traceback.print_exc()
return common.ui_message_response(
500, '服务器内部错误', '服务器内部错误', status.HTTP_500_INTERNAL_SERVER_ERROR)
def delete_role(request):
"""
删除角色
:param request:
:return:
"""
try:
request_data = common.print_header_data(request)
role_id_list = common.check_request_list_or_dict_field(
request_data, 'role_id_list')
if isinstance(role_id_list, Response):
return role_id_list
for role_id in role_id_list:
user_query = Group.objects.filter(id=role_id)
for role in user_query:
role.delete()
return common.ui_message_response(200, '角色删除成功', "success",
status.HTTP_200_OK)
except Exception:
traceback.print_exc()
return common.ui_message_response(
500, '服务器内部错误', '服务器内部错误', status.HTTP_500_INTERNAL_SERVER_ERROR)
def user_to_role(request):
"""
用户选择角色
:param request:
:return:
"""
try:
# username = request.get('username')
# role_name = request.get('rolename')
username = "******"
role_name = "系统管理员"
user_select = User.objects.filter(username=username)
for user in user_select:
group_select = Group.objects.filter(name=role_name)
for group in group_select:
user.groups.add(group)
return common.ui_message_response(
200, '给用户' + username + "设置角色" + role_name + "成功", 'success',
status.HTTP_200_OK)
except Exception:
traceback.print_exc()
return common.ui_message_response(
500, '服务器内部错误', '服务器内部错误', status.HTTP_500_INTERNAL_SERVER_ERROR)
def is_pwd_expire(request):
try:
request_data = common.print_header_data(request) # 获取请求数据
# 获取请求参数
login_id = request_data.get('username') # 用户id
if login_id is not None:
query_data = User.objects.filter(username=login_id)
now_time = du.get_current_time()
if now_time - query_data[0].last_update_time >= common.EXPIRE_TIME:
# is_expire = 1
is_expire = 0
else:
is_expire = 0
return common.ui_message_response(
200, '过期' if is_expire == 1 else '未过期', is_expire,
status.HTTP_200_OK)
else:
return common.ui_message_response(400, '没有username参数', "参数为空")
except Exception:
traceback.print_exc()
return common.ui_message_response(
500, '服务器内部错误', '服务器内部错误', status.HTTP_500_INTERNAL_SERVER_ERROR)
def create_role(request):
"""
创建角色
:param request:
:return:
"""
try:
request_data = common.print_header_data(request)
role_name = request_data.get('rolename')
print role_name
if role_name is not None:
query_data = Group.objects.filter(name=role_name)
if query_data.exists():
return common.ui_message_response(400, '角色名已经被占用', "角色名已经被占用")
else:
group = Group.objects.create(name=role_name)
group.save()
return common.ui_message_response(200, '角色创建成功', "success",
status.HTTP_200_OK)
except Exception:
traceback.print_exc()
return common.ui_message_response(
500, '服务器内部错误', '服务器内部错误', status.HTTP_500_INTERNAL_SERVER_ERROR)
def user_remove_role(request):
"""
用户退出角色选择
:param request:
:return:
"""
try:
# username = request.get('username')
# role_name = request.get('rolename')
username = "******"
role_name = "AverageUser"
user_select = User.objects.filter(username=username)
for user in user_select:
group_select = Group.objects.filter(name=role_name)
for group in group_select:
user.groups.remove(group)
return common.ui_message_response(
200, '给用户' + username + "删除角色" + role_name + "成功", 'success',
status.HTTP_200_OK)
except Exception:
traceback.print_exc()
return common.ui_message_response(
500, '服务器内部错误', '服务器内部错误', status.HTTP_500_INTERNAL_SERVER_ERROR)
def delete_user(request):
"""
根据用户id删除用户信息
:param request:
:return:
"""
try:
request_data = common.print_header_data(request)
user_id_list = common.check_request_list_or_dict_field(
request_data, 'user_id_list')
if isinstance(user_id_list, Response):
return user_id_list
for user_id in user_id_list:
user_query = User.objects.filter(id=user_id)
for user in user_query:
user.groups.clear()
user.delete()
return common.ui_message_response(200, '用户删除成功', 'success',
status.HTTP_200_OK)
except Exception:
traceback.print_exc()
return common.ui_message_response(
500, '用户删除失败', '用户删除失败', status.HTTP_500_INTERNAL_SERVER_ERROR)
