def get(self): # http://127.0.0.1:8000/v1/api_data_collection_devices/?device_id=3 device_id = views_helper.get_request_value(self.request, 'device_id', 'GET') # load devices list,init action if not device_id: devices_list = Devices.objects.filter(status=1).values( 'device_id', 'hostname') arry = [] for item in devices_list: arry.append(item) data = { 'devices': arry, 'new_token': self.new_token, constants.STATUS: { constants.STATUS: constants.TRUE, constants.MESSAGE: constants.SUCCESS } } return api_return(data=data) else: arry = self.__set_items_info_by_device(device_id) data = { 'data': arry, 'new_token': self.new_token, constants.STATUS: { constants.STATUS: constants.TRUE, constants.MESSAGE: constants.SUCCESS } } return api_return(data=data)
def post(self): """!@brief Create policy group @return data: the status of whether create successful and the inserted data """ try: with transaction.atomic(): data = { 'name': self.name, 'desc': self.desc, 'ostypeid': self.ostype, } if self.name is not '': get_name_from_cpg = self.get_cp_group( **{'name': self.name}) if get_name_from_cpg is not False: data = { constants.STATUS: { constants.STATUS: constants.FALSE, constants.MSG_TYPE: 'NAME_DUPLICATE', constants.MESSAGE: constants. COLLECTION_POLICY_GROUP_NAME_DUPLICATE } } return api_return(data=data) cps = views_helper.get_request_value(self.request, 'cps', 'BODY') serializer = CollPolicyGroupSerializer(data=data) if serializer.is_valid(Exception): serializer.save() policy_group_data = [] for per_cp in cps: per_cp['policy_group'] = int( serializer.data.get('policy_group_id')) per_cp['history'] = time.time() per_cp['policy'] = per_cp['policy'] policy_group_data.append(per_cp) serializer_related = PolicyGroupSerializer( data=policy_group_data, many=True) if serializer_related.is_valid(Exception): serializer_related.save() data = { 'data': { 'data_coll_policy': serializer.data, 'data_policys_groups': serializer_related.data, }, 'new_token': self.new_token, constants.STATUS: { constants.STATUS: constants.TRUE, constants.MESSAGE: constants.POST_SUCCESSFUL } } return api_return(data=data) except Exception, e: if constants.DEBUG_FLAG: print traceback.format_exc(e) return exception_handler(e)
def delete(self): """@brief delete a group @return: the success when delete success and error when delete fail """ try: with transaction.atomic(): if self.group_id: kwards_schedules = {'device_group_id': self.group_id} queryset_schedules = Schedules.objects.filter( **kwards_schedules) if queryset_schedules.count() != 0: data = { 'new_token': self.new_token, constants.STATUS: { constants.STATUS: constants.FALSE, constants.MESSAGE: constants.EXISTS_IN_SCHEDULES } } return api_return(data=data) kwards_devicegroup = {'group_id': self.group_id} queryset_device = DevicesGroups.objects.filter( **kwards_devicegroup) if queryset_device.count() != 0: data = { 'new_token': self.new_token, constants.STATUS: { constants.STATUS: constants.FALSE, constants.MESSAGE: constants.EXISTS_IN_DEVICESGROUPS } } return api_return(data=data) queryset = self.get_group({'group_id': self.group_id}) if queryset: queryset.delete() data = { 'new_token': self.new_token, constants.STATUS: { constants.STATUS: constants.TRUE, constants.MESSAGE: constants.SUCCESS } } return api_return(data=data) else: data = { 'new_token': self.new_token, constants.STATUS: { constants.STATUS: constants.FALSE, constants.MESSAGE: constants.GROUP_NOT_EXIST } } return api_return(data=data) except Exception, e: transaction.rollback() print e raise e
def get(self): """!@brief Rest Api of GET, get all the data for summary page or get the data according to table id @return data: the data for summary page """ try: if self.id is not '': data = self.get_info_by_table_id(self.id) return api_return(data=data) field_relation_ships = { 'table_id': 'id', 'name': 'name', 'descr': 'descr', } query_data = { 'name': self.name, 'desc': self.desc, } search_fields = ['name', 'desc'] sorts, search_conditions = views_helper.get_search_conditions( self.request, field_relation_ships, query_data, search_fields) total_num = len(DataTable.objects.all()) if search_conditions: queryset = DataTable.objects.filter( **search_conditions).values(*[ 'table_id', 'descr', 'name', 'coll_policy', 'groups', 'tree', 'coll_policy__policy_type' ]).order_by(*sorts) else: queryset = DataTable.objects.all().values(*[ 'table_id', 'descr', 'name', 'coll_policy', 'groups', 'tree', 'coll_policy__policy_type' ]).order_by(*sorts) # serializer = ActionPolicyDataTableSerializer(queryset, many=True) paginator = Paginator(list(queryset), int(self.max_size_per_page)) contacts = paginator.page(int(self.page_from)) data = { 'data': { 'data': contacts.object_list, }, 'new_token': self.new_token, 'num_page': paginator.num_pages, # 'page_range': list(paginator.page_range), 'page_has_next': contacts.has_next(), 'total_num': total_num, 'current_page_num': contacts.number, constants.STATUS: { constants.STATUS: constants.TRUE, constants.MESSAGE: constants.SUCCESS }, } return api_return(data=data) except Exception, e: if constants.DEBUG_FLAG: print traceback.format_exc(e) return exception_handler(e)
def post(self): """!@brief add one schedule into schedule table,and many items into item table @author Gin Chen @date 2018/1/5 """ try: with transaction.atomic(): param_dict = self.__set_request_param() opt = DataCollectionOptCls(**param_dict) # ready devices_list, coll_policy_list = opt.add_new_schedule_ready() # check whether the tree of cp is null or not for cp_dict in coll_policy_list: cp_id = cp_dict['coll_policy_id'] if cp_dict['item_type'] == constants.ITEM_TYPE_CLI: cp_leaf_nodes = CollPolicyRuleTree.objects.filter( coll_policy=cp_id, is_leaf=constants.LEAF_NODE_MARK) if len(cp_leaf_nodes) == 0: data = { 'new_token': self.new_token, constants.STATUS: { constants.STATUS: constants.FALSE, constants.MESSAGE: constants.NULL_TREE_IN_CP } } return api_return(data=data) # insert schedule res = opt.insert_new_schedule(devices_list, coll_policy_list) if res[0]: # create item by schedule opt.insert_new_items(devices_list, res[1], coll_policy_list) data = { 'new_token': self.new_token, constants.STATUS: { constants.STATUS: constants.TRUE, constants.MESSAGE: constants.SUCCESS } } else: data = { 'new_token': self.new_token, constants.STATUS: { constants.STATUS: constants.FALSE, constants.MESSAGE: res[1] } } return api_return(data=data) except Exception, e: if constants.DEBUG_FLAG: print traceback.format_exc(e) return exception_handler(e)
def get(self): # http://127.0.0.1:8000/v1/api_data_collection_policy/?policy_id=3&device_name=test # http://127.0.0.1:8000/v1/api_data_collection_policy/?page=1&rows=1&policy_id=3&device_name=test coll_policy_id = views_helper.get_request_value(self.request, "coll_policy_id", "GET") device_name = views_helper.get_request_value(self.request, "device", "GET") if not coll_policy_id: # load all coll_policy coll_policy_list = CollPolicy.objects.values('coll_policy_id', 'name', 'policy_type') arry = [] for item in coll_policy_list: arry.append(item) data = { 'policies': arry, 'new_token': self.new_token, constants.STATUS: { constants.STATUS: constants.TRUE, constants.MESSAGE: constants.SUCCESS } } return api_return(data=data) else: response_json_data = Tool.get_valid_item_by_cp({"policys_groups__status": 1, "coll_policy_id": coll_policy_id}) arry = [] for one_recoder in response_json_data: if device_name: if device_name in one_recoder['device_name']: isFilter = True else: isFilter = False else: isFilter = True if int(one_recoder['coll_policy_id']) == int(coll_policy_id) and isFilter: info = { 'deviceNo': one_recoder['device_id'], 'device': one_recoder['device_name'], 'status': Tool.set_cp_status_mapping(one_recoder['btn_status']), } arry.append(info) total_num = len(arry) paginator = Paginator(arry, int(self.max_size_per_page)) contacts = paginator.page(int(self.page_from)) data = { 'data': contacts.object_list, 'num_page': paginator.num_pages, 'page_has_next': contacts.has_next(), 'total_num': total_num, 'current_page_num': contacts.number, 'new_token': self.new_token, constants.STATUS: { constants.STATUS: constants.TRUE, constants.MESSAGE: constants.SUCCESS } } return api_return(data=data)
def get(self): """!@brief When select column2 after choosing column1 in 新规页面, column1 and column2 should be same with below 3 points: 1.the same device group 2.the same schedule_id(data_table_item-->item-->schedule) 3.the same policy execute inteval(data_table_item-->item-->policys_groups) @post return verify result @return data: return verify result """ try: if self.table_id_A is not '' and self.table_id_B is not '': # table_a = DataTable.objects.filter(table_id=self.table_id_A).values('groups', 'coll_policy__value_type', # 'coll_policy__policy_type') table_a_str = '' table_b_str = '' table_a = DataTableItems.objects.filter( table_id=self.table_id_A).values('table__groups', 'item__schedule', 'item__policys_groups') if table_a: table_a_str = str(table_a[0]['table__groups']) + '_' + str( table_a[0]['item__schedule']) + '_' + str( table_a[0]['item__policys_groups']) # table_b = DataTable.objects.filter(table_id=self.table_id_B).values('groups', 'coll_policy__value_type', # 'coll_policy__policy_type') table_b = DataTableItems.objects.filter( table_id=self.table_id_B).values('table__groups', 'item__schedule', 'item__policys_groups') if table_b: table_b_str = str(table_b[0]['table__groups']) + '_' + str( table_b[0]['item__schedule']) + '_' + str( table_b[0]['item__policys_groups']) if table_a_str == table_b_str: data = { constants.STATUS: { constants.STATUS: constants.TRUE, constants.MESSAGE: constants.SUCCESS }, } return api_return(data=data) data = { constants.STATUS: { constants.STATUS: constants.FALSE, constants.MESSAGE: constants.COLUMN_A_COLUMN_B_VERIFY_FAILED }, } return api_return(data=data) except Exception, e: if constants.DEBUG_FLAG: print traceback.format_exc(e) return exception_handler(e)
def put(self): """!@brief commit the collection policy update information @param @pre @post @note @return the update information @author Gin Chen @date 2018/1/18 """ coll_policy_id = views_helper.get_request_value(self.request, "coll_policy_id", "BODY") name = views_helper.get_request_value(self.request, "coll_policy_name", "BODY") command = views_helper.get_request_value(self.request, "command", "BODY") desc = views_helper.get_request_value(self.request, "desc", "BODY") ostype = views_helper.get_request_value(self.request, "ostype", "BODY") coll_policy_update_data = { 'name': name, 'cli_command': command, 'desc': desc, 'ostype': ostype } if len(CollPolicy.objects.filter(~Q(coll_policy_id=coll_policy_id), name=name)): data = { 'data': '', 'new_token': self.new_token, constants.STATUS: { constants.STATUS: constants.FALSE, constants.MSG_TYPE: 'NAME_DUPLICATE', constants.MESSAGE: constants.COLLECTION_POLICY_NAME_DUPLICATE } } return api_return(data=data) obj = CollPolicy.objects.get(coll_policy_id=coll_policy_id) serializer = CollPolicyEditSerializer(instance=obj, data=coll_policy_update_data) try: if serializer.is_valid(): serializer.save() data = { 'data': serializer.data, 'new_token': self.new_token, constants.STATUS: { constants.STATUS: constants.TRUE, constants.MESSAGE: constants.SUCCESS } } return api_return(data=data) except Exception as e: if constants.DEBUG_FLAG: print traceback.format_exc(e) return exception_handler(e)
def post(self): """@brief create a new group @return: the created group when create success and error when create fail """ if "," in self.name: data = { 'new_token': self.new_token, constants.STATUS: { constants.STATUS: constants.FALSE, constants.MESSAGE: constants.GROUP_NAME_FORMAT_ERROR } } return api_return(data=data) kwargs_groupname = {'name': self.name} groups = self.get_group(kwargs_groupname) if groups: data = { 'new_token': self.new_token, constants.STATUS: { constants.STATUS: constants.FALSE, constants.MSG_TYPE: constants.NAME_DUPLICATE, constants.MESSAGE: constants.GROUP_ALREADY_EXISTS } } return api_return(data=data) kwargs_ostypeid = {"ostypeid": self.ostype_id} ostype = self.get_ostype(kwargs_ostypeid) ostype_id = ostype.ostypeid ostype = model_to_dict(ostype) try: with transaction.atomic(): data = { 'name': self.name, 'desc': self.desc, 'ostype': ostype, } serializer = DeviceGroupIDNameSerializer(data=data) if serializer.is_valid(Exception): serializer.save(ostype_id=ostype_id) data = { 'data': serializer.data, 'new_token': self.new_token, constants.STATUS: { constants.STATUS: constants.TRUE, constants.MESSAGE: constants.SUCCESS } } return api_return(data=data) except Exception, e: transaction.rollback() print e raise e
def delete(self): """!@brief Rest Api of DELETE, delete data according to table id @return data: the status of whether delete successful """ try: with transaction.atomic(): kwargs = {'table_id': self.id} data_in_dp = self.get_data_table(**kwargs) data_in_trigger = self.get_trigger(self.id) data_table_item_info = self.get_data_table_item_for_delete( **{'table_id': self.id}) if len(data_in_dp) <= 0: data = { 'new_token': self.new_token, constants.STATUS: { constants.STATUS: constants.FALSE, constants.MESSAGE: constants.DATA_TABLE_NOT_EXIST_IN_SYSTEM } } return api_return(data=data) if len(data_in_trigger) > 0: data = { 'new_token': self.new_token, constants.STATUS: { constants.STATUS: constants.FALSE, constants.MESSAGE: constants.DATA_TABLE_EXIST_IN_TRIGGER } } return api_return(data=data) data_table_item_info.delete() data_in_dp.delete() data = { 'new_token': self.new_token, constants.STATUS: { constants.STATUS: constants.TRUE, constants.MESSAGE: constants.DELETE_SUCCESSFUL } } return api_return(data=data) except Exception, e: transaction.rollback() if constants.DEBUG_FLAG: print traceback.format_exc(e) return exception_handler(e)
def get(self): try: queryset = CollPolicy.objects.all().values('coll_policy_id', 'value_type', 'name', 'policy_type') if self.id != '': queryset = CollPolicy.objects.filter(ostype=self.id).values( 'coll_policy_id', 'value_type', 'name', 'policy_type') # serializer = CollPolicyNameSerializer(queryset, many=True) for per in queryset: if per['policy_type'] == 1: # SNMP per['name'] = '[SNMP]' + per['name'] else: # CLI per['name'] = '[CLI]' + per['name'] data = { 'data': list(queryset), 'new_token': self.new_token, constants.STATUS: { constants.STATUS: constants.TRUE, constants.MESSAGE: constants.SUCCESS } } return api_return(data=data) except Exception, e: if constants.DEBUG_FLAG: print traceback.format_exc(e) return exception_handler(e)
def get(self): """!@brief when jump to 'add a new schedule page',init ostype ,policy group, device group list @param @pre @post @return ostype list,policy group list, @author Gin Chen @date 2018/1/5 """ if self.ostype_id: # when Os type is selected cp_groups_dict = self.__get_coll_policy_groups() device_groups_dict = self.__get_device_groups() data = { 'device_groups': device_groups_dict, 'cp_groups': cp_groups_dict, 'new_token': self.new_token, constants.STATUS: { constants.STATUS: constants.TRUE, constants.MESSAGE: constants.SUCCESS } } else: all_ostype_data = self.__get_ostype() data = { 'data': all_ostype_data, 'new_token': self.new_token, constants.STATUS: { constants.STATUS: constants.TRUE, constants.MESSAGE: constants.SUCCESS } } return api_return(data=data)
def post(self): """!@brief highlight function @param @pre @post @return the highlighted page @author Gin Chen @date 2017/12/18 """ request_dict = { 'data': self.raw_data, 'tree': self.tree, 'tree_id': self.tree_id } try: render = Render(**request_dict) html_data = render.render() data = { 'data': html_data, 'new_token': self.new_token, constants.STATUS: { constants.STATUS: constants.TRUE, constants.MESSAGE: constants.SUCCESS } } return api_return(data=data) except Exception, e: if constants.DEBUG_FLAG: print traceback.format_exc(e) return exception_handler(e)
def get(self): """!@brief Rest Api of GET, verify whether data table name was exist @return data: the status """ try: if self.name is not '': get_name_from_data_table = self.get_data_table( **{'name': self.name}) data = { constants.STATUS: { constants.STATUS: constants.TRUE, constants.MESSAGE: constants.SUCCESS } } if len(get_name_from_data_table) > 0: data = { constants.STATUS: { constants.STATUS: constants.FALSE, constants.MSG_TYPE: 'NAME_DUPLICATE', constants.MESSAGE: constants.DATA_TABLE_NAME_DUPLICATE } } return api_return(data=data) except Exception, e: if constants.DEBUG_FLAG: print traceback.format_exc(e) return exception_handler(e)
def get(self): """!@brief Get data in left for Step 4 when click [新规登陆] Get the tree for left in step 4 @return data: data for left in step 4 """ try: if self.id is not '': policy_tree = Policy_tree(self.id) # get policy tree policy_tree_dict = policy_tree.get_policy_tree() data = { 'data': { 'data': policy_tree_dict, }, 'new_token': self.new_token, constants.STATUS: { constants.STATUS: constants.TRUE, constants.MESSAGE: constants.SUCCESS, }, } return api_return(data=data) except Exception, e: if constants.DEBUG_FLAG: print traceback.format_exc(e) return exception_handler(e)
def delete(self): schedule_id = views_helper.get_request_value(self.request, 'id', 'GET') try: with transaction.atomic(): # close all function off thought update status =1 obj = Schedules.objects.get(schedule_id=schedule_id) all_function_status = obj.status # all function off is opened if all_function_status == 0 and obj.policy_group is None: device_group_id = obj.device_group Schedules.objects.filter( device_group=device_group_id).update(status=1) # delete items table # delete schedule table Items.objects.filter(schedule_id=schedule_id).delete() Schedules.objects.get(schedule_id=schedule_id).delete() data = { 'new_token': self.new_token, constants.STATUS: { constants.STATUS: constants.TRUE, constants.MESSAGE: constants.SUCCESS } } return api_return(data=data) except Exception as e: if constants.DEBUG_FLAG: print traceback.format_exc(e) return exception_handler(e)
def delete(self): """!@brief delete the rule @param @pre @post @note @return data rule tree and block rule tree @author Gin Chen @date 2017/12/25 """ try: rule_id = views_helper.get_request_value(self.request, key='rule_id', method_type='GET') policy_tree_id = views_helper.get_request_value(self.request, key='coll_policy_id', method_type='GET') CollPolicyCliRule.objects.get(ruleid=rule_id).delete() p = Policy_tree(policy_tree_id) rule_tree_tuple = p.get_rules_tree() data = { 'data': { "block_rule_tree_json": rule_tree_tuple[0], "data_rule_tree_json": rule_tree_tuple[1] }, constants.STATUS: { constants.STATUS: constants.TRUE, constants.MESSAGE: constants.SUCCESS } } return api_return(data=data) except Exception, e: if constants.DEBUG_FLAG: print traceback.format_exc(e) return exception_handler(e)
def get(self): """!@brief load the rule information when open the rule edit page @param @pre @post @return rule information,verify result(rule_is_used,is_processing,is_locked) @author Gin Chen @date 2017/12/25 """ try: coll_policy_id = views_helper.get_request_value(self.request, key='coll_policy_id', method_type='GET') rule_id = views_helper.get_request_value(self.request, key='rule_id', method_type='GET') query_set = CollPolicyRuleTree.objects.filter(rule=rule_id, coll_policy=coll_policy_id) is_used = False is_processing = False is_locked = False if len(query_set) > 0: is_processing = self.__judge_rule_is_processing(coll_policy_id) is_locked = self.__judge_rule_is_locked(coll_policy_id) is_used = True rule_info = CollPolicyCliRule.objects.get(ruleid=rule_id) result_dict = CollPolicyCliRuleSerializer(rule_info).data split_char = result_dict['split_char'] if split_char: if split_char == '@space@': result_dict['split_char'] = 4 result_dict['other_char'] = None elif split_char == ',': result_dict['split_char'] = 1 result_dict['other_char'] = None elif split_char == '/': result_dict['split_char'] = 2 result_dict['other_char'] = None else: result_dict['split_char'] = 3 result_dict['other_char'] = split_char data = { 'rule_is_used': is_used, 'is_processing': is_processing, 'is_locked': is_locked, 'data': result_dict, 'new_token': self.new_token, constants.STATUS: { constants.STATUS: constants.TRUE, constants.MESSAGE: constants.SUCCESS } } return api_return(data=data) except Exception, e: if constants.DEBUG_FLAG: print traceback.format_exc(e) return exception_handler(e)
def get(self): """!@brief Rest Api of GET, verify the expression @return data: the status of whether verify successful """ try: data = self.expression_verify() if data[constants.STATUS] is not 'False': data = { constants.STATUS: { constants.STATUS: constants.TRUE, constants.MESSAGE: constants.SUCCESS }, } return api_return(data=data) else: return api_return(data=data) except Exception, e: if constants.DEBUG_FLAG: print traceback.format_exc(e) return exception_handler(e)
def get(self, action_name=None): """!@brief Rest Api of GET, get all the data for summary page or get the data according to action name @return data: the data for summary page """ try: data = self.prepare_data_for_memory_cache(action_name) return api_return(data=data) except Exception as e: if constants.DEBUG_FLAG: print traceback.format_exc(e) return exception_handler(e)
def put(self): """@brief check and change the status of telnet and snmp in Device_Tmp table by the list of device_id @return: the status of check result """ try: with transaction.atomic(): data_list = self.data_list data_return = [] # telnet test pool = ThreadPool(device_views.CLI_THREADPOOL_SIZE) res_telnet = pool.map(self.telnet_status_check, data_list) pool.close() pool.join() for x in res_telnet: device_pre = DevicesTmp.objects.get(device_id=x[1]) telnet_res = x[0] data = { 'telnet_status': telnet_res, } serializer = DevicesTmpSerializer(device_pre, data=data, partial=True) if serializer.is_valid(Exception): serializer.save() # snmp test pool = ThreadPool(device_views.CLI_THREADPOOL_SIZE) res_snmp = pool.map(self.snmp_status_check, data_list) pool.close() pool.join() for x in res_snmp: device_pre = DevicesTmp.objects.get(device_id=x[1]) snmp_res = x[0] data = { 'snmp_status': snmp_res, } serializer = DevicesTmpSerializer(device_pre, data=data, partial=True) if serializer.is_valid(Exception): serializer.save() data_return.append(serializer.data) data = { 'data': data_return, 'new_token': self.new_token, constants.STATUS: { constants.STATUS: constants.TRUE, constants.MESSAGE: constants.SUCCESS }, } return api_return(data=data) except Exception, e: transaction.rollback() print e raise e
def csv_export(self): try: if self.id is not '': data_result = self.get_info_by_table_id(self.id) check_item_name = constants.EXPORT_CSV_TITLE_COLUMN_4 csv_data = [] if len(data_result['data']['data']): check_item_name = data_result['data']['data'][0][ 'checkitem'] if data_result['data']['data'][0]['item_type'].upper( ) == 'SNMP': check_item_name = 'Value' constants.EXPORT_CSV_TITLE_COLUMN_3 = 'OID' for per in data_result['data']['data']: if per['item_type'].upper() == 'CLI': csv_data.append([ per['hostname'], per['date'], per['path'], per['value'] ]) else: csv_data.append([ per['hostname'], per['date'], per['oid'], per['value'] ]) title = [ constants.EXPORT_CSV_TITLE_COLUMN_1, constants.EXPORT_CSV_TITLE_COLUMN_2, constants.EXPORT_CSV_TITLE_COLUMN_3, check_item_name ] script_dir = os.path.split(os.path.realpath(__file__))[0] csv_path = os.path.join( os.path.dirname( os.path.dirname( os.path.dirname(os.path.dirname(script_dir)))), constants.CSV_PATH) csv_data.insert(0, title) # create csv result = csv_export.csv_export(csv_path, csv_data) # download csv if result is False: data = { constants.STATUS: { constants.STATUS: constants.FALSE, constants.MESSAGE: constants.CSV_PATH_NOT_EXIST }, } return api_return(data=data) return result except Exception, e: if constants.DEBUG_FLAG: print traceback.format_exc(e) return exception_handler(e)
def get(self): """!@brief init policy tree edit page @note @return policy tree info,data rule rule,block rule @author Gin Chen @date 2017/12/18 """ try: self.coll_policy_id = views_helper.get_request_get(self.request, 'coll_policy_id') cp = CollPolicy.objects.get(coll_policy_id=self.coll_policy_id) cli_command_result = cp.cli_command_result policy_name = cp.name policy_tree = Policy_tree(self.coll_policy_id) # get policy tree policy_tree_dict = policy_tree.get_policy_tree() # get rules of the policy tree rule_tree_tuple = policy_tree.get_rules_tree() if rule_tree_tuple == 'Error': data = { 'data': '', 'new_token': self.new_token, constants.STATUS: { constants.STATUS: constants.FALSE, constants.MESSAGE: constants.LOAD_RULE_TYPE_ERROR } } else: block_rule_tree_dict = rule_tree_tuple[0] data_rule_tree_dict = rule_tree_tuple[1] data = { 'data': { "coll_policy_name": policy_name, "cli_command_result": cli_command_result, "policy_tree_json": policy_tree_dict, "block_rule_tree_json": block_rule_tree_dict, "data_rule_tree_json": data_rule_tree_dict, }, 'new_token': self.new_token, constants.STATUS: { constants.STATUS: constants.TRUE, constants.MESSAGE: constants.SUCCESS } } return api_return(data=data) except Exception, e: if constants.DEBUG_FLAG: print traceback.format_exc(e) return exception_handler(e)
def delete(self): """!@brief Delete policy group data @return data: the status of whether deleted successful """ try: # self.get_execute_ing() with transaction.atomic(): kwargs = {'policy_group_id': self.id} verify_result = self.verify_column(self.id) if not verify_result['status']: data = { 'new_token': self.new_token, constants.STATUS: { constants.STATUS: constants.FALSE, constants.MESSAGE: constants.COLL_POLICY_GROUP_EXIST_IN_SCHEDULE } } return api_return(data=data) data = self.del_policy_group_and_coll_policy_group(**kwargs) if data is True: data = { 'new_token': self.new_token, constants.STATUS: { constants.STATUS: constants.TRUE, constants.MESSAGE: constants.DELETE_SUCCESSFUL } } return api_return(data=data) except Exception, e: transaction.rollback() if constants.DEBUG_FLAG: print traceback.format_exc(e) return exception_handler(e)
def post(self): try: output = self.snmp_work() data = { 'data': { 'data': output, }, constants.STATUS: { constants.STATUS: constants.TRUE, constants.MESSAGE: constants.PUT_SUCCESSFUL } } return api_return(data=data) except Exception, e: if constants.DEBUG_FLAG: print traceback.format_exc(e) return exception_handler(e)
def put(self): # http://127.0.0.1:8000/v1/api_data_collection_devices/ # request param: is_all,coll_policy_id,device_id,policy_group_id,status # is_all =1: all stop,is_all = 0:stop some item is_all = int( views_helper.get_request_value(self.request, 'is_all', 'BODY')) coll_policy_id = views_helper.get_request_value( self.request, 'coll_policy_id', 'BODY') device_id = views_helper.get_request_value(self.request, 'device_id', 'BODY') status = int( views_helper.get_request_value(self.request, 'status', 'BODY')) policy_group_id = int( views_helper.get_request_value(self.request, 'policy_group_id', 'BODY')) try: if is_all == 1: # stop all items of the device Items.objects.filter(device=device_id).update(status=status) else: policys_groups_id_queryset = PolicysGroups.objects.filter( policy=coll_policy_id, policy_group=policy_group_id) with transaction.atomic(): for obj in policys_groups_id_queryset: Items.objects.filter( device=device_id, coll_policy=obj.policy, policys_groups=obj.policys_groups_id).update( status=status) data = { 'new_token': self.new_token, constants.STATUS: { constants.STATUS: constants.TRUE, constants.MESSAGE: constants.SUCCESS } } return api_return(data=data) except Exception as e: print e return exception_handler(e)
def get(self): """!@brief load the collection policy information when open the collection policy edit page from cp tree page @param @pre @post @note @return rule information,verify result @author Gin Chen @date 2018/1/18 """ try: coll_policy_id = views_helper.get_request_value(self.request, "coll_policy_id", "GET") obj = CollPolicy.objects.get(coll_policy_id=coll_policy_id) is_used = False if not Tool.get_policy_status(coll_policy_id): is_used = True is_not_in_group = True if len(PolicysGroups.objects.filter(policy=coll_policy_id)) > 0: is_not_in_group = False column_status={ 'name': True, 'desc': True, 'ostype': is_not_in_group, 'cli_command': is_used } serializer = CollPolicyEditSerializer(obj) data = { 'data': { 'policy_detail': serializer.data, 'verify_result': column_status }, 'new_token': self.new_token, constants.STATUS: { constants.STATUS: constants.TRUE, constants.MESSAGE: constants.SUCCESS } } return api_return(data=data) except Exception as e: if constants.DEBUG_FLAG: print traceback.format_exc(e) return exception_handler(e)
def get(self): device_name = views_helper.get_request_value(self.request, 'device', 'GET') try: emergency_stop_list = Tool.get_emergency_stop_list(device_name) arry = self.__set_emergency_stop_list_table_view(emergency_stop_list) data = { 'data': arry, 'new_token': self.new_token, constants.STATUS: { constants.STATUS: constants.TRUE, constants.MESSAGE: constants.SUCCESS } } return api_return(data=data) except Exception as e: print e return exception_handler(e)
def get(self): try: queryset = Ostype.objects.all() if self.id: query_conditions = {'ostypeid': self.id} queryset = Ostype.objects.filter(**query_conditions) serializer = OstypeSerializer(queryset, many=True) data = { 'data': serializer.data, 'new_token': self.new_token, constants.STATUS: { constants.STATUS: constants.TRUE, constants.MESSAGE: constants.SUCCESS } } return api_return(data=data) except Exception, e: print traceback.format_exc(e) return exception_handler(e)
def delete(self): # self.request.session[self.username] = None # if self.request.session[self.username] is None: # data = { # constants.STATUS: { # 'status': 'True', # 'message': 'Logout Success.', # 'username': self.username # } # } # return api_return(data=data) # else: # data = { # constants.STATUS: { # 'status': 'False', # 'message': 'Logout Success.', # 'username': self.username # } # } # return api_return(data=data) try: self.logger.info(constants.USER_LOGOUT_SUCCESSFUL) ###Logger### self.request.session.clear() data = { constants.USERNAME: self.username, constants.STATUS: { constants.STATUS: constants.TRUE, constants.MESSAGE: constants.USER_LOGOUT_SUCCESSFUL } } return api_return(data=data) # print self.request.session.keys() # print self.request.session.get('TOKEN_IN_SESSION') except Exception, e: if constants.DEBUG_FLAG: print traceback.format_exc(e) return exception_handler(e)