def api_action_group_edit(self, request):
validator = DictParameter(
attrs={
"ids":
ListOfParameter(element=ModelParameter(self.model),
convert=True)
})
rv = self.deserialize(request.raw_post_data)
try:
v = validator.clean(rv)
except InterfaceTypeError, why:
return self.render_json(
{
"status": False,
"message": "Bad request",
"traceback": str(why)
},
status=self.BAD_REQUEST)
def get_validator(self, field):
"""
Returns Parameter instance or None to clean up field
:param field:
:type field: Field
:return:
"""
from noc.lib.fields import AutoCompleteTagsField
if isinstance(field, BooleanField):
return BooleanParameter()
elif isinstance(field, IntegerField):
return IntParameter()
elif isinstance(field, FloatField):
return FloatParameter()
elif isinstance(field, AutoCompleteTagsField):
return TagsParameter(required=not field.null)
elif isinstance(field, related.ForeignKey):
self.fk_fields[field.name] = field.rel.to
return ModelParameter(field.rel.to, required=not field.null)
else:
return None
validate={"profile": DocumentParameter(InterfaceProfile)},
method=["POST"],
access="profile",
api=True)
def api_change_profile(self, request, iface_id, profile):
i = Interface.objects.filter(id=iface_id).first()
if not i:
return self.response_not_found()
if i.profile != profile:
i.profile = profile
i.profile_locked = True
i.save()
return True
@view(url="^l1/(?P<iface_id>[0-9a-f]{24})/change_state/$",
validate={"state": ModelParameter(ResourceState)},
method=["POST"],
access="profile",
api=True)
def api_change_state(self, request, iface_id, state):
i = Interface.objects.filter(id=iface_id).first()
if not i:
return self.response_not_found()
if i.state != state:
i.state = state
i.save()
return True
@view(url="^l1/(?P<iface_id>[0-9a-f]{24})/change_project/$",
validate={"project": ModelParameter(Project, required=False)},
method=["POST"],
def __init__(self, *args, **kwargs):
super(ExtDocApplication, self).__init__(*args, **kwargs)
self.pk = "id" # @todo: detect properly
self.has_uuid = False
# Prepare field converters
self.clean_fields = self.clean_fields.copy() # name -> Parameter
for name, f in self.model._fields.items():
if isinstance(f, BooleanField):
self.clean_fields[name] = BooleanParameter()
elif isinstance(f, GeoPointField):
self.clean_fields[name] = GeoPointParameter()
elif isinstance(f, ForeignKeyField):
self.clean_fields[f.name] = ModelParameter(f.document_type,
required=f.required)
elif isinstance(f, ListField):
if isinstance(f.field, EmbeddedDocumentField):
self.clean_fields[f.name] = ListOfParameter(
element=EmbeddedDocumentParameter(
f.field.document_type))
elif isinstance(f, ReferenceField):
self.clean_fields[f.name] = DocumentParameter(
f.document_type_obj)
if f.primary_key:
self.pk = name
if name == "uuid":
self.has_uuid = True
#
if not self.query_fields:
self.query_fields = [
"%s__%s" % (n, self.query_condition)
for n, f in self.model._fields.items()
if f.unique and isinstance(f, StringField)
]
self.unique_fields = [
n for n, f in self.model._fields.items() if f.unique
]
# Install JSON API call when necessary
self.json_collection = self.model._meta.get("json_collection")
if (self.has_uuid and hasattr(self.model, "to_json")
and not hasattr(self, "api_to_json")
and not hasattr(self, "api_json")):
self.add_view("api_json",
self._api_to_json,
url="^(?P<id>[0-9a-f]{24})/json/$",
method=["GET"],
access="read",
api=True)
if self.json_collection and self.config.getboolean(
"develop", "install_collection"):
self.add_view("api_install_json",
self._api_install_json,
url="^(?P<id>[0-9a-f]{24})/json/$",
method=["POST"],
access="create",
api=True)
if self.json_collection:
self.field_is_builtin = self._field_is_builtin
# Find field_* and populate custom fields
self.custom_fields = {}
for fn in [n for n in dir(self) if n.startswith("field_")]:
h = getattr(self, fn)
if callable(h):
self.custom_fields[fn[6:]] = h
class VCApplication(ExtModelApplication):
"""
VC application
"""
title = "VC"
menu = "Virtual Circuits"
model = VC
icon = "icon_link"
query_fields = ["name", "description"]
query_condition = "icontains"
int_query_fields = ["l1", "l2"]
implied_permissions = {
"read": ["vc:vcdomain:lookup", "main:style:lookup"]
}
mrt_config = {
"get_vlans": {
"map_script": "get_vlans",
"timeout": 120,
"access": "import"
},
"set_switchport": {
"map_script": "set_switchport",
"timeout": 120,
"access": "set_untagged"
}
}
def get_vc_domain_objects(self, vc_domain):
return vc_domain.managedobject_set.all()
def lookup_vcfilter(self, q, name, value):
"""
Resolve __vcflter lookups
:param q:
:param name:
:param value:
:return:
"""
value = ModelParameter(VCFilter).clean(value)
x = value.to_sql(name)
try:
q[None] += [x]
except KeyError:
q[None] = [x]
def field_interfaces_count(self, obj):
n = vcinterfacescount.get(obj)
return str(n) if n else "-"
def field_prefixes(self, obj):
p = vcprefixes.get(obj)
if p:
return ", ".join(p)
else:
return "-"
def field_row_class(self, o):
return o.style.css_class_name if o.style else ""
@view(url="^find_free/$", method=["GET"], access="read", api=True,
validate={
"vc_domain": ModelParameter(VCDomain),
"vc_filter": ModelParameter(VCFilter)
})
def api_find_free(self, request, vc_domain, vc_filter, **kwargs):
return vc_domain.get_free_label(vc_filter)
@view(url="^bulk/import/", method=["POST"], access="import", api=True,
validate={
"vc_domain": ModelParameter(VCDomain),
"items": ListOfParameter(element=DictParameter(attrs={
"l1": IntParameter(),
"l2": IntParameter(),
"name": StringParameter(),
"description": StringParameter(default="")
}))
})
def api_bulk_import(self, request, vc_domain, items):
n = 0
for i in items:
if not VC.objects.filter(vc_domain=vc_domain,
l1=i["l1"], l2=i["l2"]).exists():
# Add only not-existing
VC(vc_domain=vc_domain, l1=i["l1"], l2=i["l2"],
name=i["name"], description=i["description"]).save()
n += 1
return {
"status": True,
"imported": n
}
@view(url=r"^(?P<vc_id>\d+)/interfaces/$", method=["GET"],
access="read", api=True)
def api_interfaces(self, request, vc_id):
"""
Returns a dict of {untagged: ..., tagged: ...., l3: ...}
:param request:
:param vc_id:
:return:
"""
vc = self.get_object_or_404(VC, id=int(vc_id))
l1 = vc.l1
# Managed objects in VC domain
objects = set(vc.vc_domain.managedobject_set.values_list(
"id", flat=True))
# Find untagged interfaces
si_objects = defaultdict(list)
for si in SubInterface.objects.filter(
managed_object__in=objects,
untagged_vlan=l1,
enabled_afi="BRIDGE"):
si_objects[si.managed_object] += [{"name": si.name}]
untagged = [{
"managed_object_id": o.id,
"managed_object_name": o.name,
"interfaces": sorted(si_objects[o], key=lambda x: x["name"])
} for o in si_objects]
# Find tagged interfaces
si_objects = defaultdict(list)
for si in SubInterface.objects.filter(
managed_object__in=objects,
tagged_vlans=l1,
enabled_afi="BRIDGE"):
si_objects[si.managed_object] += [{"name": si.name}]
tagged = [{
"managed_object_id": o.id,
"managed_object_name": o.name,
"interfaces": sorted(si_objects[o], key=lambda x: x["name"])
} for o in si_objects]
# Find l3 interfaces
si_objects = defaultdict(list)
for si in SubInterface.objects.filter(
managed_object__in=objects,
vlan_ids=l1):
si_objects[si.managed_object] += [{
"name": si.name,
"ipv4_addresses": si.ipv4_addresses,
"ipv6_addresses": si.ipv6_addresses
}]
l3 = [{"managed_object_id": o.id,
"managed_object_name": o.name,
"interfaces": sorted(si_objects[o], key=lambda x: x["name"])
} for o in si_objects]
# Update caches
ic = sum(len(x["interfaces"]) for x in untagged)
ic += sum(len(x["interfaces"]) for x in tagged)
ic += sum(len(x["interfaces"]) for x in l3)
vcinterfacescount.set(ic, vc)
#
return {
"untagged": sorted(untagged,
key=lambda x: x["managed_object_name"]),
"tagged": sorted(tagged, key=lambda x: x["managed_object_name"]),
"l3": sorted(l3, key=lambda x: x["managed_object_name"])
}