def delete_field(self, request, **kwargs): cur_obj = StaticAssetFieldValue.objects.get(Q(pk=kwargs["pk"])) can_delete_answer = can_delete_obj(cur_obj) if can_delete_answer: cur_obj.delete() return Response(status=status.HTTP_204_NO_CONTENT) else: raise ValueError(can_delete_answer.msg)
def delete(self, request, *args, **kwargs): # just be careful cur_obj = self.model.objects.get(Q(pk=kwargs["pk"])) can_delete_answer = can_delete_obj(cur_obj, logger) if can_delete_answer: cur_obj.delete() return Response(status=status.HTTP_204_NO_CONTENT) else: raise ValueError(can_delete_answer.msg)
def delete_entry(self, request, **kwargs): dvs_entry = dvs_allowed_name.objects.get(Q(pk=kwargs["pk"])) can_delete_answer = can_delete_obj(dvs_entry, logger) if can_delete_answer: dvs_entry.delete() else: raise ValidationError("cannot delete: {}".format( logging_tools.get_plural( "reference", len(can_delete_answer.related_objects)))) return Response(status=status.HTTP_204_NO_CONTENT)
def delete_field(self, request, **kwargs): _ = request from initat.cluster.backbone.models import StaticAssetFieldValue from initat.cluster.backbone.models.functions import can_delete_obj cur_obj = StaticAssetFieldValue.objects.get(pk=kwargs["pk"]) can_delete_answer = can_delete_obj(cur_obj) if can_delete_answer: from rest_framework import status from rest_framework.response import Response cur_obj.delete() return Response(status=status.HTTP_204_NO_CONTENT) else: raise ValueError(can_delete_answer.msg)
def delete_field(self, request, **kwargs): cur_obj = StaticAssetTemplateField.objects.get(Q(pk=kwargs["pk"])) can_delete_answer = can_delete_obj(cur_obj) if can_delete_answer: cur_obj.delete() return Response(status=status.HTTP_204_NO_CONTENT) # it makes no sense to return something meaningful because the DestroyModelMixin returns # a 204 status on successful deletion # print "****", "del" # print unicode(cur_obj), resp.data # if not resp.data: # resp.data = {} # resp.data["_messages"] = [u"deleted '%s'" % (unicode(cur_obj))] # return resp else: raise ValueError(can_delete_answer.msg)
def delete_field(self, request, **kwargs): _ = request from initat.cluster.backbone.models import StaticAssetTemplateField from initat.cluster.backbone.models.functions import can_delete_obj cur_obj = StaticAssetTemplateField.objects.get(pk=kwargs["pk"]) can_delete_answer = can_delete_obj(cur_obj) if can_delete_answer: from rest_framework import status from rest_framework.response import Response cur_obj.delete() return Response(status=status.HTTP_204_NO_CONTENT) # it makes no sense to return something meaningful because the DestroyModelMixin returns # a 204 status on successful deletion # print "****", "del" # print unicode(cur_obj), resp.data # if not resp.data: # resp.data = {} # resp.data["_messages"] = [u"deleted '%s'" % (unicode(cur_obj))] # return resp else: raise ValueError(can_delete_answer.msg)
def post(self, request): # returns: # - related_objs: {obj_ok : [related_obj_info] } for objects which have related objects # - deletable_objects: [obj_pk] _post = request.POST obj_pks = json.loads(_post.get("obj_pks")) model = getattr(initat.cluster.backbone.models, _post.get("model")) objs_to_delete = model.objects.filter(pk__in=obj_pks) if len(objs_to_delete) < len(obj_pks): request.xml_response.error("Could not find all objects to delete.") logger.warn("To delete: {}; found only: {}".format( obj_pks, [o.pk for o in objs_to_delete])) related_objects_info = {} deletable_objects = [] # import time for obj_to_delete in objs_to_delete: # a = time.time() can_delete_answer = can_delete_obj(obj_to_delete, logger) # print 'can del took ', time.time() - a, bool(can_delete_answer), len(can_delete_answer.related_objects) if can_delete_answer: deletable_objects.append(obj_to_delete.pk) else: info = [] # there are django related objects, which describe the fields that are related # and there are referenced objects, which are the actual db objects having these fields for related_object in can_delete_answer.related_objects: referenced_objects_list = [] refs_of_refs = set() for referenced_object in related_object.ref_list: referenced_objects_list.append({ k: v for (k, v) in referenced_object.__dict__.iteritems() if k != '_state' }) refs_of_refs.update( get_related_models(referenced_object, detail=True)) info.append({ 'model': related_object.model._meta.object_name, 'model_verbose_name': related_object.model._meta.verbose_name.capitalize(), 'field_name': related_object.field.name, 'field_verbose_name': related_object.field.verbose_name.capitalize(), 'null': related_object.field.null, 'objects': { 'num_refs_of_refs': len(refs_of_refs), 'list': referenced_objects_list, }, }) related_objects_info[obj_to_delete.pk] = info # print 'build 2nd level rel list', time.time() - a # print 'obj', obj_pk, ' took ', time.time() - a # json can't deal with datetime, django formatter doesn't have nice dates def formatter(x): if isinstance(x, datetime.datetime): return x.strftime("%Y-%m-%d %H:%M") elif isinstance(x, datetime.date): # NOTE: datetime is instance of date, so check datetime first return x.isoformat() else: return x request.xml_response['related_objects'] = json.dumps( related_objects_info, default=formatter) request.xml_response['deletable_objects'] = json.dumps( deletable_objects)
def post(self, request): from initat.cluster.backbone.models.functions import can_delete_obj, get_related_models # returns: # - related_objs: {obj_ok : [related_obj_info] } for objects which have related objects # - deletable_objects: [obj_pk] _post = request.POST _start_time = time.time() obj_pks = json.loads(_post.get("obj_pks")) model = apps.get_model("backbone", _post.get("model_name")) objs_to_delete = model.objects.filter(pk__in=obj_pks) if len(objs_to_delete) < len(obj_pks): request.xml_response.error("Could not find all objects to delete.") logger.warning( "To delete: {}; found only: {}".format( obj_pks, [o.pk for o in objs_to_delete] ) ) related_objects_info = {} deletable_objects = [] # import time for obj_to_delete in objs_to_delete: # a = time.time() can_delete_answer = can_delete_obj(obj_to_delete, logger) # print 'can del took ', time.time() - a, bool(can_delete_answer), len(can_delete_answer.related_objects) if can_delete_answer: # or True: deletable_objects.append(obj_to_delete.pk) else: info = [] # there are django related objects, which describe the fields that are related # and there are referenced objects, which are the actual db objects having these fields for related_object in can_delete_answer.related_objects: referenced_objects_list = [] refs_of_refs = set() for referenced_object in related_object.ref_list: # add simple representations of referenced objects # ignore all fields starting with underscore '_' (for example '_state') referenced_objects_list.append( { k: v for (k, v) in referenced_object.__dict__.items() if not k.startswith("_") } ) refs_of_refs.update(get_related_models(referenced_object, simple_tuples=True)) # print("*", refs_of_refs) info.append( { 'model': related_object.model._meta.object_name, 'model_verbose_name': related_object.model._meta.verbose_name.capitalize(), 'related_model': related_object.related_model._meta.object_name, 'related_model_verbose_name': related_object.related_model._meta.verbose_name.capitalize(), 'field_name': related_object.field.name, 'field_verbose_name': related_object.field.verbose_name.capitalize(), 'null': related_object.field.null, 'objects': { 'num_refs_of_refs': len(refs_of_refs), 'list': referenced_objects_list, }, } ) related_objects_info[obj_to_delete.pk] = { "list": info, } # print 'build 2nd level rel list', time.time() - a # print 'obj', obj_pk, ' took ', time.time() - a _end_time = time.time() # json can't deal with datetime, django formatter doesn't have nice dates def formatter(val): if isinstance(val, datetime.datetime): return val.strftime("%Y-%m-%d %H:%M") elif isinstance(val, datetime.date): # NOTE: datetime is instance of date, so check datetime first return val.isoformat() else: return val request.xml_response['related_objects'] = json.dumps( related_objects_info, default=formatter ) request.xml_response['deletable_objects'] = json.dumps( deletable_objects ) request.xml_response["delete_info"] = json.dumps( { "runtime": _end_time - _start_time, } )
def post(self, request): _post = request.POST c_dict = json.loads(_post.get("change_dict", "")) pk_list = json.loads(_post.get("device_list")) if c_dict.get("delete", False): num_deleted = 0 error_msgs = [] for pk in pk_list: obj = device.objects.get(Q(pk=pk)) can_delete_answer = can_delete_obj(obj, logger) if can_delete_answer: obj.delete() num_deleted += 1 else: error_msgs.append((obj.name, can_delete_answer.msg)) if num_deleted > 0: request.xml_response.info("delete {}".format( logging_tools.get_plural("device", num_deleted))) for pk, msg in error_msgs: request.xml_response.error("Failed to delete {}: {}".format( pk, msg)) else: def_dict = { "bootserver": None, "monitor_server": None, "enabled": False, "store_rrd_data": False, "enable_perfdata": False, } # build change_dict c_dict = { key[7:]: c_dict.get(key[7:], def_dict.get(key[7:], None)) for key in c_dict.iterkeys() if key.startswith("change_") and c_dict[key] } # resolve foreign keys res_c_dict = { key: { "device_group": device_group, "device_class": DeviceClass, "domain_tree_node": domain_tree_node, "bootserver": device, "monitor_server": device, }[key].objects.get(Q( pk=value)) if type(value) == int else value for key, value in c_dict.iteritems() } logger.info("change_dict has {}".format( logging_tools.get_plural("key", len(res_c_dict)))) for key in sorted(res_c_dict): if key == "root_passwd": logger.info(" {}: {}".format(key, "****")) else: logger.info(" {}: {}".format(key, unicode(res_c_dict.get(key)))) dev_changes = 0 changes_json = [] for cur_dev in device.objects.filter(Q(pk__in=pk_list)): changed = False for c_key, c_value in res_c_dict.iteritems(): if getattr(cur_dev, c_key) != c_value: if c_key == "root_passwd": c_value = cur_dev.crypt(c_value) if c_value: setattr(cur_dev, c_key, c_value) changed = True else: setattr(cur_dev, c_key, c_value) changes_json.append({ "device": cur_dev.pk, "attribute": c_key, "value": c_dict[c_key], }) changed = True if changed: cur_dev.save() dev_changes += 1 request.xml_response["changed"] = dev_changes request.xml_response["json_changes"] = json.dumps(changes_json) request.xml_response.info("changed settings of {}".format( logging_tools.get_plural("device", dev_changes)))
def handle_deletion(obj_pk, model, delete_strategies, cur_inst): model = getattr(initat.cluster.backbone.models, model) try: obj_to_delete = model.objects.get(pk=obj_pk) except model.DoesNotExist: cur_inst.log( "Object with pk {} from model {} does not exist any more". format(obj_pk, model)) else: cur_inst.log("Deleting {} ({}; pk:{})".format( obj_to_delete, model, obj_pk)) start_time = time.time() if delete_strategies: # have to do elaborate deletion of references delete_strategy_list = json.loads(delete_strategies) delete_strategies = {} for entry in delete_strategy_list: delete_strategies[( entry['model'], entry['field_name'])] = entry['selected_action'] # get references again and apply the selected strategy for each according to delete_strategies can_delete_answer = can_delete_obj(obj_to_delete) for rel_obj in can_delete_answer.related_objects: dict_key = (rel_obj.model._meta.object_name, rel_obj.field.name) strat = delete_strategies.get(dict_key, None) if strat == "set null": cur_inst.log("set null on {} ".format(rel_obj)) for db_obj in rel_obj.ref_list: setattr(db_obj, rel_obj.field.name, None) db_obj.save() elif strat == "delete cascade": for db_obj in rel_obj.ref_list: cur_inst.log("delete cascade for {} ({})".format( db_obj, rel_obj)) db_obj.delete() elif strat == "delete object": cur_inst.log("delete object on {}".format(rel_obj)) for db_obj in rel_obj.ref_list: db_obj.delete() else: raise ValueError( "Invalid strategy for {}: {}; available strategies: {}" .format(dict_key, strat, delete_strategies)) cur_inst.log("all refs have been deleted") can_delete_answer_after = can_delete_obj(obj_to_delete) if can_delete_answer_after: # all references cleared obj_to_delete.delete() else: cur_inst.log(can_delete_answer_after.msg) else: # can delete obj right away obj_to_delete.delete() cur_inst.log("Deletion finished in {} seconds".format(time.time() - start_time))
def handle_deletion(obj_pk, model, delete_strategies, cur_inst): # delete strategies is a json-encoded list model = apps.get_model("backbone", model) try: obj_to_delete = model.objects.get(pk=obj_pk) except model.DoesNotExist: cur_inst.log( "Object with pk {} from model {} does not exist any more". format(obj_pk, model)) else: _bgj = create_bg_job( global_config["SERVER_IDX"], None, "delete object '{}'".format(str(obj_to_delete)), "delete", None, state=BackgroundJobState.pending, timeout=60 * 60, ) # just for testing # time.sleep(30) cur_inst.log("Deleting {} ({}; pk:{})".format( obj_to_delete, model, obj_pk)) start_time = time.time() if delete_strategies: # have to do elaborate deletion of references delete_strategy_list = json.loads(delete_strategies) delete_strategies = {} for entry in delete_strategy_list: delete_strategies[( entry['model'], entry['field_name'])] = entry['selected_action'] # get references again and apply the selected strategy for each according to delete_strategies can_delete_answer = can_delete_obj(obj_to_delete) for rel_obj in can_delete_answer.related_objects: dict_key = (rel_obj.model._meta.object_name, rel_obj.field.name) strat = delete_strategies.get(dict_key, None) if strat == "set null": cur_inst.log("set null on {} ".format(rel_obj)) for db_obj in rel_obj.ref_list: setattr(db_obj, rel_obj.field.name, None) db_obj.save() elif strat == "delete cascade": for db_obj in rel_obj.ref_list: cur_inst.log("delete cascade for {} ({})".format( db_obj, rel_obj)) db_obj.delete() elif strat == "delete object": cur_inst.log("delete object on {}".format(rel_obj)) for db_obj in rel_obj.ref_list: db_obj.delete() else: raise ValueError( "Invalid strategy for {}: {}; available strategies: {}" .format(dict_key, strat, delete_strategies)) cur_inst.log("all refs have been deleted") can_delete_answer_after = can_delete_obj(obj_to_delete) if can_delete_answer_after: # all references cleared obj_to_delete.delete() else: cur_inst.log(can_delete_answer_after.msg) else: # can delete obj right away obj_to_delete.delete() _bgj.set_state(BackgroundJobState.done) cur_inst.log("Deletion finished in {} seconds".format(time.time() - start_time))