move OLT service from XOS repo
diff --git a/xos/api/tenant/cord/subscriber.py b/xos/api/tenant/cord/subscriber.py
new file mode 100644
index 0000000..52f9b63
--- /dev/null
+++ b/xos/api/tenant/cord/subscriber.py
@@ -0,0 +1,384 @@
+from rest_framework.decorators import api_view
+from rest_framework.response import Response
+from rest_framework.reverse import reverse
+from rest_framework import serializers
+from rest_framework import generics
+from rest_framework import viewsets
+from rest_framework import status
+from rest_framework.decorators import detail_route, list_route
+from rest_framework.views import APIView
+from core.models import *
+from django.forms import widgets
+from django.conf.urls import patterns, url
+from services.volt.models import VOLTTenant, CordSubscriberRoot
+from api.xosapi_helpers import PlusModelSerializer, XOSViewSet, ReadOnlyField
+from django.shortcuts import get_object_or_404
+from xos.apibase import XOSListCreateAPIView, XOSRetrieveUpdateDestroyAPIView, XOSPermissionDenied
+from xos.exceptions import *
+import json
+import subprocess
+from django.views.decorators.csrf import ensure_csrf_cookie
+
+class CordSubscriberNew(CordSubscriberRoot):
+ class Meta:
+ proxy = True
+ app_label = "cord"
+
+ def __init__(self, *args, **kwargs):
+ super(CordSubscriberNew, self).__init__(*args, **kwargs)
+
+ def __unicode__(self):
+ return u"cordSubscriber-%s" % str(self.id)
+
+ @property
+ def features(self):
+ return {"cdn": self.cdn_enable,
+ "uplink_speed": self.uplink_speed,
+ "downlink_speed": self.downlink_speed,
+ "uverse": self.enable_uverse,
+ "status": self.status}
+
+ @features.setter
+ def features(self, value):
+ self.cdn_enable = value.get("cdn", self.get_default_attribute("cdn_enable"))
+ self.uplink_speed = value.get("uplink_speed", self.get_default_attribute("uplink_speed"))
+ self.downlink_speed = value.get("downlink_speed", self.get_default_attribute("downlink_speed"))
+ self.enable_uverse = value.get("uverse", self.get_default_attribute("enable_uverse"))
+ self.status = value.get("status", self.get_default_attribute("status"))
+
+
+ def update_features(self, value):
+ d=self.features
+ d.update(value)
+ self.features = d
+
+ @property
+ def identity(self):
+ return {"account_num": self.service_specific_id,
+ "name": self.name}
+
+ @identity.setter
+ def identity(self, value):
+ self.service_specific_id = value.get("account_num", self.service_specific_id)
+ self.name = value.get("name", self.name)
+
+ def update_identity(self, value):
+ d=self.identity
+ d.update(value)
+ self.identity = d
+
+ @property
+ def related(self):
+ related = {}
+ if self.volt:
+ related["volt_id"] = self.volt.id
+ related["s_tag"] = self.volt.s_tag
+ related["c_tag"] = self.volt.c_tag
+ if self.volt.vcpe:
+ related["vsg_id"] = self.volt.vcpe.id
+ if self.volt.vcpe.instance:
+ related["instance_id"] = self.volt.vcpe.instance.id
+ related["instance_name"] = self.volt.vcpe.instance.name
+ related["wan_container_ip"] = self.volt.vcpe.wan_container_ip
+ if self.volt.vcpe.instance.node:
+ related["compute_node_name"] = self.volt.vcpe.instance.node.name
+ return related
+
+ def save(self, *args, **kwargs):
+ super(CordSubscriberNew, self).save(*args, **kwargs)
+
+class CordDevice(object):
+ def __init__(self, d={}, subscriber=None):
+ self.d = d
+ self.subscriber = subscriber
+
+ @property
+ def mac(self):
+ return self.d.get("mac", None)
+
+ @mac.setter
+ def mac(self, value):
+ self.d["mac"] = value
+
+ @property
+ def identity(self):
+ return {"name": self.d.get("name", None)}
+
+ @identity.setter
+ def identity(self, value):
+ self.d["name"] = value.get("name", None)
+
+ @property
+ def features(self):
+ return {"uplink_speed": self.d.get("uplink_speed", None),
+ "downlink_speed": self.d.get("downlink_speed", None)}
+
+ @features.setter
+ def features(self, value):
+ self.d["uplink_speed"] = value.get("uplink_speed", None)
+ self.d["downlink_speed"] = value.get("downlink_speed", None)
+
+ def update_features(self, value):
+ d=self.features
+ d.update(value)
+ self.features = d
+
+ def update_identity(self, value):
+ d=self.identity
+ d.update(value)
+ self.identity = d
+
+ def save(self):
+ if self.subscriber:
+ dev=self.subscriber.find_device(self.mac)
+ if dev:
+ self.subscriber.update_device(**self.d)
+ else:
+ self.subscriber.create_device(**self.d)
+
+# Add some structure to the REST API by subdividing the object into
+# features, identity, and related.
+
+class FeatureSerializer(serializers.Serializer):
+ cdn = serializers.BooleanField(required=False)
+ uplink_speed = serializers.IntegerField(required=False)
+ downlink_speed = serializers.IntegerField(required=False)
+ uverse = serializers.BooleanField(required=False)
+ status = serializers.CharField(required=False)
+
+class IdentitySerializer(serializers.Serializer):
+ account_num = serializers.CharField(required=False)
+ name = serializers.CharField(required=False)
+
+class DeviceFeatureSerializer(serializers.Serializer):
+ uplink_speed = serializers.IntegerField(required=False)
+ downlink_speed = serializers.IntegerField(required=False)
+
+class DeviceIdentitySerializer(serializers.Serializer):
+ name = serializers.CharField(required=False)
+
+class DeviceSerializer(serializers.Serializer):
+ mac = serializers.CharField(required=True)
+ identity = DeviceIdentitySerializer(required=False)
+ features = DeviceFeatureSerializer(required=False)
+
+ class Meta:
+ fields = ('mac', 'identity', 'features')
+
+class CordSubscriberSerializer(PlusModelSerializer):
+ id = ReadOnlyField()
+ humanReadableName = serializers.SerializerMethodField("getHumanReadableName")
+ features = FeatureSerializer(required=False)
+ identity = IdentitySerializer(required=False)
+ related = serializers.DictField(required=False)
+
+ nested_fields = ["features", "identity"]
+
+ class Meta:
+ model = CordSubscriberNew
+ fields = ('humanReadableName',
+ 'id',
+ 'features',
+ 'identity',
+ 'related')
+
+ def getHumanReadableName(self, obj):
+ return obj.__unicode__()
+
+# @ensure_csrf_cookie
+class CordSubscriberViewSet(XOSViewSet):
+ base_name = "subscriber"
+ method_name = "subscriber"
+ method_kind = "viewset"
+ queryset = CordSubscriberNew.get_tenant_objects().select_related().all()
+ serializer_class = CordSubscriberSerializer
+
+ custom_serializers = {"set_features": FeatureSerializer,
+ "set_feature": FeatureSerializer,
+ "set_identities": IdentitySerializer,
+ "set_identity": IdentitySerializer,
+ "get_devices": DeviceSerializer,
+ "add_device": DeviceSerializer,
+ "get_device_feature": DeviceFeatureSerializer,
+ "set_device_feature": DeviceFeatureSerializer}
+
+ @classmethod
+ def get_urlpatterns(self, api_path="^"):
+ patterns = super(CordSubscriberViewSet, self).get_urlpatterns(api_path=api_path)
+ patterns.append( self.detail_url("features/$", {"get": "get_features", "put": "set_features"}, "features") )
+ patterns.append( self.detail_url("features/(?P<feature>[a-zA-Z0-9\-_]+)/$", {"get": "get_feature", "put": "set_feature"}, "get_feature") )
+ patterns.append( self.detail_url("identity/$", {"get": "get_identities", "put": "set_identities"}, "identities") )
+ patterns.append( self.detail_url("identity/(?P<identity>[a-zA-Z0-9\-_]+)/$", {"get": "get_identity", "put": "set_identity"}, "get_identity") )
+
+ patterns.append( self.detail_url("devices/$", {"get": "get_devices", "post": "add_device"}, "devicees") )
+ patterns.append( self.detail_url("devices/(?P<mac>[a-zA-Z0-9\-_:]+)/$", {"get": "get_device", "delete": "delete_device"}, "getset_device") )
+ patterns.append( self.detail_url("devices/(?P<mac>[a-zA-Z0-9\-_:]+)/features/(?P<feature>[a-zA-Z0-9\-_]+)/$", {"get": "get_device_feature", "put": "set_device_feature"}, "getset_device_feature") )
+ patterns.append( self.detail_url("devices/(?P<mac>[a-zA-Z0-9\-_:]+)/identity/(?P<identity>[a-zA-Z0-9\-_]+)/$", {"get": "get_device_identity", "put": "set_device_identity"}, "getset_device_identity") )
+
+ patterns.append( url(self.api_path + "account_num_lookup/(?P<account_num>[0-9\-]+)/$", self.as_view({"get": "account_num_detail"}), name="account_num_detail") )
+
+ patterns.append( url(self.api_path + "ssidmap/(?P<ssid>[0-9\-]+)/$", self.as_view({"get": "ssiddetail"}), name="ssiddetail") )
+ patterns.append( url(self.api_path + "ssidmap/$", self.as_view({"get": "ssidlist"}), name="ssidlist") )
+
+ return patterns
+
+ def list(self, request):
+ object_list = self.filter_queryset(self.get_queryset())
+
+ serializer = self.get_serializer(object_list, many=True)
+
+ return Response(serializer.data)
+
+ def get_features(self, request, pk=None):
+ subscriber = self.get_object()
+ return Response(FeatureSerializer(subscriber.features).data)
+
+ def set_features(self, request, pk=None):
+ subscriber = self.get_object()
+ ser = FeatureSerializer(subscriber.features, data=request.data)
+ ser.is_valid(raise_exception = True)
+ subscriber.update_features(ser.validated_data)
+ subscriber.save()
+ return Response(FeatureSerializer(subscriber.features).data)
+
+ def get_feature(self, request, pk=None, feature=None):
+ subscriber = self.get_object()
+ return Response({feature: FeatureSerializer(subscriber.features).data[feature]})
+
+ def set_feature(self, request, pk=None, feature=None):
+ subscriber = self.get_object()
+ if [feature] != request.data.keys():
+ raise serializers.ValidationError("feature %s does not match keys in request body (%s)" % (feature, ",".join(request.data.keys())))
+ ser = FeatureSerializer(subscriber.features, data=request.data)
+ ser.is_valid(raise_exception = True)
+ subscriber.update_features(ser.validated_data)
+ subscriber.save()
+ return Response({feature: FeatureSerializer(subscriber.features).data[feature]})
+
+ def get_identities(self, request, pk=None):
+ subscriber = self.get_object()
+ return Response(IdentitySerializer(subscriber.identity).data)
+
+ def set_identities(self, request, pk=None):
+ subscriber = self.get_object()
+ ser = IdentitySerializer(subscriber.identity, data=request.data)
+ ser.is_valid(raise_exception = True)
+ subscriber.update_identity(ser.validated_data)
+ subscriber.save()
+ return Response(IdentitySerializer(subscriber.identity).data)
+
+ def get_identity(self, request, pk=None, identity=None):
+ subscriber = self.get_object()
+ return Response({identity: IdentitySerializer(subscriber.identity).data[identity]})
+
+ def set_identity(self, request, pk=None, identity=None):
+ subscriber = self.get_object()
+ if [identity] != request.data.keys():
+ raise serializers.ValidationError("identity %s does not match keys in request body (%s)" % (identity, ",".join(request.data.keys())))
+ ser = IdentitySerializer(subscriber.identity, data=request.data)
+ ser.is_valid(raise_exception = True)
+ subscriber.update_identity(ser.validated_data)
+ subscriber.save()
+ return Response({identity: IdentitySerializer(subscriber.identity).data[identity]})
+
+ def get_devices(self, request, pk=None):
+ subscriber = self.get_object()
+ result = []
+ for device in subscriber.devices:
+ device = CordDevice(device, subscriber)
+ result.append(DeviceSerializer(device).data)
+ return Response(result)
+
+ def add_device(self, request, pk=None):
+ subscriber = self.get_object()
+ ser = DeviceSerializer(subscriber.devices, data=request.data)
+ ser.is_valid(raise_exception = True)
+ newdevice = CordDevice(subscriber.create_device(**ser.validated_data), subscriber)
+ subscriber.save()
+ return Response(DeviceSerializer(newdevice).data)
+
+ def get_device(self, request, pk=None, mac=None):
+ subscriber = self.get_object()
+ device = subscriber.find_device(mac)
+ if not device:
+ return Response("Failed to find device %s" % mac, status=status.HTTP_404_NOT_FOUND)
+ return Response(DeviceSerializer(CordDevice(device, subscriber)).data)
+
+ def delete_device(self, request, pk=None, mac=None):
+ subscriber = self.get_object()
+ device = subscriber.find_device(mac)
+ if not device:
+ return Response("Failed to find device %s" % mac, status=status.HTTP_404_NOT_FOUND)
+ subscriber.delete_device(mac)
+ subscriber.save()
+ return Response("Okay")
+
+ def get_device_feature(self, request, pk=None, mac=None, feature=None):
+ subscriber = self.get_object()
+ device = subscriber.find_device(mac)
+ if not device:
+ return Response("Failed to find device %s" % mac, status=status.HTTP_404_NOT_FOUND)
+ return Response({feature: DeviceFeatureSerializer(CordDevice(device, subscriber).features).data[feature]})
+
+ def set_device_feature(self, request, pk=None, mac=None, feature=None):
+ subscriber = self.get_object()
+ device = subscriber.find_device(mac)
+ if not device:
+ return Response("Failed to find device %s" % mac, status=status.HTTP_404_NOT_FOUND)
+ if [feature] != request.data.keys():
+ raise serializers.ValidationError("feature %s does not match keys in request body (%s)" % (feature, ",".join(request.data.keys())))
+ device = CordDevice(device, subscriber)
+ ser = DeviceFeatureSerializer(device.features, data=request.data)
+ ser.is_valid(raise_exception = True)
+ device.update_features(ser.validated_data)
+ device.save()
+ subscriber.save()
+ return Response({feature: DeviceFeatureSerializer(device.features).data[feature]})
+
+ def get_device_identity(self, request, pk=None, mac=None, identity=None):
+ subscriber = self.get_object()
+ device = subscriber.find_device(mac)
+ if not device:
+ return Response("Failed to find device %s" % mac, status=status.HTTP_404_NOT_FOUND)
+ return Response({identity: DeviceIdentitySerializer(CordDevice(device, subscriber).identity).data[identity]})
+
+ def set_device_identity(self, request, pk=None, mac=None, identity=None):
+ subscriber = self.get_object()
+ device = subscriber.find_device(mac)
+ if not device:
+ return Response("Failed to find device %s" % mac, status=status.HTTP_404_NOT_FOUND)
+ if [identity] != request.data.keys():
+ raise serializers.ValidationError("identity %s does not match keys in request body (%s)" % (feature, ",".join(request.data.keys())))
+ device = CordDevice(device, subscriber)
+ ser = DeviceIdentitySerializer(device.identity, data=request.data)
+ ser.is_valid(raise_exception = True)
+ device.update_identity(ser.validated_data)
+ device.save()
+ subscriber.save()
+ return Response({identity: DeviceIdentitySerializer(device.identity).data[identity]})
+
+ def account_num_detail(self, pk=None, account_num=None):
+ object_list = CordSubscriberNew.get_tenant_objects().all()
+ object_list = [x for x in object_list if x.service_specific_id == account_num]
+ if not object_list:
+ return Response("Failed to find account_num %s" % account_num, status=status.HTTP_404_NOT_FOUND)
+
+ return Response( object_list[0].id )
+
+ def ssidlist(self, request):
+ object_list = CordSubscriberNew.get_tenant_objects().all()
+
+ ssidmap = [ {"service_specific_id": x.service_specific_id, "subscriber_id": x.id} for x in object_list ]
+
+ return Response({"ssidmap": ssidmap})
+
+ def ssiddetail(self, pk=None, ssid=None):
+ object_list = CordSubscriberNew.get_tenant_objects().all()
+
+ ssidmap = [ {"service_specific_id": x.service_specific_id, "subscriber_id": x.id} for x in object_list if str(x.service_specific_id)==str(ssid) ]
+
+ if len(ssidmap)==0:
+ raise XOSNotFound("didn't find ssid %s" % str(ssid))
+
+ return Response( ssidmap[0] )
+