def export_manual_sync_file(): file_created = None try: # CREATE TOOL DETAILS FILE data = request.get_json() sync_id = str(uuid.uuid4()) if data.get("filters_to_apply"): if data.get("filters_to_apply").get("time_after"): data["filters_to_apply"]["time_after"] = datetime.strptime( data["filters_to_apply"]["time_after"].split(".")[0], "%Y-%m-%dT%H:%M:%S") print " Main : A manual export was requested for host :" + data.get("target_host") + " id :" + sync_id file_created, toolName, toolNamesNotExported = syncService.createZipToExport({"file_path":export_full_path,"zip_file_name":sync_id,\ "target_host":data.get("target_host"),"sync_type":"manual","external_artifacts":data.get("external_artifacts")},copy.deepcopy(data.get("filters_to_apply"))) print " Main : A manual export was completed for host :" + data.get("target_host") + " id :" + sync_id filename = os.path.basename(file_created) shutil.copy(file_created, saved_export_full_path) user_id = authService.get_userid_by_auth_token() export_data = {"user": userDb.get_user_by_id(user_id, False)["user"], "export_date": datetime.now(), "no_of_exported": len(toolName), "no_of_not_exported": len(toolNamesNotExported), "export_size": str(float("{0:.2f}".format(os.path.getsize( file_created) / (1024 * 1024.0)))) + " MB", "file_name": filename, "exported": toolName, "not_exported": toolNamesNotExported, "file_path": saved_export_path + "/" + filename, "filters_to_apply": data.get("filters_to_apply"), "target_host": data.get("target_host")} SavedExportsDb.add_exports(export_data) SavedExportsDb.delete_extra_exports(saved_export_full_path) return jsonify(json.loads(dumps({"result": "success", "message": str(len(toolName)) + " entity were exported successfully", "data": {"file_path": str(export_path + "/" + filename), "tool_names": toolName, "tool_names_not_exported": toolNamesNotExported}}))), 200 # return send_file(file_created, attachment_filename=filename, # as_attachment=True) except Exception as e: # catch *all* exceptions if file_created: if os.path.isfile(file_created): os.remove(file_created) raise e
def delete_user(uid): """Start User Deletion""" user_id = authService.get_userid_by_auth_token() if user_id is None: return jsonify({ "result": "failed", "message": "Token verification failed" }), 404 loggedInUser = userdb.get_user_by_id(user_id, False) UserToDelete = userdb.get_user_by_id(uid, False) loggedInUserRole = roledb.get_role_by_id(loggedInUser["roleid"], True) if loggedInUserRole["name"].lower() == "superadmin": pass else: newUserRole = roledb.get_role_by_id(UserToDelete.get("roleid"), False) if newUserRole["name"].lower() == "superadmin": raise ValueError("Only SuperAdmin can remove a SuperAdmin") else: pass all_machines = machinedb.GetMachines( {"permitted_users": { "$in": [str(uid)] }}) present_in_machine_permissions = [] for mach in all_machines: if mach.get("machine_name") not in present_in_machine_permissions: present_in_machine_permissions.append(mach.get("machine_name")) all_teams = teamsdb.get_teams_by_filter(str(uid)) present_in_teams = [] for rec in all_teams: if rec.get("team_name") not in present_in_teams: present_in_teams.append(rec.get("team_name")) err = "" if len(present_in_machine_permissions) > 0: err = "The user cannot be deleted as it is in the machine permissions: " + ( ','.join(map(str, present_in_machine_permissions))) if len(present_in_teams) > 0: if len(err) > 0: err = err + " and is the part of teams: " + (','.join( map(str, present_in_teams))) else: err = "The user cannot be deleted as it is the part of the teams : " + ( ','.join(map(str, present_in_teams))) if len(err) > 0: raise ValueError(err) userfavmc = machineFavDb.get_user_favorite_machine_by_user_id(uid, False) if userfavmc is not None: for record in userfavmc: machineFavDb.delete_user_favorite_machine(record["_id"]) if teamsdb.get_team_by_user(uid) is not None: teams = teamsdb.get_team_by_user(uid) for team in teams: teamsdb.remove_user_from_team(team["_id"], uid) if machinedb.get_machine_by_permitted_user(uid) is not None: machines = machinedb.get_machine_by_permitted_user(uid) for machine in machines: machinedb.RemoveUserPermissionToMachine(machine["_id"], uid) return (userdb.delete_user(uid))
def getAllToolSets(): limit = int(request.args.get('perpage', '30')) page = int(request.args.get('page', "0")) skip = page * limit finalData = [] tags_filter = [] toolName_filter = [] name_filter = None if request.args.get('tags', None): tags_filter = request.args.get('tags', None).split(",") if request.args.get('toolname', None): toolName_filter = request.args.get('toolname', None).split(",") id_list = teamService.get_user_permissions( authService.get_userid_by_auth_token())[ "parent_entity_set_id_list"] # TOOL SET IDS if request.args.get('name', None): name_filter = request.args.get('name', None) filter_required = {"_id": {"$in": id_list}} if name_filter: filter_required.update( {"name": { "$regex": str(name_filter), "$options": "i" }}) total_count = len( list(toolsetdb.get_all_tool_set({"_id": { "$in": id_list }}))) if name_filter: skip = limit = 0 toolsets = toolsetdb.get_all_tool_set(filter_required, skip, limit) for record in toolsets: if (HelperServices.filter_handler(record, tags_filter, record.get("tag", []), "tag")): continue if len(toolName_filter) > 0: tool_list = [] for eachTool in record.get("tool_set"): if eachTool.get("tool_id"): tool_list.append(str(eachTool["tool_id"])) if tool_list and "any" not in toolName_filter: if toolName_filter and len(toolName_filter) > 0 and len( list(set(toolName_filter) & set(tool_list))) < 1: continue finalData.append(record) return jsonify( json.loads( dumps({ "result": "success", "data": { "data": finalData, "page": page, "total": total_count, "page_total": len(finalData) } }))), 200
def put(self): user_data = request.get_json() data = {} if user_data.get("_id") is None: raise Exception("_id not found") else: data["_id"] = user_data["_id"] if user_data.get("password") is None: raise Exception("password not found") else: data["password"] = user_data["password"] user = userdb.get_user_by_id(user_data.get("_id").get("oid"), True) if not user: raise Exception("No such user was found") if str( userdb.get_user_by_id( authService.get_userid_by_auth_token(), True)["role_details"]["name"]).lower() not in [ "superadmin", "admin" ]: if user["user"] <> userdb.get_user_by_id( authService.get_userid_by_auth_token(), True)["user"]: raise Exception( "You are only allowed to change your own password") updated = userdb.update_user(data) try: mailer.send_html_notification(user.get("email"), None, None, 1, {"name": user.get("user")}) except Exception as e: # catch *all* exceptions print "Failed to save email" + str(e) if updated == 1: user_update_data = { "_id": user_data.get("_id"), "isfirstlogin": "******" } userdb.update_user(user_update_data) invalidate_temp_password( userdb.get_user_by_id(user_data.get("_id").get("oid"), True)) return { "result": "success", "message": "Password was updated", "data": updated }, 200 else: raise Exception("Password was not updated")
def post(self): user = request.get_json() HelperServices.validate_name(user.get("user"), "username") user_id = authService.get_userid_by_auth_token() if user_id is None: raise Exception("Token verification failed") loggedInUser = userdb.get_user_by_id(user_id, False) loggedInUserRole = roledb.get_role_by_id(loggedInUser["roleid"], True) if loggedInUserRole["name"].lower() == "superadmin": pass else: newUserRole = roledb.get_role_by_id(user.get("roleid"), False) if newUserRole["name"].lower() == "superadmin": raise ValueError( "Only SuperAdmin can create a SuperAdmin user") else: pass if (user.get("employeeid") and user.get("user") and user.get("email") and user.get("accountid")) is None: raise Exception( "Mandatory fields to create a new user was not found.") if userdb.get_user(user.get("user"), False) is not None: raise Exception("User already exists") if accountDB.get_account(user.get("accountid")) is None: raise Exception("Account does not exists") addData = {"user": user.get("user").lower(), "status": "active"} if user.get("roleid") is None: addData["roleid"] = str( roledb.get_role_by_name('Guest', False)["_id"]) else: if roledb.get_role_by_id(user.get("roleid"), False) is None: raise Exception("Role does not exists") user.update(addData) passw = genrate_random_key() user["password"] = passw result = userdb.add_user(user) if user.get("included_in"): for team_id in user["included_in"]: teamDB.add_user_to_team(team_id, str(result)) try: systemdetails = systemDetailsDB.get_system_details_single() mailer.send_html_notification( user.get("email"), None, None, 14, { "name": user.get("user"), "password": passw, "machine_host": systemdetails.get("hostname") }) teamService.generate_details() except Exception as e: traceback.print_exc() return { "result": "success", "message": "A new user was created..Token was generated", "data": { "Token": authService.generate_auth_token(str(result)) } }, 200
def post(self): data = request.json oid=data.get("_id").get("oid") dep_req=deploymentRequestGroupDB.get_group_deployment_request(str(oid), True ,True) request_list= dep_req.get("requested_deployment_ids_data") keys_to_pop=["machine_name","create_date","update_date","execution_count",\ "status_message","status","start_time","_id","step_details",\ "current_step_id","retry_count","end_time"] requested_by=userDB.get_user_by_id(authService.get_userid_by_auth_token(), False).get("user") for key in keys_to_pop: for idx, item in enumerate(request_list): if key in request_list[idx].keys() : request_list[idx].pop(key) request_list[idx]["requested_by"]= requested_by request_list[idx]["request_type"]= "undeploy" return {"result": "success", "message": "New GroupDeployment request has been added successfully",\ "data": {"_id": add_request(request_list)}}, 200
def put(self): user_data = request.get_json() if user_data.get("user"): HelperServices.validate_name(user_data.get("user"), "username") if user_data.get("_id"): user_id = user_data["_id"]["oid"] if user_data.get("roleid") is not None: if roledb.get_role_by_id(user_data.get("roleid"), False) is None: raise Exception("Role does not exists") # other way is to get account id from GUI if user_data.get("accountid") is not None: if accountDB.get_account(user_data.get("accountid")) is None: raise Exception("Account does not exists") auth_user_id = authService.get_userid_by_auth_token() if auth_user_id is None: raise Exception("Token verification failed") loggedInUser = userdb.get_user_by_id(auth_user_id, False) loggedInUserRole = roledb.get_role_by_id(loggedInUser["roleid"], True) if loggedInUserRole["name"].lower() == "superadmin": pass else: newUserRole = roledb.get_role_by_id(user_data.get("roleid"), False) if newUserRole["name"].lower() == "superadmin": raise ValueError( "Only SuperAdmin can update role to SuperAdmin") else: pass for group in teamDB.get_team_by_user(user_id): teamDB.remove_user_from_team(str(group["_id"]), user_id) if user_data.get("included_in"): for group_id in user_data.get("included_in"): teamDB.add_user_to_team(group_id, user_id) updated = userdb.update_user(user_data) if updated == 1: teamService.generate_details() return { "result": "success", "message": "User was updated", "data": updated }, 200 else: raise Exception("User was not updated.")
def getGuiPermissionsByUserId(): showDetails = request.headers.get("detail") superAdmin = False user_id = authService.get_userid_by_auth_token() user = userdb.get_user_by_id(user_id, False) role_list = roledb.get_role_by_id(user["roleid"], True) in_user = '******' if dpm_type.lower() == "dpm_master": if role_list["name"].lower() == in_user.lower(): superAdmin = True if role_list is not None: if role_list.get("permissiongroup_details") is not None: if showDetails == "True": if superAdmin: data = perGroup.get_all_group_permission(True) else: data = role_list["permissiongroup_details"] else: if superAdmin: role_list[ "permissiongroup_details"] = perGroup.get_all_group_permission( True) list = [] for rec in role_list.get("permissiongroup_details"): for recInner in rec["routes_details"]: list.append(recInner["name"]) return jsonify( json.loads(dumps({ "result": "success", "data": list }))), 200 else: raise Exception("No data found") else: raise Exception("Role with id :" + user["roleid"] + "was not found") return jsonify(json.loads(dumps({"result": "success", "data": data}))), 200
def GetMachineGroups(): limit = int(request.args.get('perpage', "30")) page = int(request.args.get('page', "0")) skip = page * limit machine_group_name_filter = request.args.get('machine_group_name', None) machine_id_filter = request.args.get('machine_id_list', None) if not machine_id_filter or "any" in machine_id_filter: machine_id_filter = None else: machine_id_filter = machine_id_filter.split(",") if machine_group_name_filter: machine_group_name_filter = machine_group_name_filter.split(",") id_list = teamService.get_user_permissions( authService.get_userid_by_auth_token())["machine_group_id_list"] final_machine_group_list = [] for machine_group in machinegroupsDB.get_all_machine_groups( {"_id": { "$in": id_list }}): if(HelperServices.filter_handler(machine_group, machine_id_filter,\ machine_group.get("machine_id_list",[]),"machine_id_list")): continue if machine_group_name_filter: if len([ f for f in machine_group_name_filter if re.compile(f.lower(), re.IGNORECASE).match( machine_group.get("group_name").lower()) ]) == 0: continue final_machine_group_list.append(machine_group) total_machine_groups = list( machinegroupsDB.get_all_machine_groups({"_id": { "$in": id_list }})) return jsonify(json.loads(dumps({"result": "success", "data":{"data": final_machine_group_list, "page": page,\ "total": len(total_machine_groups), "page_total": len(final_machine_group_list)} }))), 200
def getAllDeploymentUnitSets(): limit = int(request.args.get('perpage', '30')) page = int(request.args.get('page', "0")) skip = page * limit tags_filter = [] duName_filter = [] approval_status_filter = [] name_filter = None if request.args.get('tags', None): tags_filter = request.args.get('tags', None).split(",") if request.args.get('duname', None): duName_filter = request.args.get('duname', None).split(",") if request.args.get('approval_status', None): approval_status_filter = request.args.get('approval_status', None).split(",") id_list = teamService.get_user_permissions( authService.get_userid_by_auth_token())["parent_entity_set_id_list"] if request.args.get('name', None): name_filter = request.args.get('name', None) filter_required = {"_id": {"$in": id_list}} if name_filter: filter_required.update( {"name": re.compile(name_filter, re.IGNORECASE)}) deploymentUnitSets = deploymentUnitSetDB.GetAllDeploymentUnitSet( False, filter_required, skip, limit) # total_count=len(id_list) total_count = len( list( deploymentUnitSetDB.GetAllDeploymentUnitSet( False, {"_id": { "$in": id_list }}))) ###########GROUP by DeploymentUnitType############################# finalData = [] if len(tags_filter) > 0 or len(approval_status_filter) > 0 or len( duName_filter) > 0: for dus in deploymentUnitSets: #FILTER BY TAGS if len(tags_filter) > 0: if (HelperServices.filter_handler(dus, tags_filter, dus.get("tag", []), "tag")): continue #Filter by state approval status if len(approval_status_filter) > 0: approval_sts_of_states = [] for state in stateDB.get_state_by_parent_entity_id( str(dus["_id"]), True): if state.get("approval_status"): approval_sts_of_states.append( state.get("approval_status")) if(HelperServices.filter_handler({"approval_status":True},\ approval_status_filter,approval_sts_of_states , "approval_status")): continue if len(duName_filter) > 0: du_list = [] for eachTool in dus.get("du_set"): if eachTool.get("du_id"): du_list.append(eachTool["du_id"]) if du_list and "any" not in duName_filter: if duName_filter and len(duName_filter) > 0 and len( list(set(duName_filter) & set(du_list))) < 1: continue finalData.append(dus) return jsonify( json.loads( dumps({ "result": "success", "data": { "data": finalData, "page": page, "total": total_count, "page_total": len(finalData) } }))), 200 else: return jsonify( json.loads( dumps({ "result": "success", "data": { "data": list(deploymentUnitSets), "page": page, "total": total_count, "page_total": len(deploymentUnitSets) } }))), 200
def post(self): """ Create new Group Dep definition """ requests_list = [] #GET LOGGEDIN USER requested_by=userDB.get_user_by_id(authService.get_userid_by_auth_token(), False)["user"] #VALIDATIONS request_details = request.get_json() # get machine group machine_group_id=request_details.get("machine_group_id") machine_group_name=request_details.get("machine_group_name") if machine_group_id: machine_group_details=machinegroupsDB.get_machine_groups(machine_group_id,False) if not machine_group_details: raise Exception("Machine Group with _id: "+machine_group_id+" was not in database") elif machine_group_name: machine_group_details=machinegroupsDB.get_machine_group_by_name(machine_group_name) if not machine_group_details: raise Exception("Machine Group with group_name: "+machine_group_name+" was not found in database") else : raise Exception("Mandatory parameter : machine_group_id or machine_group_name was not provided") # get package state package_state_id=request_details.get("package_state_id") package_state_name=request_details.get("package_state_name") if package_state_id: package_state_details = statedb.get_state_by_id(package_state_id, True) if not package_state_details: raise Exception("Package State with _id: "+package_state_id+" was not found in database") elif package_state_name: package_state_details = statedb.get_state_by_name(package_state_name, True) if not package_state_details: raise Exception("Package State with name: "+package_state_name+" was not found in database") if len(package_state_details) > 1: raise Exception("Package State with name: "+package_state_name+" has more than one entries in database") else: package_state_details = package_state_details[0] else : raise Exception("Mandatory parameter : package_state_id or package_state_name was not provided") if len(package_state_details.get("states",[])) < 0 or package_state_details.get("type") <> "dusetstate": raise Exception("State with _id: "+package_state_id+" is invalid du package state") du_set_details=deploymentUnitSetdb.GetDeploymentUnitSetById(package_state_details.get("parent_entity_id"), False) if not du_set_details: raise Exception("DU Package with _id: "+str(package_state_details.get("parent_entity_id"))+" was not in database") scheduled_date = str(datetime.now()) #CREATE OUTER LIST OF DUS for state in package_state_details.get("states"): if not deploymentUnitdb.GetDeploymentUnitById(state["parent_entity_id"]): raise Exception("DU with _id: "+str(state.get("parent_entity_id"))+" was not in database") #CRAETE INNER LIST OF MACHINES for machine in machine_group_details["machine_id_list"]: inner_data = {"request_type": "deploy","deployment_type": "dugroup",\ "requested_by":requested_by,"parent_entity_id":state["parent_entity_id"],"state_id":str(state["_id"]), "machine_id":machine,"warning_flag": False,"tool_deployment_value":[],"scheduled_date":scheduled_date,"parent_entity_set_id":package_state_details.get("parent_entity_id")} if state.get("deployment_field"): for dep_field in state.get("deployment_field").get("fields"): if dep_field.get("default_value"): inner_data["tool_deployment_value"].append({"input_name": dep_field.get("input_name"),\ "input_type": dep_field.get("input_type"),"input_value": dep_field.get("default_value"),\ "order_id": dep_field.get("order_id")}) inner_data.update(request_details) requests_list.append(inner_data) return {"result": "success", "message": "New GroupDeployment request has been added successfully",\ "data": {"_id": add_request(requests_list)}}, 200
def get_all_machines(): limit = int(request.args.get('perpage', "30")) page = int(request.args.get('page', "0")) skip = page * limit tags_filter = request.args.get('tags', None) if not tags_filter or "any" in tags_filter: tags_filter = None else: tags_filter = tags_filter.split(",") machine_type_filter = request.args.get('machine_type', None) if not machine_type_filter or "any" in machine_type_filter: machine_type_filter = None else: machine_type_filter = machine_type_filter.split(",") machine_name_filter = request.args.get('machine_name', None) if machine_name_filter: machine_name_filter = machine_name_filter.split(",") host_filter = request.args.get('host', "") machine_id_filter = request.args.get('machine_id_list', None) if not machine_id_filter or "any" in machine_id_filter: machine_id_filter = None else: machine_id_filter = machine_id_filter.split(",") id_list = teamService.get_user_permissions( authService.get_userid_by_auth_token())[ "machine_id_list"] # TOOL SET IDS machines = list(machineDB.GetMachines({"_id": {"$in": id_list},\ "host": {"$regex": str(host_filter), "$options": "i"}},skip,limit)) total_machines = list(machineDB.GetMachines({"_id": {"$in": id_list}})) user_id = authService.get_userid_by_auth_token() keys_to_keep = [ "username", "machine_name", "host", "status", "_id", "machine_type", "flexible_attributes" ] final_list_of_machines = [] for index, machine in enumerate(machines): #FILTER BY TAGS if (HelperServices.filter_handler( machine, tags_filter, tagDB.get_tag_names_from_given_ids_list(machine.get("tag", [])), "tag")): continue if machine_type_filter and machineTypeDb.get_machine_type_by_id( machine.get("machine_type")).get( "type") not in machine_type_filter: continue if machine_name_filter: if len([ f for f in machine_name_filter if re.compile(f.lower(), re.IGNORECASE).match( machine.get("machine_name").lower()) ]) == 0: continue if machine_id_filter: if len( [f for f in machine_id_filter if f in str(machine.get("_id"))]) == 0: continue machines[index] = machineDB.decrypt(machine) # DECRYPT PASSWORDS for key in machines[index].keys(): if key not in keys_to_keep: machine.pop(key) fav_machine = machineFavDb.get_user_favorite_machine_by_machine_id_and_user_id( str(machines[index].get("_id")), user_id) if machines[index].get("machine_type"): machine_type = machineTypeDb.get_machine_type_by_id( machines[index]["machine_type"]) if machines[index]: machines[index]["machine_type"] = machine_type["type"] final_list_of_machines.append(machine) return jsonify( json.loads( dumps({ "result": "success", "data": { "data": final_list_of_machines, "page": page, "total": len(total_machines), "page_total": len(final_list_of_machines) } }))), 200
def getAllDeploymentUnits(): id_list = teamService.get_user_permissions( authService.get_userid_by_auth_token())[ "parent_entity_id_list"] # TOOL SET IDS # total_count=len(id_list) status_filter = request.args.get('status', None) tags_filter = [] duSet_filter = [] duName_filter = [] approval_status_filter = [] deployment_unit_type_filter = [] total_count_of_du_in_page = 0 limit = int(request.args.get('perpage', "30")) page = int(request.args.get('page', "0")) skip = page * limit if request.args.get('tags', None): tags_filter = request.args.get('tags').split(",") if request.args.get('duset', None): duSet_filter = request.args.get('duset', None).split(",") if not status_filter: status_filter = ['1'] elif not status_filter or "any" in status_filter: status_filter = None else: status_filter = status_filter.split(",") if request.args.get('type', None): deployment_unit_type_filter = request.args.get('type', None) if not deployment_unit_type_filter or "any" in deployment_unit_type_filter: deployment_unit_type_filter = None else: deployment_unit_type_filter = deployment_unit_type_filter.split(",") if request.args.get('approval_status', None): approval_status_filter = request.args.get('approval_status', None).split(",") if request.args.get('duname', None): duName_filter = request.args.get('duname', None) if duName_filter: deploymentUnits = deploymentUnitDB.GetAllDeploymentUnits( status_filter, deployment_unit_type_filter, False, { "$and": [{ "_id": { "$in": id_list } }, { "name": re.compile(duName_filter, re.IGNORECASE) }] }, 0, 0, True) else: deploymentUnits = deploymentUnitDB.GetAllDeploymentUnits( status_filter, deployment_unit_type_filter, False, {"_id": { "$in": id_list }}, skip, limit, True) total_count_of_du_in_db = len( list( deploymentUnitDB.GetAllDeploymentUnits(status_filter, None, False, {"_id": { "$in": id_list }}))) ###########GROUP by DeploymentUnitType############################# duJsonObj = {} du_list = [] for du in deploymentUnits: #FILTER BY TAGS if (HelperServices.filter_handler(du, tags_filter, du.get("tag", []), "tag")): continue #Filter by state approval status if approval_status_filter: approval_sts_of_states = [] for state in stateDB.get_state_by_parent_entity_id( str(du["_id"]), True): if state.get("approval_status"): approval_sts_of_states.append(state.get("approval_status")) if(HelperServices.filter_handler({"approval_status":True},\ approval_status_filter,approval_sts_of_states,"approval_status")): continue if duSet_filter: included_in_du_set_names = [] for duSetdata in deploymentUnitSetDB.GetDeploymentUnitSetByCondition( "du_set.du_id", du["_id"]): if duSetdata.get("_id") or duSetdata("name") is not None: included_in_du_set_names.append(str(duSetdata.get("name"))) if "any" not in duSet_filter: if duSet_filter and len(duSet_filter) > 0 and len( list( set(duSet_filter) & set(included_in_du_set_names))) < 1: continue # Latest BUILD NUMBER and BUILD TYPE latest_build_details = buildDB.get_last_active_build(str(du["_id"])) if latest_build_details: du["build_number"] = latest_build_details.get("build_number") du["build_id"] = str(latest_build_details.get("_id")) # ADD GROUPS HERE if du.get("type") in duJsonObj.keys(): duJsonObj[du.get("type")].append(du) else: duJsonObj[du.get("type")] = [] duJsonObj[du.get("type")].append(du) total_count_of_du_in_page += 1 for keytype in duJsonObj.keys(): dutype = {} dutype["type"] = keytype dutype["data"] = duJsonObj.get(keytype) du_list.append(dutype) return jsonify(json.loads(dumps({"result": "success", "data":\ {"data": du_list, "page": page, "total": total_count_of_du_in_db, "page_total": total_count_of_du_in_page}}))), 200