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')