def post(self, request, *args, **kwargs):
response = BaseResponse()
url_str = ''
fresh_type_ = ''
fresh_type = request.POST.get('fresh_type')
fresh_content = request.POST.get('fresh_content')
fresh_content_list = fresh_content.split('\n')
for u in fresh_content_list:
url_str = url_str + '"' + u + '"'
url_str = url_str.replace('""', '","')
if fresh_type == '目录':
fresh_type = 'dir'
msg = '{"urls":[' + url_str + '],"type":"' + fresh_type + '"}'
msg = json.dumps(msg)
current_time = time.strftime('%Y-%m-%d %H:%M:%S',
time.localtime(time.time()))
try:
cdn_res = curl_post(url_token, msg)
print(cdn_res)
if '{"code":0,' in cdn_res[0]:
response.data = '执行成功！'
if fresh_type == 'url':
fresh_type_ = 'URL刷新'
elif fresh_type == '目录':
fresh_type_ = '目录刷新'
for u in fresh_content_list:
models.CdnFreshRecord.objects.create(
fresh_content=u,
fresh_type=fresh_type_,
fresh_time=current_time,
stats='完成')
except Exception as e:
response.data = str(e)
return HttpResponse(json.dumps(response.data))
def post_business(request):
response = BaseResponse()
try:
hostname = request.POST.get('hostname', None)
manage_ip = request.POST.get('manage_ip', None)
device_type_id = request.POST.get('device_type_id', None)
device_status_id = request.POST.get('device_status_id', None)
idc_id = request.POST.get('idc_id', None)
business_unit_id = request.POST.get('business_unit_id', None)
cabinet_num = request.POST.get('cabinet_num', None)
cabinet_order = request.POST.get('cabinet_order', None)
# add_dict = QueryDict(request.body, encoding='utf-8')
# print('add_dict', add_dict)
# print(hostname, manage_ip, device_type_id, device_status_id, idc_id, business_unit_id)
obj_asset = models.Asset.objects.create(device_type_id=device_type_id, device_status_id=device_status_id,
cabinet_num=cabinet_num, cabinet_order=cabinet_order,
business_unit_id=business_unit_id, idc_id=idc_id)
print('newobj_asset_id', obj_asset.id)
if 1 == int(device_type_id):
models.Server.objects.create(hostname=hostname, manage_ip=manage_ip, asset_id=obj_asset.id)
elif 2 == int(device_type_id):
models.NetworkDevice.objects.create(hostname=hostname, manage_ip=manage_ip, asset_id=obj_asset.id)
if obj_asset:
response.message = '添加资产成功'
else:
response.error = '添加资产失败'
except Exception as e:
response.status = False
response.message = str(e)
return response
pass
def update_urlmaps_groups(request):
response = BaseResponse()
try:
response.error = {}
post_dict = QueryDict(request.body, encoding='utf-8')
urlmaps_id = post_dict.get('urlmaps_id')
instance_list = post_dict.getlist('instance_list')
group_type = post_dict.get('group_type')
urlmaps_obj = repository_models.UrlConfigHandler.objects.get(
id=urlmaps_id)
if group_type == 'cloud':
urlmaps_obj.cloud.clear()
for instance_id in instance_list:
urlmaps_obj.cloud.add(
CMDB_MODELS.Asset.objects.get(id=instance_id))
elif group_type == 'forward':
urlmaps_obj.forward.clear()
for instance_id in instance_list:
urlmaps_obj.forward.add(
CMDB_MODELS.Asset.objects.get(id=instance_id))
elif group_type == 'docker':
urlmaps_obj.docker.clear()
for instance_id in instance_list:
urlmaps_obj.docker.add(
CMDB_MODELS.DockerInstance.objects.get(id=instance_id))
except Exception as e:
print(Exception, e)
response.status = False
response.message = str(e)
return response
def fetch_assets(self, request):
response = BaseResponse()
try:
ret = {}
conditions = self.assets_condition(request) # 根据搜索条件构造 q 对象
asset_count = models.Asset.objects.filter(conditions).count() # 根据搜索条件统计搜索总数量
page_info = PageInfo(request.GET.get('pager', None), asset_count) # 使用 PageInfo 构造 分页
asset_list = models.Asset.objects.filter(conditions).extra(select=self.extra_select).values(*self.values_list)[page_info.start:page_info.end]
ret['table_config'] = self.table_config
ret['condition_config'] = self.condition_config
ret['data_list'] = list(asset_list)
ret['page_info'] = {
"page_str": page_info.pager(),
"page_start": page_info.start,
}
ret['global_dict'] = {
'device_status_list': self.device_status_list,
'device_type_list': self.device_type_list,
'idc_list': self.idc_list,
'business_unit_list': self.business_unit_list,
'tagName_list': self.tagName_list(ret['data_list']), # 用作资产表中 对应的标签名称
'tag_name_list': self.tag_name_list, # 用作搜索条件处显示标签名称搜索条件
}
response.data = ret
response.status = True
response.message = '获取成功'
except Exception as e:
response.status = False
response.message = str(e)
return response
def post(self, request, *args, **kwargs):
"""
用于用户认证相关接口
:param request:
:param args:
:param kwargs:
:return:
"""
print(request.data)
# ret = {"code":100,'data':None}
ret = BaseResponse()
try:
user = request.data.get('user')
pwd = request.data.get('pwd')
obj = models.UserInfo.objects.filter(user=user, pwd=pwd).first()
# obj = models.UserInfo.objects.get(user=user,pwd=pwd)
if not user: # 简单逻辑往上放
ret.code = 400
ret.error = "错误的用户名或密码"
return Response(ret)
token = str(uuid.uuid4())
models.Token.objects.update_or_create(
user=obj, defaults={"token": token}) # defaults字段用于更新
ret.token = token
except Exception as e:
ret.code = 1002
ret.msg = e
# obj = Response('...')
# obj['Access-Control-Allow-Origin'] = "*"
return Response(ret.dict)
def get_untreated_servers():
response = BaseResponse()
try:
current_date = datetime.date.today()
condition = Q()
# 今日未采集的资产
con_date = Q()
con_date.connector = 'OR'
con_date.children.append(("asset__latest_date__lt", current_date))
con_date.children.append(("asset__latest_date", None))
# 在线状态的服务器
con_status = Q()
con_status.children.append(('asset__device_status_id', '2'))
condition.add(con_date, 'AND')
condition.add(con_status, 'AND')
result = models.Server.objects.filter(condition).values('hostname')
response.data = list(result)
response.status = True
except Exception as e:
response.message = str(e)
models.ErrorLog.objects.create(asset_obj=None, title='get_untreated_servers', content=traceback.format_exc())
return response
def process(server_obj, server_info, user_obj):
response = BaseResponse()
try:
mem_info = server_info['memory']
if not mem_info['status']:
models.ErrorLog.objects.create(asset_obj=server_obj.asset, title='memory-agent',
content=mem_info['error'])
response.status = False
return response
client_mem_dict = mem_info['data']
mem_obj_list = models.Memory.objects.filter(server_obj=server_obj)
mem_slots = map(lambda x: x, (item.slot for item in mem_obj_list))
update_list = agorithm.get_intersection(set(client_mem_dict.keys()), set(mem_slots))
add_list = agorithm.get_exclude(client_mem_dict.keys(), update_list)
del_list = agorithm.get_exclude(mem_slots, update_list)
HandleMemory._add_memory(add_list, client_mem_dict, server_obj, user_obj)
HandleMemory._update_memory(update_list, mem_obj_list, client_mem_dict, server_obj, user_obj)
HandleMemory._del_memory(del_list, mem_obj_list, server_obj, user_obj)
except Exception as e:
response.status = False
models.ErrorLog.objects.create(asset_obj=server_obj.asset, title='memory-run',
content=traceback.format_exc())
return response
def post(self, request, *args, **kwargs):
response = BaseResponse()
n1 = json.loads(request.body.decode('utf-8'))
n1 = json.loads(n1)
r_id = n1.get('id', None)
msg = n1.get('msg', None)
# 上传包md5值
md5 = n1.get('md5', None)
if md5:
print(md5)
models.ReleaseTask.objects.filter(id=r_id).update(release_md5=md5)
models.ReleaseLog.objects.create(release_id=r_id, release_msg=md5)
# 发布任务成功上传
response.status = True
return JsonResponse(response.__dict__)
print(r_id, msg)
try:
models.ReleaseLog.objects.create(release_id=r_id, release_msg=msg)
response.status = True
except Exception as e:
response.status = False
obj = models.ReleaseLog.objects.filter(release_time__gt='2017-05-19 05:00').first()
print(obj.release_time)
return JsonResponse(response.__dict__)
def get_instance_by_id(request):
response = BaseResponse()
instance_id = request.GET.get('instance_id')
get_edit_instance_data = CMDB_MODELS.Asset.objects.filter(
id=instance_id).values("id", "instances__id")
response.data = list(get_edit_instance_data)
return response.data
def assets_add(request):
response = BaseResponse()
obj = forms.AddAssetForm(request.POST)
if obj.is_valid():
hostname = obj.cleaned_data.pop('hostname')
Server_obj = models.Server.objects.filter(hostname=hostname)
if Server_obj: # 判断主机名是否存在
# 主机名已经存在
obj.errors['hostname'] = ["主机名已存在"]
else:
tag_list = obj.cleaned_data.pop('tag')
Asset_obj = models.Asset.objects.create(**obj.cleaned_data)
models.Server.objects.create(hostname=hostname,
asset_id=Asset_obj.id)
if tag_list:
tag_obj = models.Tag.objects.filter(id__in=tag_list)
Asset_obj.tag.add(*tag_obj)
response.status = True
else:
response.status = False
response.data = obj
return response
def add_data(self, request):
response = BaseResponse()
try:
post_dict = QueryDict(request.body, encoding='utf-8')
add_business_parent_id = post_dict.get('add_business_parent_id',
None)
add_business_name = post_dict.get('add_business_name')
add_business_admin_list = post_dict.getlist(
'add_business_admin_list', [])
add_business_contact_list = post_dict.getlist(
'add_business_contact_list', [])
add_business_memo = post_dict.get('add_business_memo')
add_data_to_db = models.BusinessUnit(
parent_unit_id=add_business_parent_id,
name=add_business_name,
memo=add_business_memo)
add_data_to_db.save()
for obj_id in add_business_admin_list:
add_data_to_db.manager.add(
user_center_models.UserGroup.objects.get(id=obj_id))
for obj_id in add_business_contact_list:
add_data_to_db.contact.add(
user_center_models.UserGroup.objects.get(id=obj_id))
except Exception as e:
response.status = False
response.message = str(e)
return response
def user_config(user_id):
response = BaseResponse()
try:
response.data = user_models.UserProfile.objects.filter(
id=user_id).first()
user_group = user_models.UserGroup.objects.all()
user_roles = user_models.Roles.objects.all()
select_dic = {
i.id: {
"group_name": i.name,
"select": False
}
for i in user_group
}
roles_dic = {
i.id: {
"role_name": i.name,
"select": False
}
for i in user_roles
}
for i in response.data.user_groups.all():
select_dic[i.id]["select"] = True
for i in response.data.roles.all():
roles_dic[i.id]["select"] = True
response.select = select_dic
response.roles_dic = roles_dic
except Exception as e:
print(Exception, e)
response.status = False
response.message = str(e)
return response
def fetch_business(self, request):
response = BaseResponse()
try:
ret = {}
conditions = self.business_condition(request) # 根据搜索条件构造 q 对象
print(conditions)
asset_count = models.BusinessUnit.objects.filter(
conditions).count() # 根据搜索条件统计搜索总数量
page_info = PageInfo(request.GET.get('pager', None),
asset_count) # 使用 PageInfo 构造 分页
asset_list = models.BusinessUnit.objects.filter(conditions).extra(
select=self.extra_select).values(
*self.values_list)[page_info.start:page_info.end]
ret['table_config'] = self.table_config
ret['condition_config'] = self.condition_config
ret['data_list'] = list(asset_list)
ret['page_info'] = {
"page_str": page_info.pager(),
"page_start": page_info.start,
}
ret['global_dict'] = {
'name_list': self.name_list,
}
response.data = ret
response.message = '获取成功'
except Exception as e:
response.status = False
response.message = str(e)
return response
def fetch_assets(self, request):
response = BaseResponse()
try:
ret = {}
conditions = self.assets_condition(request)
asset_count = models.DockerInstance.objects.filter(
conditions).count()
page_info = PageInfo(request.GET.get('pager', None), asset_count,
request.GET.get('limit', 20))
asset_list = models.DockerInstance.objects.filter(
conditions).extra(select=self.extra_select).values(
*self.values_list)[page_info.start:page_info.end]
ret['table_config'] = self.table_config
ret['condition_config'] = self.condition_config
ret['data_list'] = list(asset_list)
ret['page_info'] = {
"page_str": page_info.pager(),
"page_start": page_info.start,
}
ret['global_dict'] = {
'device_status_list': self.device_status_list,
'device_type_list': self.device_type_list,
'idc_list': self.idc_list,
'business_unit_list': self.business_unit_list
}
response.data = ret
response.message = '获取成功'
except Exception as e:
response.status = False
response.message = str(e)
return response
def fetch_group(self, request):
response = BaseResponse()
try:
ret = {}
conditions = self.assets_condition(request)
group_count = user_models.UserGroup.objects.filter(
conditions).count()
page_info = PageInfo(request.GET.get('pager', None), group_count)
group_list = user_models.UserGroup.objects.filter(
conditions).extra(select=self.extra_select).values(
*self.values_list).order_by(
"-id")[page_info.start:page_info.end]
ret['table_config'] = self.table_config
ret['condition_config'] = self.condition_config
ret['data_list'] = list(group_list)
ret['page_info'] = {
"page_str": page_info.pager(),
"page_start": page_info.start,
}
# ret['global_dict'] = {
# "group_list": self.group_list
# }
response.data = ret
response.message = '获取成功'
except Exception as e:
response.status = False
response.message = str(e)
return response
def post_idc(request):
response = BaseResponse()
try:
name = request.POST.get('name', None)
floor = request.POST.get('floor', None)
# add_dict = QueryDict(request.body, encoding='utf-8')
# print('add_dict', add_dict)
# print(hostname, manage_ip, device_type_id, device_status_id, idc_id, business_unit_id)
t_dict = {'name': name, 'floor': floor}
print(t_dict)
error_count = 0
idc_obj = models.IDC.objects.filter(**t_dict)
if idc_obj:
response.message = '添加的IDC信息已经存在'
response.status = False
response.error = '错误代码1'
pass
else:
try:
models.IDC.objects.create(name=name, floor=floor)
except Exception as e:
response.error = str(e)
response.status = False
error_count += 1
if error_count:
response.message = '添加IDC信息失败'
else:
response.message = '添加IDC信息成功'
except Exception as e:
response.status = False
response.message = str(e)
return response
pass
def fetch_assets(self, request):
username = request.GET.get('username', None)
response = BaseResponse()
try:
ret = {}
conditions = self.assets_condition(request)
asset_count = models.AuthInfo.objects.filter(conditions).count()
page_info = PageInfo(request.GET.get('pager', None), asset_count)
asset_list = models.AuthInfo.objects.filter(conditions).order_by('-id').extra(select=self.extra_select).values(
*self.values_list)[page_info.start:page_info.end]
ret['table_config'] = self.table_config
ret['condition_config'] = self.condition_config
ret['data_list'] = list(asset_list)
ret['page_info'] = {
"page_str": page_info.pager(),
"page_start": page_info.start,
}
ret['global_dict'] = {
'rank_status_list': self.rank_status_list,
'rank_list': self.rank_list,
'idc_list': self.idc_list,
'business_unit_list': self.business_unit_list,
'business_1_list': self.business_1_list,
'business_2_list': self.business_2_list,
'business_3_list': self.business_3_list
}
response.data = ret
response.message = '获取成功'
except Exception as e:
response.status = False
response.message = str(e)
return response
def get_group_by_id(request):
response = BaseResponse()
group_id = request.GET.get('group_id')
get_edit_group_data = repository_models.AppGroups.objects.filter(
id=group_id).values()
response.data = list(get_edit_group_data)
return response.data
def process(server_obj, server_info, user_obj):
response = BaseResponse()
try:
nic_info = server_info['nic']
if not nic_info['status']:
response.status = False
models.ErrorLog.objects.create(asset_obj=server_obj.asset, title='nic-agent', content=nic_info['error'])
return response
client_nic_dict = nic_info['data']
nic_obj_list = models.NIC.objects.filter(server_obj=server_obj)
nic_name_list = map(lambda x: x, (item.name for item in nic_obj_list))
update_list = agorithm.get_intersection(set(client_nic_dict.keys()), set(nic_name_list))
add_list = agorithm.get_exclude(client_nic_dict.keys(), update_list)
del_list = agorithm.get_exclude(nic_name_list, update_list)
HandleNic._add_nic(add_list, client_nic_dict, server_obj, user_obj)
HandleNic._update_nic(update_list, nic_obj_list, client_nic_dict, server_obj, user_obj)
HandleNic._del_nic(del_list, nic_obj_list, server_obj, user_obj)
except Exception as e:
response.status = False
models.ErrorLog.objects.create(asset_obj=server_obj.asset, title='nic-run', content=traceback.format_exc())
return response
def fetch_data(self, request):
response = BaseResponse()
try:
ret = {}
conditions = self.assets_condition(request)
asset_count = models.ServerApplyOrder.objects.filter(
conditions).count()
page_info = PageInfo(request.GET.get('pager', None), asset_count)
asset_list = models.ServerApplyOrder.objects.filter(
conditions).extra(select=self.extra_select).values(
*self.values_list).order_by(
'-id')[page_info.start:page_info.end]
self.asset_list = asset_list
ret['table_config'] = self.table_config
ret['condition_config'] = self.condition_config
ret['data_list'] = list(asset_list)
ret['page_info'] = {
"page_str": page_info.pager(),
"page_start": page_info.start,
}
ret['global_dict'] = {
'business_unit_list': self.business_unit_list,
'status_class_map': self.status_class_map,
'status_name_map': self.status_name_map,
'order_type_list': self.order_type_list,
'date_list': self.date_list,
}
response.data = ret
response.message = '获取成功'
except Exception as e:
response.status = False
response.message = str(e)
return response
def process(server_obj, server_info, user_obj):
response = BaseResponse()
try:
disk_info = server_info['disk']
if not disk_info['status']:
response.status = False
models.ErrorLog.objects.create(asset_obj=server_obj.asset, title='disk-agent',
content=disk_info['error'])
return response
client_disk_dict = disk_info['data']
disk_obj_list = models.Disk.objects.filter(server_obj=server_obj)
disk_slots = map(lambda x: x, (item.slot for item in disk_obj_list))
update_list = agorithm.get_intersection(set(client_disk_dict.keys()), set(disk_slots))
add_list = agorithm.get_exclude(client_disk_dict.keys(), update_list)
del_list = agorithm.get_exclude(disk_slots, update_list)
HandleDisk._add_disk(add_list, client_disk_dict, server_obj, user_obj)
HandleDisk._update_disk(update_list, disk_obj_list, client_disk_dict, server_obj, user_obj)
HandleDisk._del_disk(del_list, disk_obj_list, server_obj, user_obj)
except Exception as e:
response.status = False
models.ErrorLog.objects.create(asset_obj=server_obj.asset, title='disk-run', content=traceback.format_exc())
return response
def update_apply_items(request, order_id):
response = BaseResponse()
update_data = QueryDict(request.body, encoding='utf-8')
obj_id = update_data.get('obj_id')
ipaddress = update_data.get('ipaddress')
try:
# 检查更新ip地址是否存在
check_exist_server = models.Server.objects.filter(
ipaddress=ipaddress)
if not check_exist_server:
get_item_from_db = models.ServerApplyDetail.objects.get(
id=obj_id)
get_item_from_db.ipaddress = ipaddress
get_item_from_db.approved = 2
get_item_from_db.save()
else:
response.status = False
response.message = 'This IP has already exist in CMDB, Please check again.'
except Exception as e:
print(Exception, e)
response.status = False
response.message = str(e)
return response
def post_assets(request):
response = BaseResponse()
# 前端来获取业务线说明
get_id = request.POST.get('get_id', None)
if get_id:
obj = models.BusinessTwo.objects.filter(id=get_id).first()
business_remark = obj.business_remark
response.data = {'business_remark': business_remark}
response.status = True
return response
# 编辑业务线说明
business_text = request.POST.get('business_text', None)
if business_text:
business_id = request.POST.get('id', None)
try:
models.BusinessTwo.objects.filter(id=business_id).update(
business_remark=business_text)
response.status = True
except Exception as e:
response.status = False
response.message = str(e)
return response
# 新添加业务线
try:
response.error = []
name = request.POST.get('business1_name')
models.BusinessTwo.objects.create(name=name)
response.message = '添加成功'
except Exception as e:
response.status = False
response.message = str(e)
return response
def get_untreated_servers():
"""获取最近一天内"""
response = BaseResponse()
try:
current_date = datetime.date.today()
condition = Q()
# 今日未采集的资产
con_date = Q()
con_date.connector = 'OR'
con_date.children.append(("asset__latest_date__lt", current_date)) # 时间 小于当前的日期,表示今天未更新, 假如今天已经更新,则 该资产的 lastst_date 为今天的日期,则不小于今天的日期
con_date.children.append(("asset__latest_date", None)) # 时间为空表示新资产
# 在线状态的服务器
con_status = Q()
con_status.connector = 'AND'
con_status.children.append(('asset__device_status_id', '2')) # 资产状态为在线状态 2表示在线状态
con_status.children.append(('asset__device_type_id', '1')) # 服务器类型, 只采集硬件的资产, 1 表示硬件资产 ,阿里云 ESC 调阿里接口获取数据
condition.add(con_date, 'AND')
condition.add(con_status, 'AND')
result = models.Server.objects.filter(condition).values('hostname')
response.data = list(result)
response.status = True
except Exception as e:
response.message = str(e)
models.ErrorLog.objects.create(asset_obj=None, title='get_untreated_servers', content=traceback.format_exc())
return response
def put_business(request):
response = BaseResponse()
try:
response.error = []
put_dict = QueryDict(request.body, encoding='utf-8')
# print('put_dict', put_dict)
update_list = json.loads(put_dict.get('update_list'))
# print('update_list', update_list)
error_count = 0
for row_dict in update_list:
nid = row_dict.pop('nid')
num = row_dict.pop('num')
try:
models.BusinessUnit.objects.filter(id=nid).update(**row_dict)
except Exception as e:
response.error.append({'num': num, 'message': str(e)})
response.status = False
error_count += 1
if error_count:
response.message = '共%s条,失败%s条' % (len(update_list), error_count,)
else:
response.message = '更新成功'
except Exception as e:
response.status = False
response.message = str(e)
return response
def fetch_user(self, request):
"""
获取用户信息
:param request:
:return:
"""
response = BaseResponse()
try:
ret = {}
conditions = self.select_condition(request)
user_count = models.UserProfile.objects.filter(conditions).count()
page_info = PageInfo(request.GET.get('pager', None), user_count)
user_list = models.UserProfile.objects.filter(conditions).extra(
select=self.extra_select).values(*self.values_list).order_by(
'id')[page_info.start:page_info.end]
# 加入查询条件
ret['condition_config'] = self.condition_config
# 加入配置文件
ret['table_config'] = self.table_config
# 加入查询到的数据
ret['data_list'] = list(user_list)
# 加入页面信息
ret['page_info'] = {
'page_str': page_info.pager(),
'page_start': page_info.start,
}
# 加入全局变量
ret['global_dict'] = {}
response.data = ret
response.message = '获取成功'
except Exception as e:
response.status = False
response.message = str(e)
return response
def data_create(request):
response = BaseResponse()
try:
post_data = QueryDict(request.body, encoding='utf-8')
role_name = post_data.get('role_name')
role_memo = post_data.get('role_memo')
permission_list = post_data.getlist('permission_list')
# 创建role
data_obj = USER_CENTER_MODELS.Roles(
name=role_name,
memo=role_memo,
)
data_obj.save()
# 关联permission
for obj_id in permission_list:
data_obj.permissions.add(obj_id)
except Exception as e:
print(Exception, e)
response.status = False
response.message = str(e)
return response
def fetch_data(self, request):
response = BaseResponse()
try:
ret = {}
conditions = self.assets_condition(request)
asset_count = OMTOOLS_MODELS.MongodbMission.objects.filter(
conditions).count()
page_info = PageInfo(request.GET.get('pager', None), asset_count)
asset_list = OMTOOLS_MODELS.MongodbMission.objects.filter(
conditions).order_by('-id').extra(
select=self.extra_select).values(
*self.values_list)[page_info.start:page_info.end]
ret['table_config'] = self.table_config
ret['condition_config'] = self.condition_config
ret['data_list'] = list(asset_list)
ret['page_info'] = {
"page_str": page_info.pager(),
"page_start": page_info.start,
}
ret['global_dict'] = {
'op_type_list': self.op_type_list,
'option_status': self.option_status,
'status_map': self.status_map,
}
response.data = ret
response.message = '获取成功'
except Exception as e:
response.status = False
response.message = str(e)
return response
def fetch_tag(self, request):
response = BaseResponse()
try:
ret = {}
conditions = self.assets_condition(request)
asset_count = models.Tag.objects.filter(conditions).count()
page_info = PageInfo(request.GET.get('pager', None), asset_count)
asset_list = models.Tag.objects.filter(conditions).extra(
select=self.extra_select).values(
*self.values_list)[page_info.start:page_info.end]
ret['table_config'] = self.table_config
ret['condition_config'] = self.condition_config
ret['data_list'] = list(asset_list)
ret['page_info'] = {
"page_str": page_info.pager(),
"page_start": page_info.start,
}
ret['global_dict'] = {}
response.data = ret
response.message = '获取成功'
except Exception as e:
response.status = False
response.message = str(e)
return response
def get_urlmaps_groups_by_id(request):
response = BaseResponse()
try:
response.error = {}
group_type = request.GET.get('group_type')
group_id = request.GET.get('group_id')
urlmaps_id = request.GET.get('urlmaps_id')
urlmaps_obj = repository_models.UrlConfigHandler.objects.filter(id=urlmaps_id).values()
if group_type == 'cloud':
instance_in_group = CMDB_MODELS.Asset.objects.filter(instances__id=group_id).values('id', 'server__ipaddress')
instance_in_urlmaps = CMDB_MODELS.Asset.objects.filter(urlconfighandler_cloud__id=urlmaps_id).values('id', 'server__ipaddress')
elif group_type == 'forward':
instance_in_group = CMDB_MODELS.Asset.objects.filter(instances__id=group_id).values('id', 'server__ipaddress')
instance_in_urlmaps = CMDB_MODELS.Asset.objects.filter(urlconfighandler_forward__id=urlmaps_id).values('id', 'server__ipaddress')
elif group_type == 'docker':
instance_in_group = CMDB_MODELS.Asset.objects.filter(instances__id=group_id).values('id','server__ipaddress')
instance_in_urlmaps = CMDB_MODELS.DockerInstance.objects.filter(urlconfighandler_docker__id=urlmaps_id).values('id', 'asset__server__ipaddress', 'port')
print(instance_in_urlmaps)
response.urlmaps_obj = list(urlmaps_obj)
response.left_select_list = list(instance_in_group)
response.right_select_list = list(instance_in_urlmaps)
except Exception as e:
print(Exception, e)
response.status = False
response.message = str(e)
return response
