def group_list(request):
"""
用户组列表
* 权限 - 超级管理员(SU)
* 参数
** search - 用户组名称
** type - 用户类型
"""
msg_prefix = u"获取用户组列表 "
try:
groups = ExGroup.objects.all()
if request.method == 'POST':
req_dict = post_data_to_dict(request.data)
keyword = smart_get(req_dict, 'search', unicode, '')
member_type = smart_get(req_dict, 'type', str, '').lower()
if keyword:
groups = groups.filter(
Q(name__icontains=keyword) | Q(comment__icontains=keyword))
if member_type:
groups = groups.filter(member_type=member_type)
serializer = serializers.ExGroupSerializer(groups, many=True)
except Exception, e:
msg = msg_prefix + u"失败, 错误信息: " + unicode(e)
logger.error(msg)
return Response({
"status": -1,
"msg": msg,
"data": {}
},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def related_node(self, request, *args, **kwargs):
"""
节点间关系(上下游)
* 参数
** up_id, 上游节点id, int
** down_id, 下游节点id, int
** is_related, 是否添加关系, bool
"""
msg_prefix = u"更新节点间关系 "
req_dict = post_data_to_dict(request.data)
up_id = smart_get(req_dict, 'up_id', int)
down_id = smart_get(req_dict, 'down_id', int)
is_related = smart_get(req_dict, 'is_related', bool, False)
try:
up_instance = BlueNodeDefinition.objects.get(id=up_id)
if is_related:
up_instance.downstream_node.add(down_id)
else:
up_instance.downstream_node.remove(down_id)
node_map_set = BlueNodeMapParam.objects.filter(target_node=down_id, source_node=up_id)
for node_map in node_map_set:
node_map.delete()
up_instance.save()
except Exception, e:
msg = msg_prefix + u"失败, 错误信息: " + unicode(e)
logger.error(format_exc())
return Response({"status": -1, "msg": msg, "data": {}}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def ajax_user_list(request):
"""
ajax请求 - 动态搜索 - 用户列表
* 参数
** search - 搜索
** limit - 返回记录条数
"""
req_dict = post_data_to_dict(request.data)
PYWorker = PinYin()
search = smart_get(req_dict, 'search', unicode)
limit = smart_get(req_dict, 'limit', int)
try:
result = []
q_set = ExUser.objects.all()
if search:
search = search.lower()
for q in q_set:
if search in q.username.lower() \
or search in q.name.lower() \
or search in PYWorker.hanzi2pinyin_split(q.name) \
or search in PYWorker.hanzi2firstletter(q.name):
result.append(q)
else:
result = q_set
serializer = ExUserSerializer(result[:limit], many=True)
except Exception, e:
msg = u"失败, 错误信息: " + unicode(e)
logger.error(format_exc())
return Response({
"status": -1,
"msg": msg,
"data": {}
},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def get_secondary_app(self, request):
msg_prefix = u"动态获取二级应用"
req_dict = post_data_to_dict(request.data)
primary_app_id = smart_get(req_dict, 'id', int)
app_name = smart_get(req_dict, 'app_name', str)
app_short_name = smart_get(req_dict, 'app_short_name', str)
try:
primary_ins = self.get_queryset().filter(id=primary_app_id).first()
if not primary_ins:
msg = msg_prefix + u"失败"
return Response({"status": -1, "msg": msg, "data": []})
secondary_set = primary_ins.secondary.all()
# print secondary_set
if not secondary_set:
msg = msg_prefix + u"失败"
return Response({"status": -1, "msg": msg, "data": []})
list1 = []
for i in secondary_set:
data1 = model_to_dict(i)
if data1:
list1.append(data1)
# if list1:
# return
except Exception, e:
msg = msg_prefix + u"失败, 错误信息: " + unicode(e)
logger.error(format_exc())
return Response({"status": -1, "msg": msg, "data": {}})
def node_params(self, request, *args, **kwargs):
"""
获取节点参数及参数映射信息
* 参数
** source_id， 来源节点id, int
** target_id, 目标节点id, int
"""
msg_prefix = u"获取节点参数及参数映射信息 "
req_dict = post_data_to_dict(request.data)
source_id = smart_get(req_dict, 'source_id', int)
target_id = smart_get(req_dict, 'target_id', int)
try:
source_node_instance = self.get_queryset().get(id=source_id)
target_node_instance = self.get_queryset().get(id=target_id)
target_params = target_node_instance.component_data.get('params')
source_params = source_node_instance.component_data.get('params')
# 两个节点间映射集合
exist_map_self_set = BlueNodeMapParam.objects.filter(target_node=target_id, source_node=source_id)
# 目标节点所有映射集合
exist_map_all_set = BlueNodeMapParam.objects.filter(target_node=target_id)
exist_params = serializers.BlueNodeMapParamSerializer(instance=exist_map_self_set, many=True).data
# 参数过滤
for target_param in copy.deepcopy(target_params):
# 删除输出项
have_io_stream = "io_stream" in [k for k, _ in target_param.items()]
if have_io_stream:
if target_param['io_stream'] == "输出":
target_params.remove(target_param)
continue
# 删除其它节点已映射项
for exist_map in exist_map_all_set:
if exist_map.target_param_name == target_param['param_name'] and exist_map.source_node != source_id:
target_params.remove(target_param)
continue
for source_param in copy.deepcopy(source_params):
# 删除输入项
have_io_stream = "io_stream" in [k for k, _ in source_param.items()]
if have_io_stream:
if source_param['io_stream'] == "输入":
source_params.remove(source_param)
continue
params = dict(
source_params=source_params,
target_params=target_params,
exist_params=exist_params
)
except Exception, e:
msg = msg_prefix + u"失败, 错误信息: " + unicode(e)
logger.error(format_exc())
return Response({"status": -1, "msg": msg, "data": {}}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def user_mana_key(request):
"""
管理用户RSA密钥
* 参数
** generate - 生成新密钥
** download - 下载私钥
** passphrase - 私钥密码
** puttykey - putty格式
"""
msg_prefix = u"管理用户RSA密钥 "
req_dict = post_data_to_dict(request.data)
user = request.user
generate = smart_get(req_dict, 'generate', bool, False)
download = smart_get(req_dict, 'download', bool, False)
passphrase = smart_get(req_dict, 'passphrase', str, '')
puttykey = smart_get(req_dict, 'puttykey', bool, False)
try:
# admin系统内置账户不可更换密钥
if user.username == 'admin':
generate = False
if generate:
user_gen_rsakey(user,
key_expiration=timezone.now() +
timezone.timedelta(days=ExUser.KEY_LIFE))
if download:
key = get_rsakey_from_string(user.ssh_key_str,
passphrase=ExUser.KEY_PASSPHRASE)
if puttykey:
key_filename = "putty_pkey.ppk"
key_string = toString_PUTTY_private(key, passphrase=passphrase)
else:
key_filename = "{username}.id_rsa".format(
username=user.username)
key_string = get_key_string(key, passphrase=passphrase)
response = StreamingHttpResponse(
content_type='application/octet-stream')
response[
'Content-Disposition'] = "attachment; filename={filename}".format(
filename=key_filename)
response.streaming_content = key_string
return response
except Exception, e:
if isinstance(e, APIException):
raise e
msg = msg_prefix + u"失败, 错误信息: " + unicode(e)
logger.error(format_exc())
return Response({
"status": -1,
"msg": msg,
"data": {}
},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def group_delete(request):
"""
删除用户组
* 权限 - 超级管理员(SU)
* 参数
** id - 组id
"""
msg_prefix = u"删除用户组 "
req_dict = post_data_to_dict(request.data)
id = smart_get(req_dict, 'id', int)
try:
# 获取用户组
group_set = ExGroup.objects.filter(id=id)
if not group_set.exists():
raise Exception(u"没有符合条件的用户组")
data = list(group_set.values('id', 'name', 'member_type'))
group_set.delete()
except Exception, e:
msg = msg_prefix + u"失败, 错误信息: " + unicode(e)
logger.error(msg)
return Response({
"status": -1,
"msg": msg,
"data": {}
},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def fuzzy_search_test(self, request):
"""
:param request:
:return:
"""
msg_prefix = u"一级应用模糊搜索"
req_dict = post_data_to_dict(request.data)
search_keyword = smart_get(req_dict, 'search_keyword', str)
try:
first_app_set = self.get_queryset().filter(
app_name__icontains=search_keyword)
if not first_app_set:
first_app_set1 = self.get_queryset().filter(
app_short_name__icontains=search_keyword)
if not first_app_set1:
return Response({"status": 1, "msg": "暂无数据", "data": []})
else:
serializer = self.get_serializer(first_app_set1, many=True)
else:
serializer = self.get_serializer(first_app_set, many=True)
except Exception, e:
msg = msg_prefix + u"失败, 错误信息: " + unicode(e)
logger.error(format_exc())
return Response({"status": -1, "msg": msg, "data": {}})
def user_detail(request):
"""
获取用户详情
* 参数
** id - 用户id
"""
msg_prefix = u"获取用户详情 "
req_user = request.user
try:
if request.method == 'GET':
user = req_user
else:
req_dict = post_data_to_dict(request.data)
id = smart_get(req_dict, 'id', int)
user = ExUser.objects.get(pk=int(id))
serializer = serializers.ExUserDetailSerializer(user)
except Exception, e:
if isinstance(e, APIException):
raise e
msg = msg_prefix + u"失败, 错误信息: " + unicode(e)
logger.error(msg)
return Response({
"status": -1,
"msg": msg,
"data": {}
},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def find_map_relation(self, request, *args, **kwargs):
"""
返回对应关系
:param request:
:param args:
:param kwargs:
:return:
"""
msg_prefix = u"查找对应关系"
req_dict = post_data_to_dict(request.data)
category_code = smart_get(req_dict, 'category_code', str)
page_code = smart_get(req_dict, 'page_code', str)
service_code = smart_get(req_dict, 'service_code', str)
button_code = smart_get(req_dict, 'button_code', str)
try:
synthesize_code = category_code + service_code + page_code + button_code
wf_map_ins = self.get_queryset().filter(
synthesize_code=synthesize_code).first()
bp_map_ins = ServerMapBp.objects.filter(
synthesize_code=synthesize_code).first()
data = {}
if not wf_map_ins and not bp_map_ins:
msg = msg_prefix + u"失败，"
logger.error(format_exc())
return Response({'status': -1, 'msg': msg, "data": []})
elif wf_map_ins and not bp_map_ins:
wf_map_dict = model_to_dict(wf_map_ins)
data['wf_map_relation'] = wf_map_dict
elif bp_map_ins and not wf_map_ins:
bp_map_dict = model_to_dict(bp_map_ins)
data['bp_map_relation'] = bp_map_dict
else:
bp_map_dict = model_to_dict(bp_map_ins)
data['bp_map_relation'] = bp_map_dict
wf_map_dict = model_to_dict(wf_map_ins)
data['wf_map_relation'] = wf_map_dict
except Exception, e:
msg = msg_prefix + u"失败，错误信息：" + unicode(e)
logger.error(format_exc())
return Response({'status': -1, 'msg': msg, "data": []})
def create(self, request, *args, **kwargs):
msg_prefix = u"创建节点-参数映射关系 "
req_dict = post_data_to_dict(request.data)
map_list = smart_get(req_dict, 'map_list', list)
source_id = smart_get(req_dict, 'source_id', int)
target_id = smart_get(req_dict, 'target_id', int)
try:
exist_map_set = self.get_queryset().filter(source_node=source_id, target_node=target_id)
for exist_map in exist_map_set:
exist_map.delete()
for map in map_list:
serializer = self.get_serializer(data=map)
serializer.is_valid(raise_exception=True)
self.perform_create(serializer)
except Exception, e:
msg = msg_prefix + u"失败, 错误信息: " + unicode(e)
logger.error(format_exc())
return Response({"status": -1, "msg": msg, "data": {}}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def save_blue(self, request, *args, **kwargs):
"""
验证节点参数, 排序, 保存蓝图
"""
msg_prefix = u"保存蓝图 "
req_dict = post_data_to_dict(request.data)
blue_category_id = smart_get(req_dict, 'blue_category_id', int)
name = smart_get(req_dict, 'name', str)
description = smart_get(req_dict, 'description', str)
try:
blue_print = self.get_object()
if blue_category_id:
blue_print.blue_category_id = blue_category_id
blue_print.name = name
blue_print.description = description
nodes = blue_print.blue_nodes.filter(component_type=0)
if not len(nodes):
raise Exception(u"无节点")
is_valid_params(nodes) # 参数检查
graph = build_graph(nodes) # 构建图
avaliable_node_sort = topo_sort(graph) # 图排序
if not avaliable_node_sort:
raise Exception(u"节点存在环， 请检查")
blue_print.avaliable_node_sort = avaliable_node_sort
blue_print.is_verify = True
for node in nodes:
if not node.is_verify:
blue_print.is_verify = False
raise Exception(u"请先验证蓝图节点")
blue_print_set = BluePrintDefinition.objects.filter(name=name)
if len(blue_print_set):
raise Exception(u"蓝图有重名， 请重新命名")
blue_print.keep_status = 1
blue_print.save()
except Exception, e:
msg = unicode(e)
logger.error(format_exc())
return Response({"status": -1, "msg": msg, "data": {}})
def component_of_category(self, request, *args, **kwargs):
"""
获取分类组件实体
"""
msg_prefix = u"获取分类组件实体 "
req_dict = post_data_to_dict(request.data)
component_type = smart_get(req_dict, 'component_type', int)
component_category = smart_get(req_dict, 'component_category', str)
try:
component_def_set = BlueComponentDefinition.objects.filter(component_type=component_type,
component_category=component_category)
component_Q = Q()
component_Q.connector = 'OR'
for component_def in component_def_set:
component_Q.children.append(('id', component_def.component_entity))
if component_type == 0:
instance = BlueInterfaceDefinition.objects.filter(component_Q, is_freeze=False, is_component=True)
serializer = serializers.BlueInterfaceDefinitionSerializer(instance=instance, many=True)
elif component_type == 1:
instance = BluePreParamGroup.objects.filter(component_Q, is_freeze=False, is_component=True)
serializer = serializers.BluePreParamGroupSerializer(instance=instance, many=True)
elif component_type == 2:
instance = BlueAccessModuleParamGroup.objects.filter(component_Q, is_freeze=False, is_component=True)
serializer = serializers.BlueAccessModuleParamGroupSerializer(instance=instance, many=True)
elif component_type == 3:
instance = BluePrintDefinition.objects.filter(component_Q, is_freeze=False, is_component=True)
serializer = serializers.BluePrintDefinitionSerializer(instance=instance, many=True)
else:
raise Exception(u"不支持的组件类型， 请联系管理员！")
# component_entity_set = BlueComponentEntityDefinition.objects.filter(component_Q, is_freeze=False)
# serializer = serializers.BlueComponentEntityDefinitionSerializer(instance=component_entity_set, many=True)
except Exception, e:
msg = msg_prefix + u"失败, 错误信息: " + unicode(e)
logger.error(format_exc())
return Response({"status": -1, "msg": msg, "data": {}}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def fix_wrong_node_task(cls, data):
"""
节点修复~
:param data: 接口原装数据
:return: 节点数据给
"""
# data.get("")
blue_ins_number = smart_get(data, "blue_instance_number", str)
# blue_node = smart_get(data, "blue_node", str)
'有几种情况'
"""
读取当前蓝图实例和当前执行节点的列表
获取当前节点 和剩余列表
"""
blue_ins_obj = BlueInstance.objects.filter(
blue_instance_number=blue_ins_number).first()
if not blue_ins_obj:
return {"status": -1, "msg": "暂无该蓝图实例", "data": data}
# 获取完数据，提取处错误的节点
from django.db.models import Q
# 凡是不成功都是失败
error_node_instance = NodeInstance.objects.filter(
Q(blue_instance=blue_ins_obj) & ~Q(status=5)).first()
if blue_ins_obj.status != 3:
data = model_to_dict(blue_ins_obj)
return {"status": -1, "msg": "当前蓝图正常，无法恢复", "data": data}
if not error_node_instance:
# 说明 还没实例化呢 ，没有实例化则要找到这个对应的节点定义的iD
return {"status": -1, "msg": "当前蓝图节点暂无实例化，您可以尝试重启该实例", "data": []}
else:
if not error_node_instance.blue_node:
return {"status": -1, "msg": "蓝图恢复失败，并无当前节点", "data": []}
error_note_obj = error_node_instance.blue_node.id # 节点对象
list2 = blue_ins_obj.avaliable_node_sort[::-1] # 倒叙列表
remaining_notes = list2[:list2.index(error_note_obj) + 1]
dict1 = {"remaining_notes": remaining_notes}
data2 = model_to_dict(blue_ins_obj)
data2.update(dict1)
# req_data = cls.blue_engine_control_center(data=data2)
# req_data = cls.blue_engine_control_center(data=data2)
req_data = blue_engine_control_center.delay(data=data2)
if req_data.id:
# if celery_task_result_data.ready() == True:
return {"status": 1, "msg": "蓝图恢复执行开始", "data": req_data}
# if req_data['status'] == -1:
# return {"status": -1, "msg": "蓝图恢复失败", "data": req_data}
return {"status": 1, "msg": "蓝图恢复正常", "data": req_data}
def user_add(request):
"""
添加用户
* 参数
** username - 用户名称
** email - 邮箱地址
** password - 密码
** aam_id - 统一认证号
** name - 显示名称
** group_id - 用户组id(','号分隔列表)
** role - 角色(CU/GM/SN), SU只通过后台创建
"""
msg_prefix = u"添加用户 %s "
req_dict = post_data_to_dict(request.data)
username = smart_get(req_dict, 'username', str)
email = smart_get(req_dict, 'email', str)
password = smart_get(req_dict, 'password', str)
aam_id = smart_get(req_dict, 'aam_id', str, '')
group_id = smart_get(req_dict, 'group_id', list, default_list=None)
name = smart_get(req_dict, 'name', unicode, '')
role = smart_get(req_dict, 'role', str, 'CU')
try:
if ExUser.objects.filter(username=username):
raise Exception(u'用户名已存在')
user = ExUser.objects.create_user(username,
email,
password,
name,
role,
aam_id=aam_id)
user_gen_rsakey(user,
key_expiration=timezone.now() +
timezone.timedelta(days=ExUser.KEY_LIFE))
user_id = user.id
if group_id:
for var in group_id:
group = ExGroup.objects.get(pk=int(var))
group_add_user(group, user_id)
serializer = serializers.ExUserSerializer(user)
except Exception, e:
msg = (msg_prefix % username) + u"失败, 错误信息: " + unicode(e)
logger.error(msg)
return Response({
"status": -1,
"msg": msg,
"data": {}
},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def user_list(request):
"""
获取用户列表
* 参数
** search - 搜索匹配(用户名/显示名/邮箱)
** roles - 匹配角色(','号分隔列表)
** group_ids - 匹配用户组(','号分隔列表)
"""
msg_prefix = u"获取用户列表 "
try:
users = ExUser.objects.all()
if request.method == 'POST':
req_dict = post_data_to_dict(request.data)
keyword = smart_get(req_dict, 'search', unicode, '')
roles = smart_get(req_dict, 'role', list)
groups = smart_get(req_dict, 'group_ids', list)
if keyword:
users = users.filter(
Q(username__icontains=keyword) | Q(name__icontains=keyword)
| Q(email__icontains=keyword))
if roles:
users = users.filter(role__in=roles)
if groups:
users = users.filter(groups__in=groups)
serializer = serializers.ExUserSerializer(users, many=True)
except Exception, e:
msg = msg_prefix + u"失败, 错误信息: " + unicode(e)
logger.error(msg)
return Response({
"status": -1,
"msg": msg,
"data": {}
},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def interface_params(self, request, *args, **kwargs):
"""
获取接口参数
"""
msg_prefix = u"获取接口参数 "
req_dict = post_data_to_dict(request.data)
io_stream = smart_get(req_dict, 'io_stream', str)
try:
interface_instance = self.get_object()
params = interface_instance.params.filter(io_stream=io_stream)
interface_params_serializer = serializers.BlueInterfaceParamSerializer(instance=params, many=True)
except Exception, e:
msg = msg_prefix + u"失败, 错误信息: " + unicode(e)
logger.error(format_exc())
return Response({"status": -1, "msg": msg, "data": {}}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def link_data(self, request, *args, **kwargs):
"""
画板连线数据
* 参数
** link_data， 连线数据, list
"""
msg_prefix = u"更新画板连线数据 "
req_dict = post_data_to_dict(request.data)
link_data = smart_get(req_dict, 'link_data', list)
try:
blue_print = self.get_object()
blue_print.link_data = link_data
blue_print.save()
except Exception, e:
msg = msg_prefix + u"失败, 错误信息: " + unicode(e)
logger.error(format_exc())
return Response({"status": -1, "msg": msg, "data": {}}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def category_of_type(self, request, *args, **kwargs):
"""
获取组件实体分类
"""
msg_prefix = u"获取组件实体分类 "
req_dict = post_data_to_dict(request.data)
component_type = smart_get(req_dict, 'component_type', int)
try:
component_category = set()
queryset = self.get_queryset().filter(component_type=component_type)
for cc in queryset:
component_category.add(cc.component_category)
except Exception, e:
msg = msg_prefix + u"失败, 错误信息: " + unicode(e)
logger.error(format_exc())
return Response({"status": -1, "msg": msg, "data": {}}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def get_interface(self, request):
"""
根据类别过滤接口
"""
msg_prefix = u"接口查询 "
req_dict = post_data_to_dict(request.data)
interface_category_id = smart_get(req_dict, 'interface_category_id', int)
try:
is_freeze = request.data.get('is_freeze')
if isinstance(is_freeze, bool):
queryset = self.get_queryset().filter(category_id=interface_category_id, freeze=is_freeze)
else:
queryset = self.get_queryset().filter(category_id=interface_category_id)
serializer = self.get_serializer(instance=queryset, many=True)
except Exception, e:
msg = msg_prefix + u"失败, 错误信息: " + unicode(e)
logger.error(format_exc())
return Response({"status": -1, "msg": msg, "data": {}}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def group_add(request):
"""
添加用户组
* 权限 - 超级管理员(SU)
* 参数
** name - 用户组名称
** comment - 用户组描述
** users_id - 初始用户(id)(','号分隔列表)
** member_type - 成员类型 staff/service (默认staff)
** managers_id - 管理用户(id)(','号分隔列表)
** menu_list - 菜单权限清单,(','号分隔列表)
"""
msg_prefix = u"添加用户组 %s "
req_dict = post_data_to_dict(request.data)
name = smart_get(req_dict, 'name', str)
users_id = smart_get(req_dict, 'users_id', list)
managers_id = smart_get(req_dict, 'managers_id', list)
comment = smart_get(req_dict, 'comment', unicode, '')
member_type = smart_get(req_dict, 'member_type', str, 'staff')
menu_list = smart_get(req_dict, 'menu_list', list)
try:
if Group.objects.filter(name=name):
raise Exception(u'组名已存在')
group = ExGroup.objects.create(name=name,
comment=comment,
member_type=member_type,
menu=menu_list)
group_add_users(group, *users_id)
group_add_manager(group, *managers_id)
serializer = serializers.ExGroupSerializer(group)
except Exception, e:
msg = (msg_prefix % name) + u"失败, 错误信息: " + unicode(e)
logger.error(msg)
return Response({
"status": -1,
"msg": msg,
"data": {}
},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def obtain_matching_rule_values(self, request):
"""
获取匹配规则值
:param request:
:return:
"""
msg_prefix = u"获取匹配规则值"
req_dict = post_data_to_dict(request.data)
# print req_dict
# param_id = req_dict.get("param_id")
param_id = smart_get(req_dict, "param_id", int)
matching_param_value_id_list = req_dict.get("matching_param_value_id")
if not matching_param_value_id_list:
return Response({"status": -1, "msg": "参数值没有ID", "data": []})
param_matching_pattern = smart_get(req_dict, "param_matching_pattern",
str)
if not param_matching_pattern:
return Response({"status": -1, "msg": "匹配方式", "data": []})
int_list = []
for i in matching_param_value_id_list:
int_i = int(i)
int_list.append(int_i)
if not int_list:
return Response({"status": -1, "msg": "获取匹配规则失败", "data": []})
matching_rule_queryset = ServerMatchingRule.objects.filter(
param_id=param_id,
param_matching_pattern=param_matching_pattern).all()
if not matching_rule_queryset:
return Response({"status": -1, "msg": "获取匹配规则失败", "data": []})
result_list = []
for i in matching_rule_queryset:
# 循环出每一个匹配规则对象
matching_condition_queryset = i.matched_condition.all()
if not matching_condition_queryset:
return Response({
"status": -1,
"msg": "获取匹配规则条件失败",
"data": []
})
list1 = [] # [61,64]
for j in matching_condition_queryset:
list1.append(j.matching_param_value_id)
int_list.sort() # 用户传过来的参数 [64,61,37]
list1.sort() # 匹配项中的列表 [64,61]
set_list = list(set(int_list).intersection(set(list1)))
set_list.sort()
#
# if set_list != list1:
# # return Response({"status": -1, "msg": "获取匹配规则条件失败,参数值比对失败", "data": []})
# result_list = []
if set_list == list1:
result_list.append(i)
# print result_list #[<ServerMatchingRule: 网络的匹配规则>]
param_value_id_list = []
param_value_display_list = []
if result_list:
for i in result_list:
# i.param_value_id "[87]"
if type(i.param_value_id) != list:
load_str_list = json.loads(i.param_value_id)
for j in load_str_list:
param_value_id_list.append(j)
else:
for j in i.param_value_id:
param_value_id_list.append(j)
for k in param_value_id_list:
j_ins = ServerParamValues.objects.filter(id=k).first()
j_ins_serializer = ServerParamValuesSerializer(instance=j_ins)
param_value_display_list.append(j_ins_serializer.data)
return Response({
"status": 1,
"msg": "获取匹配规则条件成功",
"data": param_value_display_list
})
else:
return Response({"status": -1, "msg": "获取匹配规则条件失败", "data": []})
def group_edit(request):
"""
修改用户信息
* 权限 - 普通用户(CU)
* 参数
** id - 用户组id
** comment - 备注
** member_type - 成员类型 staff/service
** users_id/users_id_add - 用户/添加用户(id)(','号分隔列表)
** managers_id/managers_id_add - 管理用户/添加管理用户(id)(','号分隔列表)
** menu_list - 菜单权限清单/修改菜单权限清单(','号分隔列表)
"""
msg_prefix = u"修改用户组信息 ID:%s "
req_dict = post_data_to_dict(request.data)
id = smart_get(req_dict, 'id', int)
comment = smart_get(req_dict, 'comment', unicode, '')
member_type = smart_get(req_dict, 'member_type', str, '')
users_id = smart_get(req_dict, 'users_id', list, default_list=None)
users_id_add = smart_get(req_dict, 'users_id_add', list)
managers_id = smart_get(req_dict, 'managers_id', list, default_list=None)
managers_id_add = smart_get(req_dict, 'managers_id_add', list)
menu_list = smart_get(req_dict, 'menu_list', list, default_list=None)
try:
# 获取用户组
group = ExGroup.objects.get(pk=int(id))
# 修改信息
if comment:
group.comment = comment
if member_type:
group.member_type = member_type
if users_id is not None:
group.user_set.clear()
users_id_add += users_id
if users_id_add:
group_add_users(group, *users_id_add)
if managers_id is not None:
group.managers.clear()
managers_id_add += managers_id
if menu_list is not None:
group.menu = menu_list
group.save()
if managers_id_add:
group_add_manager(group, *managers_id_add)
serializer = serializers.ExGroupSerializer(group)
except Exception, e:
msg = (msg_prefix % id) + u"失败, 错误信息: " + unicode(e)
logger.error(msg)
return Response({
"status": -1,
"msg": msg,
"data": {}
},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def create(self, request, *args, **kwargs):
msg_prefix = u"创建申请工单"
"""
Create a model instance.
"""
req_dict = post_data_to_dict(request.data)
# req_dict = request.data
business_data_dict = req_dict.get("business_data")
map_relation_dict = req_dict.get("map_relation")
process_info_dict = req_dict.get("process_info")
if not process_info_dict:
return Response({"status": -1, "msg": "没有流程数据", "data": []})
# process_ins_info_dict = process_info_dict.get("process_ins_info")
process_instance_number = process_info_dict.get(
"process_instance_number")
if not process_instance_number:
return Response({"status": -1, "msg": "没有流程实例编号", "data": []})
# = business_data_dict.get("host_profile")instance_name
submit_data_dict = business_data_dict.get("submit_data")
submit_info_dict = submit_data_dict.get("submit_info")
host_profile_list = submit_data_dict.get("host_config_data")
apply_msg = submit_info_dict.get("submit_msg")
# apply_expiration = req_dict.get("apply_expiration")
is_haven_ins = VMGenerateApproval.objects.filter(
workflow_number=process_instance_number).first()
# 删除已存在的对象
if is_haven_ins:
set1 = is_haven_ins.vm_generate_ord.all()
if set1:
for i in set1:
i.delete()
VMGenerateApproval.objects.filter(
workflow_number=process_instance_number).delete()
apply_application_list = submit_info_dict.get("submit_application")
# print apply_application_list
apply_expiration_str = smart_get(submit_info_dict, 'submit_expiration',
str)
print "dsadasd"
print apply_expiration_str
print "dsadasd"
# '先创建申请表数据'
now_time = time.strftime("%Y%m%d", time.localtime()) # 年月日
instance_set = VMGenerateApproval.objects.all()
instance_len = len(instance_set)
i = 1
i += instance_len
k = "%03d" % i
format_number = "approval" + now_time + k
approval_user = request.user
data = {}
ins = VMGenerateApproval.objects.create(
approval_number=format_number,
applicant=approval_user,
apply_msg=apply_msg,
workflow_number=process_instance_number,
map_relation=map_relation_dict)
if not ins:
return Response({"status": -1, "msg": "创建失败", "data": []})
data['approval_ord'] = model_to_dict(ins)
# '循环创建申请数据'
# print len(host_profile_list)
for i in host_profile_list:
# 'i 为每个 主机配置信息 字典格式'
if not i:
return Response({"status": -1, "msg": "申请数据创建失败", "data": []})
env_type = i.get("env_type")
apply_deploy_place = i.get("deploy_location")
apply_os_version = i.get("apply_os_version")
apply_node_type = i.get("node_type")
apply_application_dict = apply_application_list
apply_cpu = i.get("target_cpu_cores")
apply_memory_gb = i.get("target_mem_gb")
apply_software_dict = i.get("apply_software")
apply_disk_gb = i.get("add_datadisk_gb")
apply_network_area = i.get("network_area")
# apply_expiration = i.get("apply_disk_gb")
apply_system_dict = i.get("system_type")
apply_filesystem_dict = i.get("apply_filesystem")
ord_ins = VMGenerateApprovalOrd.objects.create(
approval=ins,
env_type=env_type,
apply_os_version=apply_os_version,
apply_deploy_place=apply_deploy_place,
apply_node_type=apply_node_type,
apply_application=apply_application_dict,
apply_network_area=apply_network_area,
apply_cpu=apply_cpu,
apply_memory_gb=apply_memory_gb,
apply_software=apply_software_dict,
apply_disk_gb=apply_disk_gb,
apply_system=apply_system_dict,
apply_filesystem=apply_filesystem_dict,
apply_expiration=apply_expiration_str)
if not ord_ins:
self.get_queryset().filter(id=ins.id).delete()
return Response({
"status": -1,
"msg": "数据创建失败,申请删除",
"data": []
})
# ord_ins.apply_expiration = apply_expiration_str
# ord_ins.save()
data['approval_data'] = model_to_dict(ord_ins)
return Response({"status": 1, "msg": "创建申请数据成功", "data": data})
def user_edit(request):
"""
修改用户信息
* 参数
** id - 用户id
** email - 邮箱地址
** password - 密码
** name - 显示名称
** role - 角色(CU/GM/SN), SU只通过后台创建
** is_active - 激活状态
** aam_id - 统一认证号
"""
msg_prefix = u"修改用户信息 ID:%s "
req_dict = post_data_to_dict(request.data)
req_user = request.user
id = smart_get(req_dict, 'id', int)
email = smart_get(req_dict, 'email', str, '')
password = smart_get(req_dict, 'password', str, '')
name = smart_get(req_dict, 'name', unicode, '')
role = smart_get(req_dict, 'role', str, '')
is_active = smart_get(req_dict, 'is_active', bool, True)
aam_id = smart_get(req_dict, 'aam_id', str, '')
try:
user = ExUser.objects.get(pk=int(id))
# 判定是否高权限调用
lv_admin = "I00201" in get_menus(req_user)
if not lv_admin and req_user != user:
raise PermissionDenied()
if email:
user.email = email
if role and lv_admin:
user.role = role
user.is_superuser = (role == 'SU')
user.is_staff = (role == 'SU')
if name:
user.name = name
if password:
user.set_password(password)
if aam_id:
user.aam_id = aam_id
# 防止admin被冻结
if user.username == 'admin':
is_active = True
user.is_active = is_active
user.save()
serializer = serializers.ExUserDetailSerializer(user)
except Exception, e:
if isinstance(e, APIException):
raise e
msg = (msg_prefix % id) + u"失败, 错误信息: " + unicode(e)
logger.error(msg)
return Response({
"status": -1,
"msg": msg,
"data": {}
},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def create(self, request, *args, **kwargs):
"""
创建节点
"""
msg_prefix = u"创建节点 "
req_dict = post_data_to_dict(request.data)
component_id = smart_get(req_dict, 'component_id', int)
component_type = smart_get(req_dict, 'component_type', int)
blue_print_id = smart_get(req_dict, 'blue_print_id', int)
try:
commonent_instance_params = None
if component_type == 0: # 接口
instance_set = BlueInterfaceDefinition.objects.filter(id=component_id)
for instance in instance_set:
commonent_instance_params = serializers.BlueInterfaceParamSerializer(
instance.params.all(), many=True).data
serializer = serializers.BlueInterfaceDefinitionSerializer(instance=instance_set, many=True).data[0]
elif component_type == 1: # 参数
instance_set = BluePreParamGroup.objects.filter(id=component_id)
for instance in instance_set:
commonent_instance_params = serializers.BluePreParamGroupParamSerializer(
instance.params.all(), many=True).data
serializer = serializers.BluePreParamGroupSerializer(instance=instance_set, many=True).data[0]
elif component_type == 2: # 模块
instance_set = BlueAccessModuleParamGroup.objects.filter(id=component_id)
for instance in instance_set:
commonent_instance_params = serializers.BlueAccessModuleParamsGroupParamSerializer(
instance.params.all(), many=True).data
serializer = serializers.BlueAccessModuleParamGroupSerializer(instance=instance_set, many=True).data[0]
elif component_type == 3: # 蓝图
instance_set = BluePrintDefinition.objects.filter(id=component_id)
serializer = serializers.BluePrintDefinitionSerializer(instance=instance_set, many=True).data[0]
else:
instance_set = list()
serializer = list()
commonent_instance_params = list()
if not len(instance_set):
raise Exception(u"组件不存在， 请联系管理员！")
serializer.update(params=commonent_instance_params)
kwargs = dict(
name=instance_set[0].name,
blue_print=blue_print_id,
component_type=component_type,
component_data=serializer
)
blue_node_serializer = self.get_serializer(data=kwargs)
blue_node_serializer.is_valid(raise_exception=True)
blue_node_instance = blue_node_serializer.save()
blue_node_instance.key = blue_node_instance.id
blue_node_instance.save()
blue_print_instance = BluePrintDefinition.objects.get(id=blue_print_id)
blue_print_instance.keep_status = 0
blue_print_instance.save()
except Exception, e:
msg = msg_prefix + u"失败, 错误信息: " + unicode(e)
logger.error(format_exc())
return Response({"status": -1, "msg": msg, "data": {}},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def create(self, request, *args, **kwargs):
"""
创建审批数据用的
:param request:
:param args:
:param kwargs:
:return:
"""
msg_prefix = u"创建审批数据"
approve_user = request.user
req_dict = post_data_to_dict(request.data)
# print "!" * 120
# print req_dict
# print "!" * 120
business_data_dict = req_dict.get("business_data")
process_info_dict = req_dict.get("process_info")
blue_print_info_dict = req_dict.get("blue_print_info")
print process_info_dict
if not business_data_dict:
return Response({"status": -1, "mag": "错误，无业务信息", 'data': []})
if not process_info_dict:
return Response({"status": -1, "mag": "错误，无流程信息", 'data': []})
approve_data_dict = business_data_dict.get("submit_data")
approve_result_list = business_data_dict.get("submit_result")
if not approve_data_dict:
return Response({"status": -1, "mag": "错误，无审批信息", 'data': []})
# if not approve_result_list:
# return Response({"status":-1, "mag":"错误，无审批配置信息", 'data':[]})
approve_info_dict = approve_data_dict.get("submit_info")
host_config_data_list = approve_data_dict.get("host_config_data")
if not approve_info_dict:
return Response({"status": -1, "mag": "错误，无审批基本信息", 'data': []})
if not host_config_data_list:
return Response({"status": -1, "mag": "错误，无审批配置信息", 'data': []})
approve_msg = approve_info_dict.get("submit_advice") # 审批意见
# process_ins_dict = process_info_dict.get("process_ins_info")
process_task_ins_dict = process_info_dict.get("first_task_instance")
# if not process_ins_dict:
# return Response({"status":-1, "mag":"错误，无流程实例信息", 'data':[]})
# if not process_task_ins_dict:
# return Response({"status":-1, "mag":"错误，无任务实例信息", 'data':[]})
process_ins_number = process_info_dict.get("process_instance_number")
# print process_ins_number
process_task_ins_id = process_task_ins_dict.get("id")
approval_ins = VMGenerateApproval.objects.filter(
workflow_number=process_ins_number).first()
if not approval_ins:
return Response({"status": -1, "mag": "错误，并无申请记录", 'data': []})
approval_ins_number = approval_ins.approval_number
# '先创建申请表数据'
now_time = time.strftime("%Y%m%d", time.localtime()) # 年月日
instance_set = VMGenerateApprove.objects.all()
instance_len = len(instance_set)
i = 1
i += instance_len
k = "%03d" % i
# l1 = str(time.time())
# format_number = "approve" + now_time+l1[-2:] + k
format_number = "approve" + now_time + k
blue_instance_number = blue_print_info_dict.get("blue_instance_number")
blue_status = blue_print_info_dict.get("blue_status")
# blue_print_info_dict.get("blue_status")
status_number = ''
if blue_status == 3: # 异常
status_number = blue_status
elif blue_status == 2: # 完成
status_number = blue_status
# approve_number = approve_info_dict.get("approve_number")
approve_ord_id = approve_info_dict.get("approve_ord_id")
# if approve_number:# 如果是已经存在的审批单
# old_approve_ins = VMGenerateApprove.objects.filter(approve_number=approve_number).first()
approve_ord_ins = VMGenerateApproveOrd.objects.filter(
id=approve_ord_id).first()
# print "%" *20
# print approve_ord_ins
# print "%" *20
old_approve_ins = approve_ord_ins.approve
if old_approve_ins and approve_ord_ins:
# print "dasdasdasdasdasd"
old_approve_ins.status = status_number
old_approve_ins.approve_result = approve_result_list
old_approve_ins.save()
# approve_ord_ins = VMGenerateApprovalOrd.objects.filter(id=approve_ord_id).first()
host_config_data_dict = host_config_data_list[0]
appro_expiration_str = smart_get(approve_info_dict,
'submit_expiration', str)
appro_application_list = approve_info_dict.get(
"submit_application")
env_type = host_config_data_dict.get("env_type")
appro_deploy_place = host_config_data_dict.get("deploy_location")
appro_os_version = host_config_data_dict.get("os_version")
appro_node_type = host_config_data_dict.get("node_type")
appro_network_area_str = host_config_data_dict.get("network_area")
appro_cpu = host_config_data_dict.get("target_cpu_cores")
appro_memory_gb = host_config_data_dict.get("target_mem_gb")
# appro_software_list = i.get("software",{})
appro_disk_gb = host_config_data_dict.get("add_datadisk_gb")
appro_system_dict = host_config_data_dict.get("system_type")
appro_filesystem_dict = host_config_data_dict.get(
"apply_filesystem")
# approve_ord_ins.approve=old_approve_ins
approve_ord_ins.env_type = env_type
approve_ord_ins.deploy_location = appro_deploy_place
approve_ord_ins.appro_os_version = appro_os_version
approve_ord_ins.node_type = appro_node_type
approve_ord_ins.application = appro_application_list
#approve_ord_ins.appro_software=appro_software_list,
approve_ord_ins.network_area = appro_network_area_str
approve_ord_ins.target_cpu_cores = appro_cpu
approve_ord_ins.target_mem_gb = appro_memory_gb
approve_ord_ins.add_datadisk_gb = appro_disk_gb
approve_ord_ins.expiration = appro_expiration_str
approve_ord_ins.system_type = appro_system_dict
approve_ord_ins.apply_filesystem = appro_filesystem_dict
approve_ord_ins.configuration_resource_information = host_config_data_dict
approve_ord_ins.save()
if not approve_ord_ins:
is_delete = VMGenerateApprove.objects.filter(
approve_number=approve_ord_ins.approval.approve_number
).delete()
if is_delete:
return Response({
"status": -1,
"msg": "审批数据创建失败，审批工单已删除",
"data": []
})
data = model_to_dict(approve_ord_ins)
return Response({"status": 1, "msg": "重新创建审批数据成功", "data": data})
else:
approve_ins = VMGenerateApprove.objects.create(
approval_number=approval_ins_number,
approve_number=format_number,
workflow_number=process_ins_number,
workflow_note_ins_id=process_task_ins_id,
status=status_number,
aprover=approve_user,
approve_msg=approve_msg,
approve_result=approve_result_list,
blue_ins_number=blue_instance_number)
if not approve_ins:
return Response({
"status": -1,
"mag": "错误，无法创建审批信息",
'data': []
})
# '循环创建审批数据'
# print len(host_profile_list)
appro_expiration_str = smart_get(approve_info_dict,
'submit_expiration', str)
appro_application_list = approve_info_dict.get(
"submit_application")
list1 = []
for i in host_config_data_list:
# 'i 为每个 主机配置信息 字典格式'
if not i:
return Response({
"status": -1,
"msg": "审批工单创建失败",
"data": []
})
env_type = i.get("env_type")
appro_deploy_place = i.get("deploy_location")
appro_os_version = i.get("os_version")
appro_node_type = i.get("node_type")
appro_network_area_str = i.get("network_area")
appro_cpu = i.get("target_cpu_cores")
appro_memory_gb = i.get("target_mem_gb")
# appro_software_list = i.get("software",{})
appro_disk_gb = i.get("add_datadisk_gb")
appro_system_dict = i.get("system_type")
appro_filesystem_dict = dict(i.get("apply_filesystem"))
print appro_filesystem_dict
# print type(appro_application_list)
# print type(i)
approve_ord_ins = VMGenerateApproveOrd.objects.create(
approve=approve_ins,
env_type=env_type,
deploy_location=appro_deploy_place,
appro_os_version=appro_os_version,
node_type=appro_node_type,
application=appro_application_list,
# appro_software=appro_software_list,
network_area=appro_network_area_str,
target_cpu_cores=appro_cpu,
target_mem_gb=appro_memory_gb,
add_datadisk_gb=appro_disk_gb,
expiration=appro_expiration_str,
system_type=appro_system_dict,
apply_filesystem=appro_filesystem_dict,
configuration_resource_information=i,
)
if not approve_ord_ins:
is_delete = VMGenerateApprove.objects.filter(
approve_number=approve_ins.approve_number).delete()
if is_delete:
return Response({
"status": -1,
"msg": "审批数据创建失败，审批工单已删除",
"data": []
})
data = model_to_dict(approve_ord_ins)
list1.append(data)
if not list1:
return Response({"status": -1, "msg": "审批数据查看失败", "data": []})
return Response({"status": 1, "msg": "创建审批数据成功", "data": list1})
