def sqlworkflow_list(request):
limit = int(request.POST.get('limit'))
offset = int(request.POST.get('offset'))
limit = offset + limit
search = request.POST.get('search', '')
# 获取筛选参数
navStatus = request.POST.get('navStatus')
# 管理员可以看到全部工单，其他人能看到自己提交和审核的工单
user = request.user
# 全部工单里面包含搜索条件
if navStatus == 'all':
if user.is_superuser:
workflow_list = SqlWorkflow.objects.filter(
Q(engineer_display__contains=search) | Q(workflow_name__contains=search)).order_by('-create_time')
elif user.has_perm('sql.sql_review') or user.has_perm('sql.sql_execute'):
# 先获取用户所在资源组列表
group_list = user_groups(user)
group_ids = [group.group_id for group in group_list]
workflow_list = SqlWorkflow.objects.filter(group_id__in=group_ids).filter(
Q(engineer_display__contains=search) | Q(workflow_name__contains=search)).order_by('-create_time')
else:
workflow_list = SqlWorkflow.objects.filter(engineer=user.username).filter(
workflow_name__contains=search).order_by('-create_time')
else:
if user.is_superuser:
workflow_list = SqlWorkflow.objects.filter(
status=navStatus
).order_by('-create_time')
elif user.has_perm('sql.sql_review') or user.has_perm('sql.sql_execute'):
# 先获取用户所在资源组列表
group_list = user_groups(user)
group_ids = [group.group_id for group in group_list]
workflow_list = SqlWorkflow.objects.filter(status=navStatus,
group_id__in=group_ids).order_by('-create_time')
else:
workflow_list = SqlWorkflow.objects.filter(status=navStatus, engineer=user.username
).order_by('-create_time')
count = workflow_list.count()
workflow = workflow_list[offset:limit].values("id", "workflow_name", "engineer_display", "status",
"is_backup", "create_time", "instance_name", "db_name",
"group_name", "sql_syntax")
# QuerySet 序列化
rows = [row for row in workflow]
result = {"total": count, "rows": rows}
# 返回查询结果
return HttpResponse(json.dumps(result, cls=ExtendJSONEncoder, bigint_as_string=True),
content_type='application/json')
def can_timingtask(user, workflow_id):
"""
判断用户当前是否可定时执行，两种情况下用户有定时执行权限
1.登录用户有资源组粒度执行权限，并且为组内用户
2.当前登录用户为提交人，并且有执行权限
:param user:
:param workflow_id:
:return:
"""
workflow_detail = SqlWorkflow.objects.get(id=workflow_id)
result = False
# 只有审核通过和定时执行的数据才可以执行
if workflow_detail.status in [
'workflow_review_pass', 'workflow_timingtask'
]:
# 当前登录用户有资源组粒度执行权限，并且为组内用户
group_ids = [group.group_id for group in user_groups(user)]
if workflow_detail.group_id in group_ids and user.has_perm(
'sql.sql_execute_for_resource_group'):
result = True
# 当前登录用户为提交人，并且有执行权限
if workflow_detail.engineer == user.username and user.has_perm(
'sql.sql_execute'):
result = True
return result
def archive_list(request):
"""
获取归档申请列表
:param request:
:return:
"""
user = request.user
filter_instance_id = request.GET.get('filter_instance_id')
state = request.GET.get('state')
limit = int(request.GET.get('limit', 0))
offset = int(request.GET.get('offset', 0))
limit = offset + limit
search = request.GET.get('search', '')
# 组合筛选项
filter_dict = dict()
if filter_instance_id:
filter_dict['src_instance'] = filter_instance_id
if state == 'true':
filter_dict['state'] = True
elif state == 'false':
filter_dict['state'] = False
# 管理员可以看到全部数据
if user.is_superuser:
pass
# 拥有审核权限、可以查看组内所有工单
elif user.has_perm('sql.archive_review'):
# 先获取用户所在资源组列表
group_list = user_groups(user)
group_ids = [group.group_id for group in group_list]
filter_dict['resource_group__in'] = group_ids
# 其他人只能看到自己提交的工单
else:
filter_dict['user_name'] = user.username
# 过滤组合筛选项
archive_config = ArchiveConfig.objects.filter(**filter_dict)
# 过滤搜索项，支持模糊搜索标题、用户
if search:
archive_config = archive_config.filter(
Q(title__icontains=search) | Q(user_display__icontains=search))
count = archive_config.count()
lists = archive_config.order_by('-id')[offset:limit].values(
'id', 'title', 'src_instance__instance_name', 'src_db_name',
'src_table_name', 'dest_instance__instance_name', 'dest_db_name',
'dest_table_name', 'sleep', 'mode', 'no_delete', 'status', 'state',
'user_display', 'create_time', 'resource_group__group_name')
# QuerySet 序列化
rows = [row for row in lists]
result = {"total": count, "rows": rows}
# 返回查询结果
return HttpResponse(json.dumps(result,
cls=ExtendJSONEncoder,
bigint_as_string=True),
content_type='application/json')
def post(self, request):
# 参数验证
serializer = WorkflowAuditSerializer(data=request.data)
if not serializer.is_valid():
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
# 先获取用户所在资源组列表
user = Users.objects.get(username=request.data['engineer'])
group_list = user_groups(user)
group_ids = [group.group_id for group in group_list]
# 再获取用户所在权限组列表
if user.is_superuser:
auth_group_ids = [group.id for group in Group.objects.all()]
else:
auth_group_ids = [
group.id for group in Group.objects.filter(user=user)
]
self.queryset = self.queryset.filter(
current_status=WorkflowDict.workflow_status['audit_wait'],
group_id__in=group_ids,
current_audit__in=auth_group_ids)
audit = self.filter_queryset(self.queryset)
page_audit = self.paginate_queryset(queryset=audit)
serializer_obj = self.get_serializer(page_audit, many=True)
data = {'data': serializer_obj.data}
return self.get_paginated_response(data)
def submit_sql(request):
"""提交SQL的页面"""
user = request.user
# 获取组信息
group_list = user_groups(user)
# 获取所有有效用户，通知对象
active_user = Users.objects.filter(is_active=1)
# 获取系统配置
archer_config = SysConfig()
# 主动创建标签
InstanceTag.objects.get_or_create(tag_code='can_write',
defaults={
'tag_name': '支持上线',
'active': True
})
context = {
'active_user': active_user,
'group_list': group_list,
'enable_backup_switch': archer_config.get('enable_backup_switch')
}
return render(request, 'sqlsubmit.html', context)
def sqlworkflow(request):
"""SQL上线工单列表页面"""
user = request.user
# 过滤筛选项的数据
filter_dict = dict()
# 管理员，可查看所有工单
if user.is_superuser:
pass
# 非管理员，拥有审核权限、资源组粒度执行权限的，可以查看组内所有工单
elif user.has_perm('sql.sql_review') or user.has_perm('sql.sql_execute_for_resource_group'):
# 先获取用户所在资源组列表
group_list = user_groups(user)
group_ids = [group.group_id for group in group_list]
filter_dict['group_id__in'] = group_ids
# 其他人只能查看自己提交的工单
else:
filter_dict['engineer'] = user.username
instance_id = SqlWorkflow.objects.filter(**filter_dict).values('instance_id').distinct()
instance = Instance.objects.filter(pk__in=instance_id)
resource_group_id = SqlWorkflow.objects.filter(**filter_dict).values('group_id').distinct()
resource_group = ResourceGroup.objects.filter(group_id__in=resource_group_id)
return render(request, 'sqlworkflow.html',
{'status_list': SQL_WORKFLOW_CHOICES,
'instance': instance, 'resource_group': resource_group})
def queryapplylist(request):
user = request.user
# 获取资源组
group_list = user_groups(user)
context = {'group_list': group_list}
return render(request, 'queryapplylist.html', context)
def backupcheck(request):
"""备份检查页面"""
user = request.user
# 获取组信息
group_list = user_groups(user)
context = {'group_list': group_list}
return render(request, 'backupcheck.html', context)
def can_view(user, workflow_id):
"""
判断用户当前是否可以查看工单信息，和列表过滤逻辑保存一致
:param user:
:param workflow_id:
:return:
"""
workflow_detail = SqlWorkflow.objects.get(id=workflow_id)
result = False
# 管理员，可查看所有工单
if user.is_superuser:
result = True
# 非管理员，拥有审核权限、资源组粒度执行权限的，可以查看组内所有工单
elif user.has_perm('sql.sql_review') or user.has_perm(
'sql.sql_execute_for_resource_group'):
# 先获取用户所在资源组列表
group_list = user_groups(user)
group_ids = [group.group_id for group in group_list]
if workflow_detail.group_id in group_ids:
result = True
# 其他人只能查看自己提交的工单
else:
if workflow_detail.engineer == user.username:
result = True
return result
def can_execute(user, workflow_id):
"""
判断用户当前是否可执行，两种情况下用户有执行权限
1.登录用户有资源组粒度执行权限，并且为组内用户
2.当前登录用户为提交人，并且有执行权限
:param user:
:param workflow_id:
:return:
"""
result = False
# 保证工单当前是可执行状态
with transaction.atomic():
workflow_detail = SqlWorkflow.objects.select_for_update().get(
id=workflow_id)
# 只有审核通过和定时执行的数据才可以立即执行
if workflow_detail.status not in [
'workflow_review_pass', 'workflow_timingtask'
]:
return False
# 当前登录用户有资源组粒度执行权限，并且为组内用户
group_ids = [group.group_id for group in user_groups(user)]
if workflow_detail.group_id in group_ids and user.has_perm(
'sql.sql_execute_for_resource_group'):
result = True
# 当前登录用户为提交人，并且有执行权限
if workflow_detail.engineer == user.username and user.has_perm(
'sql.sql_execute'):
result = True
return result
def create_backup(request):
"""创建腾讯云数据库的备份"""
user = request.user
# 获取组信息
group_list = user_groups(user)
tags = InstanceTag.objects.all()
context = {'group_list': group_list, 'tags': tags}
return render(request, 'create_backup.html', context)
def archive(request):
"""归档列表页面"""
# 获取资源组
group_list = user_groups(request.user)
ins_list = user_instances(request.user, db_type=['mysql'])
return render(request, 'archive.html', {
'group_list': group_list,
'ins_list': ins_list
})
def submit_sql(request):
user = request.user
# 获取组信息
group_list = user_groups(user)
# 获取所有有效用户，通知对象
active_user = Users.objects.filter(is_active=1)
context = {'active_user': active_user, 'group_list': group_list}
return render(request, 'sqlsubmit.html', context)
def archive(request):
"""归档列表页面"""
# 获取资源组
group_list = user_groups(request.user)
ins_list = user_instances(request.user, db_type=['mysql']).order_by(
Convert('instance_name', 'gbk').asc())
return render(request, 'archive.html', {
'group_list': group_list,
'ins_list': ins_list
})
def user_query_priv(request):
"""
用户的查询权限管理
:param request:
:return:
"""
user = request.user
user_display = request.POST.get('user_display', 'all')
limit = int(request.POST.get('limit'))
offset = int(request.POST.get('offset'))
limit = offset + limit
search = request.POST.get('search', '')
user_query_privs = QueryPrivileges.objects.filter(
is_deleted=0, valid_date__gte=datetime.datetime.now())
# 过滤搜索项，支持模糊搜索用户、数据库、表
if search:
user_query_privs = user_query_privs.filter(
Q(user_display__icontains=search) | Q(db_name__icontains=search)
| Q(table_name__icontains=search))
# 过滤用户
if user_display != 'all':
user_query_privs = user_query_privs.filter(user_display=user_display)
# 管理员可以看到全部数据
if user.is_superuser:
user_query_privs = user_query_privs
# 拥有管理权限、可以查看组内所有工单
elif user.has_perm('sql.query_mgtpriv'):
# 先获取用户所在资源组列表
group_list = user_groups(user)
group_ids = [group.group_id for group in group_list]
user_query_privs = user_query_privs.filter(
instance__queryprivilegesapply__group_id__in=group_ids)
# 其他人只能看到自己提交的工单
else:
user_query_privs = user_query_privs.filter(user_name=user.username)
privileges_count = user_query_privs.distinct().count()
privileges_list = user_query_privs.distinct().order_by(
'-privilege_id')[offset:limit].values('privilege_id', 'user_display',
'instance__instance_name',
'db_name', 'priv_type',
'table_name', 'limit_num',
'valid_date')
# QuerySet 序列化
rows = [row for row in privileges_list]
result = {"total": privileges_count, "rows": rows}
# 返回查询结果
return HttpResponse(json.dumps(result,
cls=ExtendJSONEncoder,
bigint_as_string=True),
content_type='application/json')
def stop(request):
user = request.user
workflow_id = request.POST.get('workflow_id')
stop_remark = request.POST.get('stop_remark')
if not workflow_id:
return JsonResponse({'status': 1, 'msg': '参数不完整，请确认后提交', 'data': []})
if not stop_remark:
return JsonResponse({'status': 1, 'msg': '终止原因不能为空', 'data': []})
try:
group_list = user_groups(user)
group_ids = [group.group_id for group in group_list]
workflow = SqlWorkflow.objects.get(id=workflow_id)
if workflow.group_id not in group_ids:
return JsonResponse({'status': 1, 'msg': '您无权操作', 'data': []})
# 只有工单流转起来后，才能停止
if workflow.status not in [
'workflow_finish', 'workflow_review_pass',
'workflow_exception', 'workflow_pause'
]:
return JsonResponse({
'status': 1,
'msg': '该工单无法停止，操作非法',
'data': []
})
with transaction.atomic():
Schedule.objects.filter(name=f'sqlcron-{workflow_id}').update(
repeats=0)
workflow.status = 'workflow_stop'
workflow.save()
# 添加工单日志
audit_id = Audit.detail_by_workflow_id(
workflow_id=workflow_id,
workflow_type=WorkflowDict.workflow_type['sqlreview']).audit_id
Audit.add_log(
audit_id=audit_id,
operation_type=6,
operation_type_desc='终止执行',
operation_info='终止原因：{}'.format(stop_remark),
operator=user.username,
operator_display=user.display,
)
except Exception as e:
logger.error(f'发生异常，错误信息：{traceback.format_exc()}')
return JsonResponse({'status': 1, 'msg': f'发生异常，错误信息：{e}'})
return JsonResponse({'status': 0, 'msg': '', 'data': []})
def can_execute(user, workflow_id):
workflow_detail = SqlWorkflow.objects.get(id=workflow_id)
result = False
# 只有审核通过和定时执行的数据才可以立即执行
if workflow_detail.status in [
Const.workflowStatus['pass'], Const.workflowStatus['timingtask']
]:
# 当前登录用户必须为有执行权限的组内用户
group_ids = [group.group_id for group in user_groups(user)]
if workflow_detail.group_id in group_ids and user.has_perm(
'sql.sql_execute'):
return True
return result
def can_timingtask(user, workflow_id):
workflow_detail = SqlWorkflow.objects.get(id=workflow_id)
result = False
# 只有审核通过和定时执行的数据才可以执行
if workflow_detail.status in [
'workflow_review_pass', 'workflow_timingtask'
]:
# 当前登录用户必须为有执行权限的组内用户
group_ids = [group.group_id for group in user_groups(user)]
if workflow_detail.group_id in group_ids and user.has_perm(
'sql.sql_execute'):
result = True
return result
def lists(request):
# 获取用户信息
user = request.user
limit = int(request.POST.get('limit'))
offset = int(request.POST.get('offset'))
workflow_type = int(request.POST.get('workflow_type'))
limit = offset + limit
search = request.POST.get('search', '')
# 先获取用户所在资源组列表
group_list = user_groups(user)
group_ids = [group.group_id for group in group_list]
# 再获取用户所在权限组列表
if user.is_superuser:
auth_group_ids = [group.id for group in Group.objects.all()]
else:
auth_group_ids = [
group.id for group in Group.objects.filter(user=user)
]
# 只返回当前待自己审核的数据
if workflow_type == 0:
audit_obj = WorkflowAudit.objects.filter(
workflow_title__icontains=search,
current_status=WorkflowDict.workflow_status['audit_wait'],
group_id__in=group_ids,
current_audit__in=auth_group_ids)
else:
audit_obj = WorkflowAudit.objects.filter(
workflow_title__icontains=search,
workflow_type=workflow_type,
current_status=WorkflowDict.workflow_status['audit_wait'],
group_id__in=group_ids,
current_audit__in=auth_group_ids)
audit_list_count = audit_obj.count()
audit_list = audit_obj.order_by('-audit_id')[offset:limit].values(
'audit_id', 'workflow_type', 'workflow_title', 'create_user_display',
'create_time', 'current_status', 'audit_auth_groups', 'current_audit',
'group_name')
# QuerySet 序列化
rows = [row for row in audit_list]
result = {"total": audit_list_count, "rows": rows}
# 返回查询结果
return HttpResponse(json.dumps(result,
cls=ExtendJSONEncoder,
bigint_as_string=True),
content_type='application/json')
def todo(user):
# 先获取用户所在资源组列表
group_list = user_groups(user)
group_ids = [group.group_id for group in group_list]
# 再获取用户所在权限组列表
if user.is_superuser:
auth_group_ids = [group.id for group in Group.objects.all()]
else:
auth_group_ids = [group.id for group in Group.objects.filter(user=user)]
return WorkflowAudit.objects.filter(
current_status=WorkflowDict.workflow_status['audit_wait'],
group_id__in=group_ids,
current_audit__in=auth_group_ids).count()
def sql_workflow_list(request):
"""
获取审核列表
:param request:
:return:
"""
nav_status = request.POST.get('navStatus', 'all')
limit = int(request.POST.get('limit'))
offset = int(request.POST.get('offset'))
limit = offset + limit
search = request.POST.get('search')
user = request.user
workflow = SqlWorkflow.objects.all()
# 过滤搜索项，模糊检索项包括提交人名称、工单名
if search:
workflow = SqlWorkflow.objects.filter(
Q(engineer_display__icontains=search)
| Q(workflow_name__icontains=search))
# 过滤工单状态
if nav_status != 'all':
workflow = workflow.filter(status=nav_status)
# 管理员，可查看所有工单
if user.is_superuser:
workflow = workflow
# 非管理员，拥有审核权限、资源组粒度执行权限的，可以查看组内所有工单
elif user.has_perm('sql.sql_review') or user.has_perm(
'sql.sql_execute_for_resource_group'):
# 先获取用户所在资源组列表
group_list = user_groups(user)
group_ids = [group.group_id for group in group_list]
workflow = workflow.filter(group_id__in=group_ids)
# 其他人只能查看自己提交的工单
else:
workflow = workflow.filter(engineer=user.username)
count = workflow.count()
workflow_list = workflow.order_by('-create_time')[offset:limit].values(
"id", "workflow_name", "engineer_display", "status", "is_backup",
"create_time", "instance__instance_name", "db_name", "group_name",
"syntax_type")
# QuerySet 序列化
rows = [row for row in workflow_list]
result = {"total": count, "rows": rows}
# 返回查询结果
return HttpResponse(json.dumps(result,
cls=ExtendJSONEncoder,
bigint_as_string=True),
content_type='application/json')
def pause(request):
user = request.user
workflow_id = request.POST.get('workflow_id')
if not workflow_id:
return JsonResponse({'status': 1, 'msg': '参数不完整，请确认后提交', 'data': []})
try:
group_list = user_groups(user)
group_ids = [group.group_id for group in group_list]
workflow = SqlWorkflow.objects.get(id=workflow_id)
if workflow.group_id not in group_ids:
return JsonResponse({'status': 1, 'msg': '您无权操作', 'data': []})
# 在‘已审核’、‘在执行’、‘已执行’的状态下工单才能被暂停
if workflow.status not in [
'workflow_review_pass', 'workflow_executing', 'workflow_finish'
]:
return JsonResponse({
'status': 1,
'msg': '该工单非暂停状态，操作非法',
'data': []
})
with transaction.atomic():
Schedule.objects.filter(name=f'sqlcron-{workflow_id}').update(
repeats=0)
workflow.status = 'workflow_pause'
workflow.save()
# 添加工单日志
audit_id = Audit.detail_by_workflow_id(
workflow_id=workflow_id,
workflow_type=WorkflowDict.workflow_type['sqlreview']).audit_id
Audit.add_log(
audit_id=audit_id,
operation_type=5,
operation_type_desc='执行工单',
operation_info='执行结果：已暂停任务',
operator=user.username,
operator_display=user.display,
)
except Exception as e:
logger.error(f'发生异常，错误信息：{traceback.format_exc()}')
return JsonResponse({'status': 1, 'msg': f'发生异常，错误信息：{e}'})
return JsonResponse({'status': 0, 'msg': '', 'data': []})
def submit_sql(request):
user = request.user
# 获取组信息
group_list = user_groups(user)
# 获取所有有效用户，通知对象
active_user = Users.objects.filter(is_active=1)
# 获取系统配置
archer_config = SysConfig()
context = {
'active_user': active_user,
'group_list': group_list,
'enable_backup_switch': archer_config.get('enable_backup_switch')
}
return render(request, 'sqlsubmit.html', context)
def query_priv_apply_list(request):
"""
获取查询权限申请列表
:param request:
:return:
"""
user = request.user
limit = int(request.POST.get('limit', 0))
offset = int(request.POST.get('offset', 0))
limit = offset + limit
search = request.POST.get('search', '')
query_privs = QueryPrivilegesApply.objects.all()
# 过滤搜索项，支持模糊搜索标题、用户
if search:
query_privs = query_privs.filter(
Q(title__icontains=search) | Q(user_display__icontains=search))
# 管理员可以看到全部数据
if user.is_superuser:
query_privs = query_privs
# 拥有审核权限、可以查看组内所有工单
elif user.has_perm('sql.query_review'):
# 先获取用户所在资源组列表
group_list = user_groups(user)
group_ids = [group.group_id for group in group_list]
query_privs = query_privs.filter(group_id__in=group_ids)
# 其他人只能看到自己提交的工单
else:
query_privs = query_privs.filter(user_name=user.username)
count = query_privs.count()
lists = query_privs.order_by('-apply_id')[offset:limit].values(
'apply_id', 'title', 'instance__instance_name', 'db_list', 'priv_type',
'table_list', 'limit_num', 'valid_date', 'user_display', 'status',
'create_time', 'group_name')
# QuerySet 序列化
rows = [row for row in lists]
result = {"total": count, "rows": rows}
# 返回查询结果
return HttpResponse(json.dumps(result,
cls=ExtendJSONEncoder,
bigint_as_string=True),
content_type='application/json')
def getqueryapplylist(request):
# 获取用户信息
user = request.user
limit = int(request.POST.get('limit'))
offset = int(request.POST.get('offset'))
limit = offset + limit
search = request.POST.get('search', '')
# 获取列表数据,申请人只能查看自己申请的数据,管理员可以看到全部数据,审核人可以看到自己审核的数据
if user.is_superuser:
lists_obj = QueryPrivilegesApply.objects.all().filter(
Q(title__contains=search) | Q(user_display__contains=search))
elif user.has_perm('sql.query_review'):
# 先获取用户所在资源组列表
group_list = user_groups(user)
group_ids = [group.group_id for group in group_list]
lists_obj = QueryPrivilegesApply.objects.filter(
group_id__in=group_ids).filter(
Q(title__contains=search) | Q(user_display__contains=search))
else:
lists_obj = QueryPrivilegesApply.objects.filter(
user_name=user.username).filter(
Q(title__contains=search) | Q(user_display__contains=search))
count = lists_obj.count()
lists = lists_obj.order_by('-apply_id')[offset:limit].values(
'apply_id', 'title', 'instance_name', 'db_list', 'priv_type',
'table_list', 'limit_num', 'valid_date', 'user_display', 'status',
'create_time', 'group_name')
# QuerySet 序列化
rows = [row for row in lists]
result = {"total": count, "rows": rows}
# 返回查询结果
return HttpResponse(json.dumps(result,
cls=ExtendJSONEncoder,
bigint_as_string=True),
content_type='application/json')
def sqlcronnewquery(request):
"""SQL在线查询页面"""
user = request.user
# 获取组信息
group_list = user_groups(user)
# 获取所有有效用户，通知对象
active_user = Users.objects.filter(is_active=1)
# 获取系统配置
archer_config = SysConfig()
# 主动创建标签
InstanceTag.objects.get_or_create(tag_code='can_read',
defaults={
'tag_name': '支持查询',
'active': True
})
context = {'active_user': active_user, 'group_list': group_list}
# 主动创建标签
return render(request, 'sqlcron/newquery.html', context)
def sql_workflow_list(request):
"""
获取审核列表
:param request:
:return:
"""
nav_status = request.POST.get('navStatus')
instance_id = request.POST.get('instance_id')
resource_group_id = request.POST.get('group_id')
start_date = request.POST.get('start_date')
end_date = request.POST.get('end_date')
limit = int(request.POST.get('limit'))
offset = int(request.POST.get('offset'))
limit = offset + limit
search = request.POST.get('search')
user = request.user
# 组合筛选项
filter_dict = dict()
# 工单状态
if nav_status:
filter_dict['status'] = nav_status
# 实例
if instance_id:
filter_dict['instance_id'] = instance_id
# 资源组
if resource_group_id:
filter_dict['group_id'] = resource_group_id
# 时间
if start_date and end_date:
end_date = datetime.datetime.strptime(
end_date, '%Y-%m-%d') + datetime.timedelta(days=1)
filter_dict['create_time__range'] = (start_date, end_date)
# 管理员，可查看所有工单
if user.is_superuser:
pass
# 非管理员，拥有审核权限、资源组粒度执行权限的，可以查看组内所有工单
elif user.has_perm('sql.sql_review') or user.has_perm(
'sql.sql_execute_for_resource_group'):
# 先获取用户所在资源组列表
group_list = user_groups(user)
group_ids = [group.group_id for group in group_list]
filter_dict['group_id__in'] = group_ids
# 其他人只能查看自己提交的工单
else:
filter_dict['engineer'] = user.username
# 过滤组合筛选项
workflow = SqlWorkflow.objects.filter(**filter_dict)
# 过滤搜索项，模糊检索项包括提交人名称、工单名
if search:
workflow = workflow.filter(
Q(engineer_display__icontains=search)
| Q(workflow_name__icontains=search))
count = workflow.count()
workflow_list = workflow.order_by('-create_time')[offset:limit].values(
"id", "workflow_name", "engineer_display", "status", "is_backup",
"create_time", "instance__instance_name", "db_name", "group_name",
"syntax_type")
# QuerySet 序列化
rows = [row for row in workflow_list]
result = {"total": count, "rows": rows}
# 返回查询结果
return HttpResponse(json.dumps(result,
cls=ExtendJSONEncoder,
bigint_as_string=True),
content_type='application/json')
