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 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 option_edit(request):
"""
修改动态表单选项
* 权限 - 超级管理员(SU)
* 参数
** app - 模块名称
** name - 表单名称
** value - 选项值
** display - 选项显示名称
** 其他 - 其他附加属性
"""
msg_prefix = u"修改表单选项 <%s>:<%s> "
req_dict = post_data_to_dict(request.data)
app = req_dict.pop('app')
name = req_dict.pop('name')
value = req_dict.pop('value')
display = req_dict.pop('display', '')
try:
updated = DataDict.options.update_option(app, name, value, display, **req_dict)
data = DataDict.options.get_options_serialized(app, name)
except Exception, e:
msg = (msg_prefix % (name, value)) + 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 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 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 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 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 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 option_names(request):
"""
根据应用名获取表单名
"""
msg_prefix = u"获取表单名列表 "
req_dict = post_data_to_dict(request.data)
app = req_dict.pop('app')
try:
names = DataDict.options.get_name(app=app)
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 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 blue_engine_task_recover(request):
"""
需要参数
{
"blue_instance_number": "",
"current_note_id": "",
}
"""
'接收参数'
req_data = post_data_to_dict(request.data)
req = BLueEngine.fix_wrong_node_task(req_data)
if req['status'] == -1:
return Response({"status": -1, "msg": "恢复失败", "data": req})
# print req
if req['status'] == 1:
return Response({"status": 1, "msg": "恢复执行成功，正在进行恢复", "data": req})
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 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 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 create(self, request, *args, **kwargs):
msg_prefix = "创建/获取蓝图草稿 "
req_dict = post_data_to_dict(request.data)
category, created = BlueCategory.objects.get_or_create(name=DEFAULT_CATEGORY)
try:
blue_instance = BluePrintDefinition.objects.filter(created_user=request.user, keep_status=0).last()
if blue_instance:
serializer = self.get_serializer(blue_instance)
else:
req_dict['created_user'] = request.user.name
req_dict['category'] = category
serializer = self.get_serializer(data=req_dict)
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 option_list(request):
"""
获取动态表单选项
* 权限 - 任何人
* 参数
** app - 模块名称
** name - 表单名称
** 其他 - 其他附加属性
"""
msg_prefix = u"获取表单选项 <%s> "
req_dict = post_data_to_dict(request.data)
app = req_dict.pop('app')
name = req_dict.pop('name')
try:
data = DataDict.options.get_options_serialized(app, name, **req_dict)
except Exception, e:
msg = (msg_prefix % name) + 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 option_delete(request):
"""
删除动态表单选项
* 权限 - 超级管理员(SU)
* 参数
** app - 模块名称
** name - 表单名称
** value - 选项值(','号分隔列表)
"""
msg_prefix = u"删除表单选项 <%s>:<%s> "
req_dict = post_data_to_dict(request.data)
app = req_dict.pop('app')
name = req_dict.pop('name')
value = split(req_dict.pop('value'), ',')
try:
deleted = DataDict.options.delete_options(app, name, *value)
data = DataDict.options.get_options_serialized(app, name)
except Exception, e:
msg = (msg_prefix % (name, ','.join(value))) + u"失败, 错误信息: " + unicode(e)
logger.error(format_exc())
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 restart_bw_mq(request):
"""
用于重启流程和蓝图
:param request:
:return:
"""
# req_data = request.data
# 调用查询蓝图
PORT = "8030"
# PORT = LOCAL_PORT
blue_relative_url = "/iconfig/blue-engine-query/"
process_agree_relative_url = "/iworkflow/taskinstance/agree_interface/"
process_over_relative_url = "/iworkflow/pinstance/process_over/"
process_ins_error_relative_url = "/iworkflow/taskinstance/process-ins-error/"
# req_data = post_data_to_dict(request.data)
authorization = request.META.get(
'HTTP_AUTHORIZATION') # token 76e25c7f4265592a44f258261180a175f20912d4
headers = {
'content-type': 'application/json',
"authorization": authorization
}
base_url = "http://" + LOCAL_HOST + ":" + PORT
blue_url = "http://" + LOCAL_HOST + ":" + PORT + blue_relative_url
process_agree_url = "http://" + LOCAL_HOST + ":" + PORT + process_agree_relative_url
process_over_url = "http://" + LOCAL_HOST + ":" + PORT + process_over_relative_url
process_ins_error_url = "http://" + LOCAL_HOST + ":" + PORT + process_ins_error_relative_url
ori_data = post_data_to_dict(request.data)
# req_data = format_request(data=ori_data)
blue_func_req = transfer_bp(url=blue_url,
headers=headers,
req_data=ori_data)
# print "!" * 100
# print blue_func_req
# print "!" * 100
if blue_func_req['status'] == -1: # 函数调用失败
return Response({"status": -1, "msg": "调用蓝图的接口失败", 'data': []})
elif blue_func_req['status'] == 1:
ret_data = blue_func_req['data']
if not ret_data:
return Response({"status": -1, "msg": "调用蓝图的接口返回值为空", 'data': []})
blue_print_info_dict = ret_data.get('blue_print_info')
while blue_print_info_dict['blue_status'] == 1:
print "蓝图sss正在执行中"
# 修改流程状态
process_req = edit_process_status(ori_data, 0)
if process_req['status'] == -1:
return Response({
"status": -1,
"msg": "调用流程修改状态的操作失败",
'data': []
})
# 再次检测
blue_func_req = transfer_bp(url=blue_url,
headers=headers,
req_data=ori_data)
time.sleep(5) # 5秒发送
ret_data = blue_func_req['data'] # 源数据
if not ret_data:
return Response({
"status": -1,
"msg": "调用蓝图的接口返回值为空",
'data': []
})
blue_print_info_dict = ret_data.get('blue_print_info')
if blue_print_info_dict['blue_status'] == 3: # 调用流程异常的接口
# 修改流程
process_error_func_req = transfer_workflow_error_process(
url=process_ins_error_url, headers=headers, req_data=ori_data)
if process_error_func_req['status'] == -1:
return Response({
"status": -1,
"msg": "调用流程异常接口返回值为失败",
'data': process_error_func_req
})
elif process_error_func_req['status'] == 1: # 同意成功就可以结束进程了
return Response({
"status": 1,
"msg": "调用流程异常接口返回值为成功",
'data': process_error_func_req['data']
})
elif blue_print_info_dict['blue_status'] == 2: # 蓝图状态已经完成了
business_info_dict = ret_data.get('business_data') # 业务数据字典
if not business_info_dict:
return Response({
"status": -1,
"msg": "业务数据回写失败,调用失败",
'data': []
})
business_info_dict['submit_result'] = blue_print_info_dict.get(
'result_data')
ori_data['business_data'] = business_info_dict # 重写 业务数据
finish_req = data_analysis_and_data_write_back(req_data=ori_data,
base_url=base_url,
headers=headers)
if finish_req['status'] == -1:
finish_ret = finish_req['data']
return Response({
"status": -1,
"msg": "调用业务数据回写接口返回值为失败",
'data': finish_ret
})
process_func_req = transfer_workflow_agree(url=process_agree_url,
headers=headers,
req_data=ori_data)
# print process_func_req
if process_func_req['status'] == -1:
return Response({
"status": -1,
"msg": "调用流程同意接口返回值为失败",
'data': []
})
elif process_func_req['status'] == 1: # 同意成功就可以结束进程了
req_data = process_func_req['data']
process_ins_over_req = transfer_workflow_over_process(
url=process_over_url, headers=headers, req_data=req_data)
if process_ins_over_req['status'] == -1:
return Response({
"status": -1,
"msg": "调用流程结束接口返回值为失败",
'data': []
})
elif process_ins_over_req['status'] == 1: # 结束接口返回值成功
return Response({
"status": 1,
"msg": "重新调用流程结束接口返回成功",
'data': process_ins_over_req['data']
})
return Response({
"status": 1,
"msg": "蓝图状态已经完成了",
'data': ori_data
})
return Response({"status": 1, "msg": "蓝图状态正常", 'data': ori_data})
def bwmq_api(request):
"""
用来接收请求和循环调用蓝图和流程等接口
:param request:
:return:
"""
##########################新代码##################################################
# PORT = "8030"
PORT = LOCAL_PORT
# print PORT
blue_relative_url = "/iconfig/blue-engine-query/"
process_agree_relative_url = "/iworkflow/taskinstance/agree_interface/"
process_over_relative_url = "/iworkflow/pinstance/process_over/"
process_ins_error_relative_url = "/iworkflow/taskinstance/process-ins-error/"
# req_data = post_data_to_dict(request.data)
authorization = request.META.get(
'HTTP_AUTHORIZATION') # token 76e25c7f4265592a44f258261180a175f20912d4
headers = {
'content-type': 'application/json',
"authorization": authorization
}
base_url = "http://" + LOCAL_HOST + ":" + PORT
blue_url = "http://" + LOCAL_HOST + ":" + PORT + blue_relative_url
process_agree_url = "http://" + LOCAL_HOST + ":" + PORT + process_agree_relative_url
process_over_url = "http://" + LOCAL_HOST + ":" + PORT + process_over_relative_url
process_ins_error_url = "http://" + LOCAL_HOST + ":" + PORT + process_ins_error_relative_url
ori_data = post_data_to_dict(request.data)
req_data = format_request(data=ori_data)
if req_data['status'] == -1:
return Response({"status": -1, "msg": "格式化数据函数执行失败", "data": []})
elif req_data['status'] == 1:
every_blue_print_list = req_data.get('data')
fin_list = []
for data in every_blue_print_list: # 循环每一个源格式的请求对象
# 调用蓝图的接口
time.sleep(0.3) # 太快会报错
blue_func_req = transfer_bp(url=blue_url,
headers=headers,
req_data=data)
print "!" * 100
print blue_func_req
print "!" * 100
if blue_func_req['status'] == -1: # 函数调用失败
return Response({"status": -1, "msg": "调用蓝图的接口失败", 'data': []})
elif blue_func_req['status'] == 1:
ret_data = blue_func_req['data']
if not ret_data:
return Response({
"status": -1,
"msg": "调用蓝图的接口返回值为空",
'data': []
})
blue_print_info_dict = ret_data.get('blue_print_info')
print "循环查询蓝图状态之前:", blue_print_info_dict
while blue_print_info_dict['blue_status'] == 1:
print "蓝图sss正在执行中"
blue_func_req = transfer_bp(url=blue_url,
headers=headers,
req_data=data)
print "循环查询蓝图状态内容:", blue_func_req
time.sleep(3) # 3秒发送
ret_data = blue_func_req['data'] # 源数据
if not ret_data:
return Response({
"status": -1,
"msg": "调用蓝图的接口返回值为空",
'data': []
})
blue_print_info_dict = ret_data.get('blue_print_info')
if blue_print_info_dict['blue_status'] == 3: # 调用流程异常的接口
# 异常的话先调用业务数据接口
finish_req = data_analysis_and_data_write_back(
req_data=ret_data, base_url=base_url, headers=headers)
if finish_req['status'] == -1:
finish_ret = finish_req['data']
return Response({
"status": -1,
"msg": "调用业务数据回写接口返回值为失败",
'data': finish_ret
})
if finish_req['status'] == 1:
finish_ret = finish_req['data']
fin_list.append(ret_data)
elif blue_print_info_dict['blue_status'] == 2: # 蓝图状态已经完成了
# time.sleep(1) # 太快会报错
business_info_dict = ret_data.get(
'business_data') # 业务数据字典
if not business_info_dict:
return Response({
"status": -1,
"msg": "业务数据回写失败,调用失败",
'data': []
})
business_info_dict[
'submit_result'] = blue_print_info_dict.get(
'result_data')
ret_data['business_data'] = business_info_dict # 重写 业务数据
finish_req = data_analysis_and_data_write_back(
req_data=ret_data, base_url=base_url, headers=headers)
if finish_req['status'] == -1:
finish_ret = finish_req['data']
return Response({
"status": -1,
"msg": "调用业务数据回写接口返回值为失败",
'data': finish_ret
})
if finish_req['status'] == 1:
fin_list.append(ret_data)
is_ok_status_list = []
submit_result_list1 = [] # 多个蓝图结果的返回的列表，只有成功的
# 获取部分原始请求信息和返回结果进行重新结构组合
old_process_info_dict = request.data.get("process_info")
old_map_relation_dict = request.data.get("map_relation")
old_business_data_dict = request.data.get("business_data")
old_blue_print_info_list = request.data.get("blue_print_info")
# old_submit_data_dict = old_business_data_dict.get("submit_data")
for i in fin_list:
blue_print_info_dict = i.get('blue_print_info')
blue_status = blue_print_info_dict.get('blue_status')
is_ok_status_list.append(blue_status)
#############将数据重新打包成调度中心调度之前的结构，重新传给流程
business_data_dict = i.get('business_data')
submit_result_list = business_data_dict.get('submit_result')
for submit_result in submit_result_list:
submit_result_list1.append(submit_result)
# 蓝图执行后的结果重写到原来的位置
old_business_data_dict["submit_result"] = submit_result_list1
net_refactoring_dict = {}
net_refactoring_dict["process_info"] = old_process_info_dict
net_refactoring_dict["map_relation"] = old_map_relation_dict
net_refactoring_dict["business_data"] = old_business_data_dict
net_refactoring_dict["blue_print_info"] = old_blue_print_info_list
set1 = set(is_ok_status_list)
set0 = {2}
print "打印出蓝图状态列表:", set1
#
if set1 != set0: # 有异常的蓝图
print "调用流程异常的接口"
# blue_print_info_dict=req_data['blue_print_info']
process_error_func_req = transfer_workflow_error_process(
url=process_ins_error_url,
headers=headers,
req_data=net_refactoring_dict)
if process_error_func_req['status'] == -1:
return Response({
"status": -1,
"msg": "调用流程异常接口返回值为失败",
'data': process_error_func_req
})
elif process_error_func_req['status'] == 1: # 同意成功就可以结束进程了
return Response({
"status": 1,
"msg": "调用流程异常接口返回值为成功",
'data': process_error_func_req['data']
})
# return Response({"status": 1, "msg": "调用业务数据回写接口返回值为成功", 'data': finish_ret})
else: # 都是完成的蓝图
print "调用流程同意的接口"
process_func_req = transfer_workflow_agree(
url=process_agree_url,
headers=headers,
req_data=net_refactoring_dict)
if process_func_req['status'] == -1:
return Response({
"status": -1,
"msg": "调用流程同意接口返回值为失败",
'data': []
})
elif process_func_req['status'] == 1: # 同意成功就可以结束进程了
req_data = process_func_req['data']
process_ins_over_req = transfer_workflow_over_process(
url=process_over_url, headers=headers, req_data=req_data)
if process_ins_over_req['status'] == -1:
return Response({
"status": -1,
"msg": "调用流程结束接口返回值为失败",
'data': []
})
elif process_ins_over_req['status'] == 1: # 结束接口返回值成功
return Response({
"status": 1,
"msg": "调用流程结束接口返回值为成功",
'data': process_ins_over_req
})
return Response({
"status": 1,
"msg": "格式化数据函数执行成功",
"data": net_refactoring_dict
})
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 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)
