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})