def fetch_org_code_list(request):
"""
获取各分局公安机关机构代码列表
:param request:
:return:
"""
req_params = parse_json(request)
limit = req_params.get('limit', 50)
current_page = req_params.get('page', 1)
try:
org_code = OrgCode.objects.all().order_by("-id")
current_page = get_actual_page(len(org_code), limit, current_page)
paginator = Paginator(org_code, limit)
org_code = paginator.page(current_page)
data_list = []
data = {'count': 0, 'list': [], 'current_page': current_page}
if org_code:
for item in org_code:
data_list.append({
"id": item.id,
"name": item.name,
"code": item.code
})
data = {
'count': paginator.count,
'list': data_list,
'current_page': current_page
}
return json_resp("success", data)
except Exception as e:
print(e)
return json_resp("error", None, 500)
def fetch_alarm_record_list(request):
"""
获取基础故障告警数据
:param request:
:return:
"""
req_params = parse_json(request)
limit = req_params.get('limit', 20)
current_page = req_params.get('page', 1)
sj_org_code = req_params.get("SJ_ORG_CODE")
name = req_params.get("NAME")
severity = req_params.get("SEVERITY")
pro_status = req_params.get("PRO_STATUS")
# 执行sql语句
table_name = "v_alarm_record_9"
try:
keywords = []
if sj_org_code is not None and len(sj_org_code.strip()) > 0:
keywords.append({
"key": "SJ_ORG_CODE",
"value": sj_org_code,
"condition": "="
})
if name is not None and len(name.strip()) > 0:
keywords.append({
"key": "NAME",
"value": name + "",
"condition": "like"
})
if severity in [0, 1, 2]:
keywords.append({
"key": "SEVERITY",
"value": str(severity),
"condition": "="
})
if pro_status in [10, 20, 30]:
keywords.append({
"key": "PRO_STATUS",
"value": str(pro_status),
"condition": "="
})
sql, con_sql = splice_sql(table_name,
limit,
current_page,
keywords=keywords)
oracle_execute_sql = OracleExecuteSQL()
object_list = oracle_execute_sql.fetchall_to_dict(sql)
count = oracle_execute_sql.fetchone_to_dict(con_sql)
data = {
'count': count.get("COUNT", 0),
'list': object_list,
'current_page': current_page
}
return json_resp("success", data)
except Exception as e:
print(e)
return json_resp("error", None, 500)
def fetch_alarm_disposition_list(request):
"""
获取故障处理工单数据
:param request:
:return:
"""
req_params = parse_json(request)
limit = req_params.get('limit', 20)
current_page = req_params.get('page', 1)
sj_org_code = req_params.get("SJ_ORG_CODE")
one_solve = req_params.get("ONE_SOLVE")
satisfaction = req_params.get("SATISFACTION")
status = req_params.get("STATUS")
# 执行sql语句
table_name = "v_alarm_disposition_9"
try:
keywords = []
if sj_org_code is not None and len(sj_org_code.strip()) > 0:
keywords.append({
"key": "SJ_ORG_CODE",
"value": sj_org_code,
"condition": "="
})
if one_solve in [10, 20, 30]:
keywords.append({
"key": "ONE_SOLVE",
"value": str(one_solve),
"condition": "="
})
if satisfaction in [10, 20, 30]:
keywords.append({
"key": "SATISFACTION",
"value": str(satisfaction),
"condition": "="
})
if status in [10, 20, 30, 40]:
keywords.append({
"key": "STATUS",
"value": str(status),
"condition": "="
})
sql, con_sql = splice_sql(table_name,
limit,
current_page,
keywords=keywords)
oracle_execute_sql = OracleExecuteSQL()
object_list = oracle_execute_sql.fetchall_to_dict(sql)
count = oracle_execute_sql.fetchone_to_dict(con_sql)
data = {
'count': count.get("COUNT", 0),
'list': object_list,
'current_page': current_page
}
return json_resp("success", data)
except Exception as e:
print(e)
return json_resp("error", None, 500)
def fetch_room_situation_list(request):
"""
获取机房情况数据
:param request:
:return:
"""
req_params = parse_json(request)
m_type = req_params.get("TYPE")
if m_type == 1: # 分局
return branch(request)
else:
return police(request)
def fetch_report_log_list(request):
"""
获取上报日志数据
:param request:
:return:
"""
req_params = parse_json(request)
limit = req_params.get('limit', 20)
current_page = req_params.get('page', 1)
create_time_range = req_params.get("create_time_range")
update_time_range = req_params.get("update_time_range")
try:
report_log = ReportLog.objects.all().order_by("-id")
if update_time_range is not None and len(update_time_range):
satm = update_time_range[0]
edtm = update_time_range[1]
report_log = report_log.filter(updatedTime__range=(satm, edtm))
if create_time_range is not None and len(create_time_range) == 2:
satm = create_time_range[0]
edtm = create_time_range[1]
report_log = report_log.filter(createdTime__range=(satm, edtm))
current_page = get_actual_page(len(report_log), limit, current_page)
paginator = Paginator(report_log, limit)
report_log = paginator.page(current_page)
data_list = []
data = {'count': 0, 'list': [], 'current_page': current_page}
if report_log:
for item in report_log:
print(type(item.requestData))
data_list.append({
"id":
item.id,
"reportType":
item.reportType,
"requestData":
item.requestData,
"resultData":
json.loads(item.resultData),
"createdTime":
item.createdTime.strftime("%Y-%m-%d %H:%M:%S")
if item.createdTime else None,
"updatedTime":
item.updatedTime.strftime("%Y-%m-%d %H:%M:%S"),
})
data = {
'count': paginator.count,
'list': data_list,
'current_page': current_page
}
return json_resp("success", data)
except Exception as e:
print(e)
return json_resp("error", None, 500)
def fetch_hardware_resource_list(request):
"""
获取硬件资源数据
:param request:
:return:
"""
req_params = parse_json(request)
limit = req_params.get('limit', 20)
current_page = req_params.get('page', 1)
sj_org_code = req_params.get("SJ_ORG_CODE")
sj_status = req_params.get("SJ_STATUS")
sj_cl_network = req_params.get("SJ_CI_NETWORK")
# 执行sql语句
table_name = "v_hardware_resource_9"
try:
keywords = []
if sj_org_code is not None and len(sj_org_code.strip()) > 0:
keywords.append({
"key": "SJ_ORG_CODE",
"value": sj_org_code + "",
"condition": "="
})
if sj_status in [1, 2, 3, 4, 5, 6, 7, 8]:
keywords.append({
"key": "SJ_STATUS",
"value": str(sj_status),
"condition": "="
})
if sj_cl_network in [1, 2]:
keywords.append({
"key": "SJ_CI_NETWORK",
"value": str(sj_cl_network),
"condition": "="
})
sql, con_sql = splice_sql(table_name,
limit,
current_page,
keywords=keywords)
oracle_execute_sql = OracleExecuteSQL()
object_list = oracle_execute_sql.fetchall_to_dict(sql)
count = oracle_execute_sql.fetchone_to_dict(con_sql)
data = {
'count': count.get("COUNT", 0),
'list': object_list,
'current_page': current_page
}
return json_resp("success", data)
except Exception as e:
print(e)
return json_resp("error", None, 500)
def fetch_network_perf_list(request):
"""
获取网络设备监测指标数据
:param request:
:return:
"""
req_params = parse_json(request)
limit = req_params.get('limit', 20)
current_page = req_params.get('page', 1)
sj_org_code = req_params.get("ORG_CODE")
net_dev_online_state = req_params.get("NET_DEV_ONLINE_STATE")
net_dev_alert_level = req_params.get("NET_DEV_ALERT_LEVEL")
# 执行sql语句
table_name = "v_network_perf_9"
try:
keywords = []
if sj_org_code is not None and len(sj_org_code.strip()) > 0:
keywords.append({
"key": "ORG_CODE",
"value": sj_org_code,
"condition": "="
})
if net_dev_online_state in [10, 20]:
keywords.append({
"key": "NET_DEV_ONLINE_STATE",
"value": str(net_dev_online_state),
"condition": "="
})
if net_dev_alert_level in [0, 1, 2, 3]:
keywords.append({
"key": "NET_DEV_ALERT_LEVEL",
"value": str(net_dev_alert_level),
"condition": "="
})
sql, con_sql = splice_sql(table_name,
limit,
current_page,
keywords=keywords)
oracle_execute_sql = OracleExecuteSQL()
object_list = oracle_execute_sql.fetchall_to_dict(sql)
count = oracle_execute_sql.fetchone_to_dict(con_sql)
data = {
'count': count.get("COUNT", 0),
'list': object_list,
'current_page': current_page
}
return json_resp("success", data)
except Exception as e:
print(e)
return json_resp("error", None, 500)
def add_cloud_data(request):
"""
新增云平台总体建设情况
:param request:
:return:
"""
req_params = parse_json(request)
sj_org_code = req_params.get("sJorgCode") # 公安机关机构代码
sj_vm_plat_code = req_params.get("sJvmPlatCode")
sj_cloud_brand = req_params.get("sJcloudBrand")
sj_cloud_scale = req_params.get("sJcloudScale")
sj_cloud_serv_count = req_params.get("sJcloudServCount")
sj_cloud_serv_types = req_params.get("sJcloudServTypes")
sj_cloud_app_count = req_params.get("sJcloudAppCount")
is_reported = req_params.get("isReported")
is_deleted = req_params.get("isDeleted")
try:
configs = [
{"key": "sJorgCode", "value": sj_org_code, "v_type": "not_none"},
{"key": "sJvmPlatCode", "value": sj_vm_plat_code, "v_type": "not_none"},
{"key": "sJcloudBrand", "value": sj_cloud_brand, "v_type": "not_none"},
{"key": "sJcloudScale", "value": sj_cloud_scale, "v_type": "not_none"},
{"key": "sJcloudServCount", "value": sj_cloud_serv_count, "v_type": "not_none"},
{"key": "sJcloudServTypes", "value": sj_cloud_serv_types, "v_type": "not_none"},
{"key": "sJcloudAppCount", "value": sj_cloud_app_count, "v_type": "not_none"},
]
res_obj = batch_verification(configs)
if res_obj.get("msg") != "success":
return json_resp(res_obj.get("msg"), None, 500)
CloudDataAll.objects.create(
sJorgCode=sj_org_code,
sJvmPlatCode=sj_vm_plat_code,
sJcloudBrand=sj_cloud_brand,
sJcloudScale=sj_cloud_scale,
sJcloudServCount=sj_cloud_serv_count,
sJcloudServTypes=sj_cloud_serv_types,
sJcloudAppCount=sj_cloud_app_count,
isReported=0,
isDeleted=0,
createdTime=time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()),
updatedTime=time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
)
return json_resp("success")
except Exception as e:
print(e)
return json_resp("error", None, 500)
def delete_cloud_data(request):
"""
批量删除云平台总体建设情况数据
:param request:
:return:
"""
req_params = parse_json(request)
ids = req_params.get("ids")
try:
vd_res = is_data_validation_defeat('ids', ids, 'is_list')
if vd_res:
return json_resp(vd_res, None, 500)
CloudDataAll.objects.filter(id__in=ids).update(isDeleted=1)
return json_resp("success")
except Exception as e:
print(e)
return json_resp("error", None, 500)
def update_soft_data(request):
"""
编辑软件实例运行指标指标
:param request:
:return:
"""
req_params = parse_json(request)
server_data_id = req_params.get("id")
sj_org_code = req_params.get("orgCode") # 公安机关机构代码
is_reported = req_params.get("isReported")
is_deleted = req_params.get("isDeleted")
ci_id = req_params.get("ciId")
running_tate = req_params.get("runningState")
tcp_tate = req_params.get("tcpState")
web_response_time = req_params.get("webResponseTime")
vd_res = is_data_validation_defeat('id', server_data_id, 'not_none')
if vd_res:
return json_resp(vd_res, None, 500)
try:
soft_data = SoftData.objects.filter(id=server_data_id).first()
if not soft_data:
return json_resp("编辑失败", None, 500)
configs = [
{"key": "orgCode", "value": sj_org_code, "v_type": "not_none"},
{"key": "ciId", "value": ci_id, "v_type": "not_none"},
{"key": "runningState", "value": running_tate, "v_type": "not_none"},
{"key": "tcpState", "value": tcp_tate, "v_type": "not_none"},
{"key": "webResponseTime", "value": web_response_time, "v_type": "not_none"},
{"key": "isReported", "value": is_reported, "v_type": "not_in", "param": [1, 0]},
{"key": "isDeleted", "value": is_deleted, "v_type": "not_in", "param": [1, 0]},
]
res_obj = set_attr_by_data_valid(soft_data, configs)
if res_obj.get("msg") == "success":
soft_data = res_obj.get("obj")
else:
return json_resp(res_obj.get("msg"), None, 500)
soft_data.createdTime = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
soft_data.updatedTime = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
soft_data.save()
return json_resp("success")
except Exception as e:
print(e)
return json_resp("error", None, 500)
def fetch_network_link_list(request):
"""
获取网络骨干链路信息数据
:param request:
:return:
"""
req_params = parse_json(request)
limit = req_params.get('limit', 20)
current_page = req_params.get('page', 1)
sj_org_code = req_params.get("ORG_CODE")
# 执行sql语句
table_name = "v_network_link_9"
try:
keywords = []
if sj_org_code is not None and len(sj_org_code.strip()) > 0:
keywords.append({
"key": "ORG_CODE",
"value": sj_org_code,
"condition": "="
})
sql, con_sql = splice_sql(table_name,
limit,
current_page,
keywords=keywords)
oracle_execute_sql = OracleExecuteSQL()
object_list = oracle_execute_sql.fetchall_to_dict(sql)
count = oracle_execute_sql.fetchone_to_dict(con_sql)
data = {
'count': count.get("COUNT", 0),
'list': object_list,
'current_page': current_page
}
return json_resp("success", data)
except Exception as e:
print(e)
return json_resp("error", None, 500)
def fetch_cloud_data_list(request):
"""
获取云平台总体建设情况数据
:param request:
:return:
"""
req_params = parse_json(request)
limit = req_params.get('limit', 20)
current_page = req_params.get('page', 1)
cloud_data_id = req_params.get("id")
sj_org_code = req_params.get("sJorgCode")
create_time_range = req_params.get("createTimeRange")
update_time_range = req_params.get("updateTimeRange")
is_reported = req_params.get("isReported")
try:
cloud_data_list = CloudDataAll.objects.filter(isDeleted=0).order_by("-id")
if update_time_range is not None and len(update_time_range) == 2:
satm = update_time_range[0]
edtm = update_time_range[1]
cloud_data_list = cloud_data_list.filter(updatedTime__range=(satm, edtm))
if create_time_range is not None and len(create_time_range) == 2:
satm = create_time_range[0]
edtm = create_time_range[1]
cloud_data_list = cloud_data_list.filter(createdTime__range=(satm, edtm))
vd_res = is_data_validation_defeat('id', cloud_data_id, 'not_none')
if not vd_res:
cloud_data_list = cloud_data_list.filter(id=cloud_data_id)
vd_res = is_data_validation_defeat('sj_org_code', sj_org_code, 'not_none')
if not vd_res:
cloud_data_list = cloud_data_list.filter(sJorgCode=sj_org_code)
vd_res = is_data_validation_defeat('is_reported', is_reported, 'not_none')
if not vd_res:
cloud_data_list = cloud_data_list.filter(isReported=is_reported)
current_page = get_actual_page(len(cloud_data_list), limit, current_page)
paginator = Paginator(cloud_data_list, limit)
cloud_data_list = paginator.page(current_page)
data_list = []
data = {
'count': 0,
'list': [],
'current_page': current_page
}
if cloud_data_list:
for item in cloud_data_list:
data_list.append({
"id": item.id,
"sJorgCode": item.sJorgCode,
"sJvmPlatCode": item.sJvmPlatCode,
"sJcloudBrand": item.sJcloudBrand,
"sJcloudScale": item.sJcloudScale,
"sJcloudServCount": item.sJcloudServCount,
"sJcloudServTypes": item.sJcloudServTypes,
"sJcloudAppCount": item.sJcloudAppCount,
"isReported": item.isReported,
"isDeleted": item.isDeleted,
"createdTime": item.createdTime.strftime("%Y-%m-%d %H:%M:%S") if item.createdTime else None,
"updatedTime": item.updatedTime.strftime("%Y-%m-%d %H:%M:%S")
})
data = {
'count': paginator.count,
'list': data_list,
'current_page': current_page
}
return json_resp("success", data)
except Exception as e:
print(e)
return json_resp("error", None, 500)
def fetch_police_wechat_data_list(request):
"""
获取警务微信轻应用运行监控指标
:param request:
:return:
"""
req_params = parse_json(request)
limit = req_params.get('limit', 20)
current_page = req_params.get('page', 1)
sj_org_code = req_params.get("orgCode")
police_wechat_id = req_params.get("id")
create_time_range = req_params.get("createTimeRange")
update_time_range = req_params.get("updateTimeRange")
app_name = req_params.get("appName")
is_reported = req_params.get("isReported")
try:
police_wechat_data_list = PoliceWechatData.objects.filter(
isDeleted=0).order_by("-id")
if update_time_range is not None and len(update_time_range):
satm = update_time_range[0]
edtm = update_time_range[1]
police_wechat_data_list = police_wechat_data_list.filter(
updatedTime__range=(satm, edtm))
if create_time_range is not None and len(create_time_range) == 2:
satm = create_time_range[0]
edtm = create_time_range[1]
police_wechat_data_list = police_wechat_data_list.filter(
createdTime__range=(satm, edtm))
vd_res = is_data_validation_defeat('app_name', app_name, 'not_none')
if not vd_res:
police_wechat_data_list = police_wechat_data_list.filter(
appName__icontains=app_name)
vd_res = is_data_validation_defeat('id', police_wechat_id, 'not_none')
if not vd_res:
police_wechat_data_list = police_wechat_data_list.filter(
id=police_wechat_id)
vd_res = is_data_validation_defeat('sj_org_code', sj_org_code,
'not_none')
if not vd_res:
police_wechat_data_list = police_wechat_data_list.filter(
orgCode=sj_org_code)
vd_res = is_data_validation_defeat('is_reported', is_reported,
'not_none')
if not vd_res:
police_wechat_data_list = police_wechat_data_list.filter(
isReported=is_reported)
current_page = get_actual_page(len(police_wechat_data_list), limit,
current_page)
paginator = Paginator(police_wechat_data_list, limit)
police_wechat_data_list = paginator.page(current_page)
data_list = []
data = {'count': 0, 'list': [], 'current_page': current_page}
if police_wechat_data_list:
for item in police_wechat_data_list:
data_list.append({
"id":
item.id,
"orgCode":
item.orgCode,
"agentid":
item.agentid,
"appName":
item.appName,
"checkTime":
item.checkTime,
"result":
item.result,
"expdesc":
item.expdesc,
"isReported":
item.isReported,
"isDeleted":
item.isDeleted,
"createdTime":
item.createdTime.strftime("%Y-%m-%d %H:%M:%S")
if item.createdTime else None,
"updatedTime":
item.updatedTime.strftime("%Y-%m-%d %H:%M:%S"),
})
data = {
'count': paginator.count,
'list': data_list,
'current_page': current_page
}
return json_resp("success", data)
except Exception as e:
print(e)
return json_resp("error", None, 500)
def update_police_wechat_data(request):
"""
编辑警务微信轻应用运行监控指标
:param request:
:return:
"""
req_params = parse_json(request)
police_wechat_id = req_params.get("id")
sj_org_code = req_params.get("orgCode") # 公安机关机构代码
is_reported = req_params.get("isReported")
is_deleted = req_params.get("isDeleted")
agent_id = req_params.get("agentid")
app_name = req_params.get("appName")
check_time = req_params.get("checkTime")
result = req_params.get("result")
expdesc = req_params.get("expdesc")
vd_res = is_data_validation_defeat('id', police_wechat_id, 'not_none')
if vd_res:
return json_resp(vd_res, None, 500)
try:
police_wechat_data = PoliceWechatData.objects.filter(
id=police_wechat_id).first()
if not police_wechat_data:
return json_resp("编辑失败", None, 500)
if sj_org_code is not None:
police_wechat_data.orgCode = sj_org_code
if agent_id is not None:
police_wechat_data.agentid = agent_id
if app_name is not None:
police_wechat_data.appName = app_name
if check_time is not None:
police_wechat_data.checkTime = check_time
if result is not None:
vd_res = is_data_validation_defeat('result', result, 'not_in',
[1, 0])
if vd_res:
return json_resp(vd_res, None, 500)
police_wechat_data.result = result
if expdesc is not None:
police_wechat_data.expdesc = expdesc
if is_reported is not None:
vd_res = is_data_validation_defeat('is_reported', is_reported,
'not_in', [1, 0])
if vd_res:
return json_resp(vd_res, None, 500)
police_wechat_data.isReported = is_reported
if is_deleted is not None:
vd_res = is_data_validation_defeat('is_deleted', is_deleted,
'not_in', [1, 0])
if vd_res:
return json_resp(vd_res, None, 500)
police_wechat_data.isDeleted = is_reported
police_wechat_data.createdTime = time.strftime("%Y-%m-%d %H:%M:%S",
time.localtime())
police_wechat_data.updatedTime = time.strftime("%Y-%m-%d %H:%M:%S",
time.localtime())
police_wechat_data.save()
return json_resp("success")
except Exception as e:
print(e)
return json_resp("error", None, 500)
def update_pc_room_data(request):
"""
编辑机房环境运行指标
:param request:
:return:
"""
req_params = parse_json(request)
pc_room_id = req_params.get("id")
sj_org_code = req_params.get("orgCode") # 公安机关机构代码
rm_code = req_params.get("rmCode")
env_health_value = req_params.get("envHealthValue")
power_ealth_value = req_params.get("powerHealthValue")
electr_real_power = req_params.get("electrRealPower")
ups_real_power = req_params.get("upsRealPower")
room_aver_temp = req_params.get("roomAverTemp")
room_aver_hum = req_params.get("roomAverHum")
water_leak_status = req_params.get("waterLeakStatus")
fire_status = req_params.get("fireStatus")
is_reported = req_params.get("isReported")
is_deleted = req_params.get("isDeleted")
vd_res = is_data_validation_defeat('id', pc_room_id, 'not_none')
if vd_res:
return json_resp(vd_res, None, 500)
try:
pc_room_data = PcRoomData.objects.filter(id=pc_room_id).first()
if not pc_room_data:
return json_resp("编辑失败", None, 500)
if sj_org_code is not None:
pc_room_data.orgCode = sj_org_code
if rm_code is not None:
pc_room_data.rmCode = rm_code
if env_health_value is not None:
pc_room_data.envHealthValue = env_health_value
if power_ealth_value is not None:
pc_room_data.powerHealthValue = power_ealth_value
if electr_real_power is not None:
pc_room_data.electrRealPower = electr_real_power
if ups_real_power is not None:
pc_room_data.upsRealPower = ups_real_power
if room_aver_temp is not None:
pc_room_data.roomAverTemp = room_aver_temp
if water_leak_status is not None:
pc_room_data.waterLeakStatus = water_leak_status
if room_aver_hum is not None:
pc_room_data.roomAverHum = room_aver_hum
if fire_status is not None:
pc_room_data.fireStatus = fire_status
if is_reported is not None:
vd_res = is_data_validation_defeat('is_reported', is_reported,
'not_in', [1, 0])
if vd_res:
return json_resp(vd_res, None, 500)
pc_room_data.isReported = is_reported
if is_deleted is not None:
vd_res = is_data_validation_defeat('is_deleted', is_deleted,
'not_in', [1, 0])
if vd_res:
return json_resp(vd_res, None, 500)
pc_room_data.isDeleted = is_reported
pc_room_data.createdTime = time.strftime("%Y-%m-%d %H:%M:%S",
time.localtime())
pc_room_data.updatedTime = time.strftime("%Y-%m-%d %H:%M:%S",
time.localtime())
pc_room_data.save()
return json_resp("success")
except Exception as e:
print(e)
return json_resp("error", None, 500)
def fetch_pc_room_data_list(request):
"""
获取机房环境运行指标数据
:param request:
:return:
"""
req_params = parse_json(request)
limit = req_params.get('limit', 20)
current_page = req_params.get('page', 1)
sj_org_code = req_params.get("orgCode")
pc_room_id = req_params.get("id")
create_time_range = req_params.get("createTimeRange")
update_time_range = req_params.get("updateTimeRange")
is_reported = req_params.get("isReported")
try:
pc_room_data_list = PcRoomData.objects.filter(
isDeleted=0).order_by("-id")
vd_res = is_data_validation_defeat('sj_org_code', sj_org_code,
'not_none')
if not vd_res:
pc_room_data_list = pc_room_data_list.filter(orgCode=sj_org_code)
vd_res = is_data_validation_defeat('id', pc_room_id, 'not_none')
if not vd_res:
pc_room_data_list = pc_room_data_list.filter(id=pc_room_id)
if update_time_range is not None and len(update_time_range) == 2:
satm = update_time_range[0]
edtm = update_time_range[1]
pc_room_data_list = pc_room_data_list.filter(
updatedTime__range=(satm, edtm))
if create_time_range is not None and len(create_time_range) == 2:
satm = create_time_range[0]
edtm = create_time_range[1]
pc_room_data_list = pc_room_data_list.filter(
createdTime__range=(satm, edtm))
vd_res = is_data_validation_defeat('is_reported', is_reported,
'not_none')
if not vd_res:
pc_room_data_list = pc_room_data_list.filter(
isReported=is_reported)
current_page = get_actual_page(len(pc_room_data_list), limit,
current_page)
paginator = Paginator(pc_room_data_list, limit)
pc_room_data_list = paginator.page(current_page)
data_list = []
data = {'count': 0, 'list': [], 'current_page': current_page}
if pc_room_data_list:
for item in pc_room_data_list:
data_list.append({
"id":
item.id,
"orgCode":
item.orgCode,
"rmCode":
item.rmCode,
"envHealthValue":
item.envHealthValue,
"powerHealthValue":
item.powerHealthValue,
"electrRealPower":
item.electrRealPower,
"upsRealPower":
item.upsRealPower,
"roomAverTemp":
item.roomAverTemp,
"roomAverHum":
item.roomAverHum,
"waterLeakStatus":
item.waterLeakStatus,
"fireStatus":
item.fireStatus,
"isReported":
item.isReported,
"isDeleted":
item.isDeleted,
"createdTime":
item.createdTime.strftime("%Y-%m-%d %H:%M:%S")
if item.createdTime else None,
"updatedTime":
item.updatedTime.strftime("%Y-%m-%d %H:%M:%S")
})
data = {
'count': paginator.count,
'list': data_list,
'current_page': current_page
}
return json_resp("success", data)
except Exception as e:
print(e)
return json_resp("error", None, 500)
def add_cloud_serve_type(request):
"""
新增云平台分服务类型建设情况
:param request:
:return:
"""
req_params = parse_json(request)
sj_org_code = req_params.get("sJorgCode") # 公安机关机构代码
sj_cloud_serv_type = req_params.get("sJcloudServType")
sj_cloud_serv_name = req_params.get("sJcloudServName")
sj_cloud_serv_code = req_params.get("sJcloudServCode")
sj_cloud_count = req_params.get("sJcloudcount")
sj_cloud_brand_cpu = req_params.get("sJcloudBrandCpu")
sj_cloud_brand_mem = req_params.get("sJcloudBrandMem")
sj_cloud_brand_store = req_params.get("sJcloudBrandStore")
sj_cloud_brand_band = req_params.get("sJcloudBrandBand")
is_reported = req_params.get("isReported")
is_deleted = req_params.get("isDeleted")
try:
configs = [
{
"key": "sJorgCode",
"value": sj_org_code,
"v_type": "not_none"
},
{
"key": "sJcloudServType",
"value": sj_cloud_serv_type,
"v_type": "not_none"
},
{
"key": "sJcloudServName",
"value": sj_cloud_serv_name,
"v_type": "not_none"
},
{
"key": "sJcloudServCode",
"value": sj_cloud_serv_code,
"v_type": "not_none"
},
{
"key": "sJcloudcount",
"value": sj_cloud_count,
"v_type": "not_none"
},
{
"key": "sJcloudBrandCpu",
"value": sj_cloud_brand_cpu,
"v_type": "not_none"
},
{
"key": "sJcloudBrandMem",
"value": sj_cloud_brand_mem,
"v_type": "not_none"
},
{
"key": "sJcloudBrandStore",
"value": sj_cloud_brand_store,
"v_type": "not_none"
},
{
"key": "sJcloudBrandBand",
"value": sj_cloud_brand_band,
"v_type": "not_none"
},
]
res_obj = batch_verification(configs)
if res_obj.get("msg") != "success":
return json_resp(res_obj.get("msg"), None, 500)
CloudServeType.objects.create(
sJorgCode=sj_org_code,
sJcloudServType=sj_cloud_serv_type,
sJcloudServName=sj_cloud_serv_name,
sJcloudServCode=sj_cloud_serv_code,
sJcloudcount=sj_cloud_count,
sJcloudBrandCpu=sj_cloud_brand_cpu,
sJcloudBrandMem=sj_cloud_brand_mem,
sJcloudBrandStore=sj_cloud_brand_store,
sJcloudBrandBand=sj_cloud_brand_band,
isReported=0,
isDeleted=0,
createdTime=time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()),
updatedTime=time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
return json_resp("success")
except Exception as e:
print(e)
return json_resp("error", None, 500)
def fetch_server_data_list(request):
"""
获取服务器检测指标数据
:param request:
:return:
"""
req_params = parse_json(request)
limit = req_params.get('limit', 20)
current_page = req_params.get('page', 1)
create_time_range = req_params.get("createTimeRange")
update_time_range = req_params.get("updateTimeRange")
server_data_id = req_params.get("id")
sj_org_code = req_params.get("orgCode")
is_reported = req_params.get("isReported")
dev_online_state = req_params.get("devOnlineState")
dev_alert_level = req_params.get("devAlertLevel")
try:
server_data_list = ServerData.objects.filter(
isDeleted=0).order_by("-id")
if update_time_range is not None and len(update_time_range):
satm = update_time_range[0]
edtm = update_time_range[1]
server_data_list = server_data_list.filter(
updatedTime__range=(satm, edtm))
if create_time_range is not None and len(create_time_range) == 2:
satm = create_time_range[0]
edtm = create_time_range[1]
server_data_list = server_data_list.filter(
createdTime__range=(satm, edtm))
vd_res = is_data_validation_defeat('id', server_data_id, 'not_none')
if not vd_res:
server_data_list = server_data_list.filter(id=server_data_id)
vd_res = is_data_validation_defeat('sj_org_code', sj_org_code,
'not_none')
if not vd_res:
server_data_list = server_data_list.filter(orgCode=sj_org_code)
vd_res = is_data_validation_defeat('is_reported', is_reported,
'not_none')
if not vd_res:
server_data_list = server_data_list.filter(isReported=is_reported)
vd_res = is_data_validation_defeat('devOnlineState', dev_online_state,
'not_none')
if not vd_res:
server_data_list = server_data_list.filter(
devOnlineState=dev_online_state)
vd_res = is_data_validation_defeat('devAlertLevel', dev_alert_level,
'not_none')
if not vd_res:
server_data_list = server_data_list.filter(
devAlertLevel=dev_alert_level)
current_page = get_actual_page(len(server_data_list), limit,
current_page)
paginator = Paginator(server_data_list, limit)
server_data_list = paginator.page(current_page)
data_list = []
data = {'count': 0, 'list': [], 'current_page': current_page}
if server_data_list:
for item in server_data_list:
data_list.append({
"id":
item.id,
"orgCode":
item.orgCode,
"ciId":
item.ciId,
"devOnlineState":
item.devOnlineState,
"devResponseTime":
item.devResponseTime,
"devAlertLevel":
item.devAlertLevel,
"devCpuRate":
item.devCpuRate,
"devMemRate":
item.devMemRate,
"devDiskRate":
item.devDiskRate,
"isReported":
item.isReported,
"isDeleted":
item.isDeleted,
"createdTime":
item.createdTime.strftime("%Y-%m-%d %H:%M:%S")
if item.createdTime else None,
"updatedTime":
item.updatedTime.strftime("%Y-%m-%d %H:%M:%S"),
})
data = {
'count': paginator.count,
'list': data_list,
'current_page': current_page
}
return json_resp("success", data)
except Exception as e:
print(e)
return json_resp("error", None, 500)
def fetch_fault_alert_list(request):
"""
获取故障告警数据
:param request:
:return:
"""
req_params = parse_json(request)
limit = req_params.get('limit', 20)
current_page = req_params.get('page', 1)
sj_org_code = req_params.get("orgCode")
cloud_serve_type_id = req_params.get("id")
create_time_range = req_params.get("createTimeRange")
update_time_range = req_params.get("updateTimeRange")
is_reported = req_params.get("isReported")
severity = req_params.get("severity")
try:
cloud_serve_type_list = FaultAlert.objects.filter(
isDeleted=0).order_by("-id")
if update_time_range is not None and len(update_time_range) == 2:
satm = update_time_range[0]
edtm = update_time_range[1]
cloud_serve_type_list = cloud_serve_type_list.filter(
updatedTime__range=(satm, edtm))
if create_time_range is not None and len(create_time_range) == 2:
satm = create_time_range[0]
edtm = create_time_range[1]
cloud_serve_type_list = cloud_serve_type_list.filter(
createdTime__range=(satm, edtm))
vd_res = is_data_validation_defeat('id', cloud_serve_type_id,
'not_none')
if not vd_res:
cloud_serve_type_list = cloud_serve_type_list.filter(
id=cloud_serve_type_id)
vd_res = is_data_validation_defeat('sj_org_code', sj_org_code,
'not_none')
if not vd_res:
cloud_serve_type_list = cloud_serve_type_list.filter(
orgCode=sj_org_code)
vd_res = is_data_validation_defeat('is_reported', is_reported,
'not_none')
if not vd_res:
cloud_serve_type_list = cloud_serve_type_list.filter(
isReported=is_reported)
vd_res = is_data_validation_defeat('severity', severity, 'not_none')
if not vd_res:
cloud_serve_type_list = cloud_serve_type_list.filter(
severity=severity)
current_page = get_actual_page(len(cloud_serve_type_list), limit,
current_page)
paginator = Paginator(cloud_serve_type_list, limit)
cloud_serve_type_list = paginator.page(current_page)
data_list = []
data = {'count': 0, 'list': [], 'current_page': current_page}
if cloud_serve_type_list:
for item in cloud_serve_type_list:
data_list.append({
"id":
item.id,
"orgCode":
item.orgCode,
"alertId":
item.alertId,
"name":
item.name,
"severity":
item.severity,
"description":
item.description,
"entityName":
item.entityName,
"entityAddr":
item.entityAddr,
"firstTime":
item.firstTime,
"lastTime":
item.lastTime,
"properties":
item.properties,
"ciId":
item.ciId,
"proStatus":
item.proStatus,
"orderNo":
item.orderNo,
"isReported":
item.isReported,
"isDeleted":
item.isDeleted,
"createdTime":
item.createdTime.strftime("%Y-%m-%d %H:%M:%S")
if item.createdTime else None,
"updatedTime":
item.updatedTime.strftime("%Y-%m-%d %H:%M:%S"),
})
data = {
'count': paginator.count,
'list': data_list,
'current_page': current_page
}
return json_resp("success", data)
except Exception as e:
print(e)
return json_resp("error", None, 500)
def fetch_soft_data_list(request):
"""
获取软件实例运行指标数据
:param request:
:return:
"""
req_params = parse_json(request)
limit = req_params.get('limit', 20)
current_page = req_params.get('page', 1)
create_time_range = req_params.get("createTimeRange")
update_time_range = req_params.get("updateTimeRange")
server_data_id = req_params.get("id")
sj_org_code = req_params.get("orgCode")
is_reported = req_params.get("isReported")
try:
soft_data_list = SoftData.objects.filter(isDeleted=0).order_by("-id")
if update_time_range is not None and len(update_time_range):
satm = update_time_range[0]
edtm = update_time_range[1]
soft_data_list = soft_data_list.filter(updatedTime__range=(satm,
edtm))
if create_time_range is not None and len(create_time_range) == 2:
satm = create_time_range[0]
edtm = create_time_range[1]
soft_data_list = soft_data_list.filter(createdTime__range=(satm,
edtm))
vd_res = is_data_validation_defeat('id', server_data_id, 'not_none')
if not vd_res:
soft_data_list = soft_data_list.filter(id=server_data_id)
vd_res = is_data_validation_defeat('sj_org_code', sj_org_code,
'not_none')
if not vd_res:
soft_data_list = soft_data_list.filter(orgCode=sj_org_code)
vd_res = is_data_validation_defeat('sj_org_code', is_reported,
'not_none')
if not vd_res:
soft_data_list = soft_data_list.filter(isReported=is_reported)
current_page = get_actual_page(len(soft_data_list), limit,
current_page)
paginator = Paginator(soft_data_list, limit)
soft_data_list = paginator.page(current_page)
data_list = []
data = {'count': 0, 'list': [], 'current_page': current_page}
if soft_data_list:
for item in soft_data_list:
data_list.append({
"id":
item.id,
"orgCode":
item.orgCode,
"ciId":
item.ciId,
"runningState":
item.runningState,
"tcpState":
item.tcpState,
"webResponseTime":
item.webResponseTime,
"isReported":
item.isReported,
"isDeleted":
item.isDeleted,
"createdTime":
item.createdTime.strftime("%Y-%m-%d %H:%M:%S")
if item.createdTime else None,
"updatedTime":
item.updatedTime.strftime("%Y-%m-%d %H:%M:%S"),
})
data = {
'count': paginator.count,
'list': data_list,
'current_page': current_page
}
orcaletest()
return json_resp("success", data)
except Exception as e:
print(e)
return json_resp("error", None, 500)
def police(request):
"""
派出所
:param request:
:return:
"""
req_params = parse_json(request)
limit = req_params.get('limit', 20)
current_page = req_params.get('page', 1)
sj_org_code = req_params.get("SJ_ORG_CODE")
sj_rm_name = req_params.get("SJ_RM_NAME")
sj_is_th_mon = req_params.get("SJ_IS_TH_MON")
sj_is_water_mon = req_params.get("SJ_IS_WATER_MON")
sj_is_fire_mon = req_params.get("SJ_IS_FIRE_MON")
try:
machine_room = MachineRoom.objects.filter(isDeleted=0).order_by("-id")
vd_res = is_data_validation_defeat('SJ_ORG_CODE', sj_org_code,
'not_none')
if not vd_res:
machine_room = machine_room.filter(sJorgCode=sj_org_code)
vd_res = is_data_validation_defeat('SJ_RM_NAME', sj_rm_name,
'not_none')
if not vd_res:
machine_room = machine_room.filter(sJrmName__contains=sj_rm_name)
vd_res = is_data_validation_defeat('SJ_IS_TH_MON', sj_is_th_mon,
'not_none')
if not vd_res:
machine_room = machine_room.filter(sJisWatermon=sj_is_water_mon)
vd_res = is_data_validation_defeat('SJ_IS_FIRE_MON', sj_is_fire_mon,
'not_none')
if not vd_res:
machine_room = machine_room.filter(sJisFiremon=sj_is_fire_mon)
current_page = get_actual_page(len(machine_room), limit, current_page)
paginator = Paginator(machine_room, limit)
machine_room = paginator.page(current_page)
data_list = []
data = {'count': 0, 'list': [], 'current_page': current_page}
if machine_room:
for item in machine_room:
data_list.append({
"id": item.id,
"SJ_ORG_CODE": item.sJorgCode,
"SJ_RM_NAME": item.sJrmName,
"SJ_RM_CODE": item.sJrmCode,
"SJ_RM_POSITION": item.sJrmPosition,
"SJ_CAB_COUNT": item.sJcabCount,
"SJ_CAB_INSTALLED": item.sJcabInstalled,
"SJ_SD_TOTAL_CAPACITY": item.sJsdTotalCapacity,
"SJ_UPS_CAPACITY": item.sJupsCapacity,
"SJ_AIR_COUNT": item.sJairCount,
"SJ_IS_TH_MON": item.sJisTHmon,
"SJ_IS_WATER_MON": item.sJisWatermon,
"SJ_IS_FIRE_MON": item.sJisFiremon
})
data = {
'count': paginator.count,
'list': data_list,
'current_page': current_page
}
return json_resp("success", data)
except Exception as e:
print(e)
return json_resp("error", None, 500)
def branch(request):
req_params = parse_json(request)
limit = req_params.get('limit', 20)
current_page = req_params.get('page', 1)
sj_org_code = req_params.get("SJ_ORG_CODE")
sj_rm_name = req_params.get("SJ_RM_NAME")
sj_is_th_mon = req_params.get("SJ_IS_TH_MON")
sj_is_water_mon = req_params.get("SJ_IS_WATER_MON")
sj_is_fire_mon = req_params.get("SJ_IS_FIRE_MON")
# 执行sql语句
table_name = "v_room_situation_9"
try:
keywords = []
if sj_org_code is not None and len(sj_org_code.strip()) > 0:
keywords.append({
"key": "SJ_ORG_CODE",
"value": sj_org_code,
"condition": "="
})
if sj_rm_name is not None and len(sj_rm_name.strip()) > 0:
keywords.append({
"key": "SJ_RM_NAME",
"value": sj_rm_name + "",
"condition": "like"
})
if sj_is_th_mon in [10, 20]:
keywords.append({
"key": "SJ_IS_TH_MON",
"value": str(sj_is_th_mon),
"condition": "="
})
if sj_is_water_mon in [10, 20]:
keywords.append({
"key": "SJ_IS_WATER_MON",
"value": str(sj_is_water_mon),
"condition": "="
})
if sj_is_fire_mon in [10, 20]:
keywords.append({
"key": "SJ_IS_FIRE_MON",
"value": str(sj_is_fire_mon),
"condition": "="
})
sql, con_sql = splice_sql(table_name,
limit,
current_page,
keywords=keywords)
oracle_execute_sql = OracleExecuteSQL()
object_list = oracle_execute_sql.fetchall_to_dict(sql)
count = oracle_execute_sql.fetchone_to_dict(con_sql)
data = {
'count': count.get("COUNT", 0),
'list': object_list,
'current_page': current_page
}
return json_resp("success", data)
except Exception as e:
print(e)
return json_resp("error", None, 500)
def update_cloud_data(request):
"""
编辑云平台总体建设情况数据
:param request:
:return:
"""
req_params = parse_json(request)
cloud_data_id = req_params.get("id")
sj_org_code = req_params.get("sJorgCode") # 公安机关机构代码
sj_vm_plat_code = req_params.get("sJvmPlatCode")
sj_cloud_brand = req_params.get("sJcloudBrand")
sj_cloud_scale = req_params.get("sJcloudScale")
sj_cloud_serv_count = req_params.get("sJcloudServCount")
sj_cloud_serv_types = req_params.get("sJcloudServTypes")
sj_cloud_app_count = req_params.get("sJcloudAppCount")
is_reported = req_params.get("isReported")
is_deleted = req_params.get("isDeleted")
vd_res = is_data_validation_defeat('id', cloud_data_id, 'not_none')
if vd_res:
return json_resp(vd_res, None, 500)
try:
cloud_data = CloudDataAll.objects.filter(id=cloud_data_id).first()
if not cloud_data:
return json_resp("编辑失败", None, 500)
if sj_org_code is not None:
cloud_data.sJorgCode = sj_org_code
if sj_vm_plat_code is not None:
cloud_data.sJvmPlatCode = sj_vm_plat_code
if sj_cloud_brand is not None:
cloud_data.sJcloudBrand = sj_cloud_brand
if sj_cloud_scale is not None:
vd_res = is_data_validation_defeat('sj_cloud_scale', sj_cloud_scale, 'not_none')
if not vd_res:
cloud_data.sJcloudScale = sj_cloud_scale
else:
return json_resp(vd_res, None, 500)
if sj_cloud_serv_count is not None:
vd_res = is_data_validation_defeat('sj_cloud_serv_count', sj_cloud_serv_count, 'not_none')
if not vd_res:
cloud_data.sJcloudServCount = sj_cloud_serv_count
else:
return json_resp(vd_res, None, 500)
if sj_cloud_serv_types is not None:
cloud_data.sJcloudServTypes = sj_cloud_serv_types
if sj_cloud_app_count is not None:
vd_res = is_data_validation_defeat('sj_cloud_app_count', sj_cloud_app_count, 'not_none')
if not vd_res:
cloud_data.sJcloudAppCount = sj_cloud_app_count
else:
return json_resp(vd_res, None, 500)
if is_reported is not None:
vd_res = is_data_validation_defeat('is_reported', is_reported, 'not_in', [1, 0])
if not vd_res:
cloud_data.isReported = is_reported
else:
return json_resp(vd_res, None, 500)
if is_deleted is not None:
vd_res = is_data_validation_defeat('is_deleted', is_deleted, 'not_in', [1, 0])
if not vd_res:
cloud_data.isDeleted = is_reported
else:
return json_resp(vd_res, None, 500)
cloud_data.createdTime = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
cloud_data.updatedTime = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
cloud_data.save()
return json_resp("success")
except Exception as e:
print(e)
return json_resp("error", None, 500)
def update_base_soft(request):
"""
更新基础软件实例数据
:param request:
:return:
"""
req_params = parse_json(request)
base_soft_id = req_params.get("id")
sj_org_code = req_params.get("sJorgCode") # 公安机关机构代码
sj_soft_type = req_params.get("sJsoftType") # 软件类型1.数据库；2.中间件；9.其他
sj_soft_name = req_params.get("sJsoftName")
sj_soft_version = req_params.get("sJsoftVersion")
sj_soft_ip = req_params.get("sJsoftIp")
sj_soft_port = req_params.get("sJsoftPort")
is_reported = req_params.get("isReported")
is_deleted = req_params.get("isDeleted")
vd_res = is_data_validation_defeat('id', base_soft_id, 'not_none')
if vd_res:
return json_resp(vd_res, None, 500)
try:
base_soft_data = BaseSoftData.objects.filter(id=base_soft_id).first()
if not base_soft_data:
return json_resp("编辑失败", None, 500)
if sj_org_code is not None:
base_soft_data.sJorgCode = sj_org_code
if sj_soft_type is not None:
vd_res = is_data_validation_defeat('sj_soft_type', sj_soft_type,
'not_in', [1, 2, 9])
if vd_res:
return json_resp(vd_res, None, 500)
base_soft_data.sJsoftType = sj_soft_type
if sj_soft_name is not None:
vd_res = is_data_validation_defeat('sj_soft_name', sj_soft_name,
'not_none')
if vd_res:
return json_resp(vd_res, None, 500)
base_soft_data.sJsoftName = sj_soft_name
if sj_soft_version is not None:
base_soft_data.sJsoftVersion = sj_soft_version
if sj_soft_ip is not None:
base_soft_data.sJsoftIp = sj_soft_ip
if sj_soft_port is not None:
base_soft_data.sJsoftPort = sj_soft_port
if is_reported is not None:
vd_res = is_data_validation_defeat('is_reported', is_reported,
'not_in', [1, 0])
if vd_res:
return json_resp(vd_res, None, 500)
base_soft_data.isReported = is_reported
if is_deleted is not None:
vd_res = is_data_validation_defeat('is_deleted', is_deleted,
'not_in', [1, 0])
if vd_res:
return json_resp(vd_res, None, 500)
base_soft_data.isDeleted = is_reported
base_soft_data.createdTime = time.strftime("%Y-%m-%d %H:%M:%S",
time.localtime())
base_soft_data.updatedTime = time.strftime("%Y-%m-%d %H:%M:%S",
time.localtime())
base_soft_data.save()
return json_resp("success")
except Exception as e:
print(e)
return json_resp("error", None, 500)
def fetch_base_soft_list(request):
"""
获取基础软件实例列表数据
:param request:
:return:
"""
req_params = parse_json(request)
limit = req_params.get('limit', 20)
base_soft_id = req_params.get("id")
current_page = req_params.get('page', 1)
sj_org_code = req_params.get("sJorgCode")
sj_soft_name = req_params.get("sJsoftName")
is_reported = req_params.get("isReported")
sj_soft_type = req_params.get("sJsoftType") # 软件类型1.数据库；2.中间件；9.其他
create_time_range = req_params.get("createTimeRange")
update_time_range = req_params.get("updateTimeRange")
try:
base_soft_list = BaseSoftData.objects.filter(
isDeleted=0).order_by("-id")
vd_res = is_data_validation_defeat('id', base_soft_id, 'not_none')
if not vd_res:
base_soft_list = base_soft_list.filter(id=base_soft_id)
vd_res = is_data_validation_defeat('sj_soft_name', sj_soft_name,
'not_none')
if not vd_res:
base_soft_list = base_soft_list.filter(
sJsoftName__contains=sj_soft_name)
vd_res = is_data_validation_defeat('sj_org_code', sj_org_code,
'not_none')
if not vd_res:
base_soft_list = base_soft_list.filter(sJorgCode=sj_org_code)
vd_res = is_data_validation_defeat('is_reported', is_reported,
'not_none')
if not vd_res:
base_soft_list = base_soft_list.filter(isReported=is_reported)
vd_res = is_data_validation_defeat('sj_soft_type', sj_soft_type,
'not_none')
if not vd_res:
base_soft_list = base_soft_list.filter(sJsoftType=sj_soft_type)
if update_time_range is not None and len(update_time_range) == 2:
satm = update_time_range[0]
edtm = update_time_range[1]
base_soft_list = base_soft_list.filter(updatedTime__range=(satm,
edtm))
if create_time_range is not None and len(create_time_range) == 2:
satm = create_time_range[0]
edtm = create_time_range[1]
base_soft_list = base_soft_list.filter(createdTime__range=(satm,
edtm))
current_page = get_actual_page(len(base_soft_list), limit,
current_page)
paginator = Paginator(base_soft_list, limit)
base_soft_list = paginator.page(current_page)
data_list = []
data = {'count': 0, 'list': [], 'current_page': current_page}
if base_soft_list:
for item in base_soft_list:
data_list.append({
"id":
item.id,
"sJorgCode":
item.sJorgCode,
"sJsoftType":
item.sJsoftType,
"sJsoftName":
item.sJsoftName,
"sJsoftVersion":
item.sJsoftVersion,
"sJsoftIp":
item.sJsoftIp,
"sJsoftPort":
item.sJsoftPort,
"isReported":
item.isReported,
"isDeleted":
item.isDeleted,
"sJsortCode":
None,
"createdTime":
item.createdTime.strftime("%Y-%m-%d %H:%M:%S")
if item.createdTime else None,
"updatedTime":
item.updatedTime.strftime("%Y-%m-%d %H:%M:%S"),
})
data = {
'count': paginator.count,
'list': data_list,
'current_page': current_page
}
return json_resp("success", data)
except Exception as e:
print(e)
return json_resp("error", None, 500)
def add_base_soft(request):
"""
新增基础软件实例数据
:param request:
:return:
"""
req_params = parse_json(request)
sj_org_code = req_params.get("sJorgCode") # 公安机关机构代码
sj_soft_type = req_params.get("sJsoftType") # 软件类型1.数据库；2.中间件；9.其他
sj_soft_name = req_params.get("sJsoftName")
sj_soft_version = req_params.get("sJsoftVersion")
sj_soft_ip = req_params.get("sJsoftIp")
sj_soft_port = req_params.get("sJsoftPort")
is_reported = req_params.get("isReported")
is_deleted = req_params.get("isDeleted")
try:
configs = [
{
"key": "sJorgCode",
"value": sj_org_code,
"v_type": "not_none"
},
{
"key": "sJsoftType",
"value": sj_soft_type,
"v_type": "not_none"
},
{
"key": "sJsoftName",
"value": sj_soft_name,
"v_type": "not_none"
},
{
"key": "sJsoftVersion",
"value": sj_soft_version,
"v_type": "not_none"
},
{
"key": "sJsoftIp",
"value": sj_soft_ip,
"v_type": "not_none"
},
{
"key": "sJsoftPort",
"value": sj_soft_port,
"v_type": "not_none"
},
]
res_obj = batch_verification(configs)
if res_obj.get("msg") != "success":
return json_resp(res_obj.get("msg"), None, 500)
BaseSoftData.objects.create(
sJorgCode=sj_org_code,
sJsoftType=sj_soft_type,
sJsoftName=sj_soft_name,
sJsoftVersion=sj_soft_version,
sJsoftIp=sj_soft_ip,
sJsoftPort=sj_soft_port,
isReported=0,
isDeleted=0,
createdTime=time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()),
updatedTime=time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
return json_resp("success")
except Exception as e:
print(e)
return json_resp("error", None, 500)
def update_server_data(request):
"""
编辑服务器检测指标
:param request:
:return:
"""
req_params = parse_json(request)
server_data_id = req_params.get("id")
sj_org_code = req_params.get("orgCode") # 公安机关机构代码
is_reported = req_params.get("isReported")
is_deleted = req_params.get("isDeleted")
ci_id = req_params.get("ciId")
dev_online_state = req_params.get("devOnlineState")
dev_response_time = req_params.get("devResponseTime")
dev_alert_level = req_params.get("devAlertLevel")
dev_cpu_rate = req_params.get("devCpuRate")
dev_mem_rate = req_params.get("devMemRate")
dev_disk_rate = req_params.get("devDiskRate")
vd_res = is_data_validation_defeat('id', server_data_id, 'not_none')
if vd_res:
return json_resp(vd_res, None, 500)
try:
server_data = ServerData.objects.filter(id=server_data_id).first()
if not server_data:
return json_resp("编辑失败", None, 500)
configs = [
{
"key": "orgCode",
"value": sj_org_code,
"v_type": "not_none"
},
{
"key": "ciId",
"value": ci_id,
"v_type": "not_none"
},
{
"key": "devOnlineState",
"value": dev_online_state,
"v_type": "not_none"
},
{
"key": "devResponseTime",
"value": dev_response_time,
"v_type": "not_none"
},
{
"key": "devAlertLevel",
"value": dev_alert_level,
"v_type": "not_in",
"param": [3, 2, 1, 0]
},
{
"key": "devCpuRate",
"value": dev_cpu_rate,
"v_type": "not_none"
},
{
"key": "devMemRate",
"value": dev_mem_rate,
"v_type": "not_none"
},
{
"key": "devDiskRate",
"value": dev_disk_rate,
"v_type": "not_none"
},
{
"key": "isReported",
"value": is_reported,
"v_type": "not_in",
"param": [1, 0]
},
{
"key": "isDeleted",
"value": is_deleted,
"v_type": "not_in",
"param": [1, 0]
},
]
res_obj = set_attr_by_data_valid(server_data, configs)
if res_obj.get("msg") == "success":
server_data = res_obj.get("obj")
else:
return json_resp(res_obj.get("msg"), None, 500)
server_data.createdTime = time.strftime("%Y-%m-%d %H:%M:%S",
time.localtime())
server_data.updatedTime = time.strftime("%Y-%m-%d %H:%M:%S",
time.localtime())
server_data.save()
return json_resp("success")
except Exception as e:
print(e)
return json_resp("error", None, 500)
def update_cloud_serve_type(request):
"""
编辑云平台分服务类型建设情况
:param request:
:return:
"""
req_params = parse_json(request)
cloud_serve_type_id = req_params.get("id")
sj_org_code = req_params.get("sJorgCode") # 公安机关机构代码
sj_cloud_serv_type = req_params.get("sJcloudServType")
sj_cloud_serv_name = req_params.get("sJcloudServName")
sj_cloud_serv_code = req_params.get("sJcloudServCode")
sj_cloud_count = req_params.get("sJcloudcount")
sj_cloud_brand_cpu = req_params.get("sJcloudBrandCpu")
sj_cloud_brand_mem = req_params.get("sJcloudBrandMem")
sj_cloud_brand_store = req_params.get("sJcloudBrandStore")
sj_cloud_brand_band = req_params.get("sJcloudBrandBand")
is_reported = req_params.get("isReported")
is_deleted = req_params.get("isDeleted")
vd_res = is_data_validation_defeat('id', cloud_serve_type_id, 'not_none')
if vd_res:
return json_resp(vd_res, None, 500)
try:
cloud_serve_type = CloudServeType.objects.filter(
id=cloud_serve_type_id).first()
if not cloud_serve_type:
return json_resp("编辑失败", None, 500)
if sj_org_code is not None:
cloud_serve_type.sJorgCode = sj_org_code
if sj_cloud_serv_type is not None:
cloud_serve_type.sJcloudServType = sj_cloud_serv_type
if sj_cloud_serv_name is not None:
cloud_serve_type.sJcloudServName = sj_cloud_serv_name
if sj_cloud_serv_code is not None:
cloud_serve_type.sJcloudServCode = sj_cloud_serv_code
if sj_cloud_count is not None:
vd_res = is_data_validation_defeat('sj_cloud_count',
sj_cloud_count, 'not_none')
if vd_res:
return json_resp(vd_res, None, 500)
cloud_serve_type.sJcloudcount = sj_cloud_count
if sj_cloud_brand_cpu is not None:
vd_res = is_data_validation_defeat('sj_cloud_brand_cpu',
sj_cloud_brand_cpu, 'not_none')
if vd_res:
return json_resp(vd_res, None, 500)
cloud_serve_type.sJcloudBrandCpu = sj_cloud_brand_cpu
if sj_cloud_brand_mem is not None:
vd_res = is_data_validation_defeat('sj_cloud_brand_mem',
sj_cloud_brand_mem, 'not_none')
if vd_res:
return json_resp(vd_res, None, 500)
cloud_serve_type.sJcloudBrandMem = sj_cloud_brand_mem
if sj_cloud_brand_store is not None:
vd_res = is_data_validation_defeat('sj_cloud_brand_store',
sj_cloud_brand_store,
'not_none')
if vd_res:
return json_resp(vd_res, None, 500)
cloud_serve_type.sJcloudBrandStore = sj_cloud_brand_store
if sj_cloud_brand_band is not None:
vd_res = is_data_validation_defeat('sj_cloud_brand_band',
sj_cloud_brand_band, 'not_none')
if vd_res:
return json_resp(vd_res, None, 500)
cloud_serve_type.sJcloudBrandBand = sj_cloud_brand_band
if is_reported is not None:
vd_res = is_data_validation_defeat('is_reported', is_reported,
'not_in', [1, 0])
if vd_res:
return json_resp(vd_res, None, 500)
cloud_serve_type.isReported = is_reported
if is_deleted is not None:
vd_res = is_data_validation_defeat('is_deleted', is_deleted,
'not_in', [1, 0])
if vd_res:
return json_resp(vd_res, None, 500)
cloud_serve_type.isDeleted = is_reported
cloud_serve_type.createdTime = time.strftime("%Y-%m-%d %H:%M:%S",
time.localtime())
cloud_serve_type.updatedTime = time.strftime("%Y-%m-%d %H:%M:%S",
time.localtime())
cloud_serve_type.save()
return json_resp("success")
except Exception as e:
print(e)
return json_resp("error", None, 500)
