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)