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