def dispatch(self, request, *args, **kwargs):
if not AuthServiceApi.verify_token(request):
return self.handle_no_permission()
self.user = AuthServiceApi.get_me(request.COOKIES.get('user_token'))
if not self.test_func():
return self.handle_no_permission()
return super().dispatch(request, *args, **kwargs)
def get(self, request, device, pk, format=None):
me = AuthServiceApi.get_me(self.request.headers.get('Authorization'))
if not me['is_staff']:
read_permission = AuthServiceApi.has_read_permission(
HUB_ID, device, me['pk'])
if not read_permission['has_read_perm']:
return Response(status=status.HTTP_403_FORBIDDEN)
try:
device_obj = Device.objects.get(pk=device)
unit = DeviceUnit.objects.get(device=device_obj, pk=pk)
except Device.DoesNotExist:
raise Http404
except DeviceUnit.DoesNotExist:
raise Http404
if unit.type_of_unit == UnitType.HUMIDITY_UNIT:
objs = HumidityUnitValue.objects.filter(
device_unit=unit).order_by('-timestamp')[:50]
serializer = HumidityUnitValueSerializer(objs, many=True)
elif unit.type_of_unit == UnitType.TEMPERATURE_UNIT:
objs = TemperatureUnitValue.objects.filter(
device_unit=unit).order_by('-timestamp')[:50]
serializer = TemperatureUnitValueSerializer(objs, many=True)
elif unit.type_of_unit == UnitType.SWITCH_UNIT:
objs = SwitchUnitValue.objects.filter(
device_unit=unit).order_by('-timestamp')[:50]
serializer = SwitchUnitValueSerializer(objs, many=True)
else:
raise Exception("Bad Unit Type")
return Response(serializer.data, status=status.HTTP_200_OK)
def get(self, *args, **kwargs):
hub_id = kwargs.get('hub')
device_id = kwargs.get('device')
permission_id = kwargs.get('pk')
AuthServiceApi.delete_device_group_permission(hub_id, device_id,
permission_id)
return redirect(self.get_success_url())
def form_valid(self, form):
hub = AuthServiceApi.get_hub(self.kwargs['hub'])
device_id = int(self.kwargs.get('pk'))
form.cleaned_data['group'] = int(form.cleaned_data['group'])
form.cleaned_data['device'] = device_id
AuthServiceApi.add_device_group_permission(hub['pk'], device_id,
form.cleaned_data)
return HttpResponseRedirect(self.get_success_url())
def get(self, request, *args, **kwargs):
self.groups = AuthServiceApi.get_groups()
hub_id = kwargs.get('hub')
device_id = kwargs.get('device')
permission_id = kwargs.get('pk')
self.object = AuthServiceApi.get_device_group_permission(
hub_id, device_id, permission_id)
return super(UpdateDeviceGroupPermissionView,
self).get(request, *args, **kwargs)
def post(self, request, *args, **kwargs):
self.users = AuthServiceApi.get_users()
hub_id = kwargs.get('hub')
device_id = kwargs.get('device')
permission_id = kwargs.get('pk')
self.object = AuthServiceApi.get_device_user_permission(
hub_id, device_id, permission_id)
return super(UpdateDeviceUserPermissionView,
self).post(request, *args, **kwargs)
def get(self, request, *args, **kwargs):
hub = AuthServiceApi.get_hub(self.kwargs.get('hub'))
self.device = InternalApi.get_device(
self.request.COOKIES.get('user_token'), hub, self.kwargs.get('pk'))
self.units = InternalApi.get_units(
self.request.COOKIES.get('user_token'), hub, self.kwargs.get('pk'))
self.user = AuthServiceApi.get_me(
self.request.COOKIES.get('user_token'))
return super(DeviceUnitsView, self).get(request, *args, **kwargs)
def post(self, request, format=None):
me = AuthServiceApi.get_me(self.request.headers.get('Authorization'))
if not me['is_staff']:
return Response(status=status.HTTP_403_FORBIDDEN)
serializer = DeviceSerializer(data=request.data)
if serializer.is_valid():
device = serializer.save()
AuthServiceApi.register_device(HUB_ID, device)
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get_all(self, request, format=None):
me = AuthServiceApi.get_me(request.headers.get('Authorization'))
if me['is_staff']:
devices = Device.objects.all()
else:
devices_pks = AuthServiceApi.get_registered_devices_with_read_perm(
HUB_ID, me['pk'])['read_permission_devices']
devices = Device.objects.filter(pk__in=devices_pks)
serializer = DeviceSerializer(devices, many=True)
return Response(serializer.data)
def delete(self, request, pk, format=None):
me = AuthServiceApi.get_me(self.request.headers.get('Authorization'))
if not me['is_staff']:
return Response(status=status.HTTP_403_FORBIDDEN)
try:
device = Device.objects.get(pk=pk)
except Device.DoesNotExist:
raise Http404
AuthServiceApi.unregister_device(HUB_ID, device)
device.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
def get(self, request, *args, **kwargs):
token = self.request.COOKIES.get('user_token')
hub = AuthServiceApi.get_hub(kwargs['hub'])
device = InternalApi.get_device(token, hub, kwargs['pk'])
self.device = device
self.users = AuthServiceApi.get_users()
self.groups = AuthServiceApi.get_groups()
self.user_permissions = AuthServiceApi.get_device_user_permissions(
hub['pk'], device['pk'])
self.group_permissions = AuthServiceApi.get_device_group_permissions(
hub['pk'], device['pk'])
return super(DevicePermissionsView, self).get(request, *args, **kwargs)
def get_one(self, request, pk, format=None):
me = AuthServiceApi.get_me(self.request.headers.get('Authorization'))
if not me['is_staff']:
read_permission = AuthServiceApi.has_read_permission(
HUB_ID, pk, me['pk'])
if not read_permission['has_read_perm']:
raise Http404
try:
devices = Device.objects.get(pk=pk)
except Device.DoesNotExist:
raise Http404
serializer = DeviceSerializer(devices)
return Response(serializer.data)
def get(self, request, *args, **kwargs):
hub = AuthServiceApi.get_hub(self.kwargs.get('hub'))
self.hub = hub
token = self.request.COOKIES.get('user_token')
self.device = InternalApi.get_device(token, self.hub,
self.kwargs.get('device'))
self.unit = InternalApi.get_unit(token, hub, self.kwargs.get('device'),
self.kwargs.get('pk'))
self.data = InternalApi.get_data_from_unit(token, hub,
self.kwargs.get('device'),
self.kwargs.get('pk'))
self.has_write_perms = AuthServiceApi.has_write_permission(
hub['pk'], self.kwargs.get('device'), self.user['pk'])
return super(UnitDataView, self).get(request, *args, **kwargs)
def post(self, request, *args, **kwargs):
self.hub = AuthServiceApi.get_hub(self.kwargs.get('hub'))
self.token = self.request.COOKIES.get('user_token')
self.device = InternalApi.get_device(self.token, self.hub,
self.kwargs.get('device'))
self.unit = InternalApi.get_unit(self.token, self.hub,
self.kwargs.get('device'),
self.kwargs.get('pk'))
self.data = InternalApi.get_data_from_unit(self.token, self.hub,
self.kwargs.get('device'),
self.kwargs.get('pk'))
self.has_write_perms = AuthServiceApi.has_write_permission(
self.hub['pk'], self.kwargs.get('device'), self.user['pk'])
if not self.has_write_perms['has_write_perm']:
return HttpResponseRedirect(self.get_success_url())
return super(UnitDataView, self).post(request, *args, **kwargs)
def post(self, request, *args, **kwargs):
hub = AuthServiceApi.get_hub(self.kwargs.get('hub'))
device_id = self.kwargs.get('device')
token = self.request.COOKIES.get('user_token')
self.object = InternalApi.get_unit(token, hub, device_id,
self.kwargs.get('pk'))
return super(UpdateDeviceUnitView, self).post(request, *args, **kwargs)
def form_valid(self, form):
hub = AuthServiceApi.get_hub(self.kwargs.get('hub'))
device_id = self.kwargs.get('device')
pk = self.kwargs.get('pk')
token = self.request.COOKIES.get('user_token')
InternalApi.update_unit(token, hub, device_id, pk, form.cleaned_data)
return super(UpdateDeviceUnitView, self).form_valid(form)
def delete(self, request, pk, format=None):
me = AuthServiceApi.get_me(self.request.headers.get('Authorization'))
if not me['is_staff']:
return Response(status=status.HTTP_403_FORBIDDEN)
connected_unit = ConnectedUnit.objects.get(pk=pk)
connected_unit.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
def get(self, request, from_unit, pk=None, format=None):
me = AuthServiceApi.get_me(self.request.headers.get('Authorization'))
if not me['is_staff']:
return Response(status=status.HTTP_403_FORBIDDEN)
if pk is None:
return self.get_many(request, from_unit, format)
else:
return self.get_single(request, from_unit, pk, format)
def clean(self):
super(HubAuthorizationForm, self).clean()
username = self.cleaned_data.get("username")
password = self.cleaned_data.get("password")
response = AuthServiceApi.sign_in(username, password)
self.user_token = response.json().get("access")
self.refresh_token = response.json().get("refresh")
def get(self, request, *args, **kwargs):
token = self.request.COOKIES.get('user_token')
self.hub = AuthServiceApi.get_hub(self.kwargs.get('dest_hub'))
self.device = InternalApi.get_device(token, self.hub,
self.kwargs.get('dest_device'))
self.units = InternalApi.get_units(token, self.hub, self.device['pk'])
return super(ConnectUnitSelectUnitView,
self).get(request, *args, **kwargs)
def form_valid(self, form):
if self.unit['type_of_unit'] == UnitType.TEMPERATURE_UNIT:
obj = TemperatureUnitValue(timestamp=timezone.now(),
incoming=True,
**form.cleaned_data)
serializer_obj = json.dumps(
serializers.TemperatureUnitValueSerializer(obj).data)
prepared_objs = [
json.dumps({
'data': serializer_obj,
'type': 'TemperatureUnitValue'
})
]
elif self.unit['type_of_unit'] == UnitType.SWITCH_UNIT:
obj = SwitchUnitValue(timestamp=timezone.now(),
incoming=True,
**form.cleaned_data)
serializer_obj = json.dumps(
serializers.SwitchUnitValueSerializer(obj).data)
prepared_objs = [
json.dumps({
'data': serializer_obj,
'type': 'SwitchUnitValue'
})
]
elif self.unit['type_of_unit'] == UnitType.HUMIDITY_UNIT:
obj = HumidityUnitValue(timestamp=timezone.now(),
incoming=True,
**form.cleaned_data)
serializer_obj = json.dumps(
serializers.HumidityUnitValueSerializer(obj).data)
prepared_objs = [
json.dumps({
'data': serializer_obj,
'type': 'HumidityUnitValue'
})
]
else:
raise Exception("Invalid Type Of Device")
payload = {
'device': int(self.kwargs.get('device')),
'unit': self.unit['pk'],
'data': prepared_objs
}
InternalApi.send_data_to_unit(self.hub, payload)
connected_units = InternalApi.get_connected_units_with_unit(
self.token, self.hub, self.unit['pk'])
for connected_unit in connected_units:
payload = {
'device': connected_unit['dest_device'],
'unit': connected_unit['dest_unit'],
'data': prepared_objs
}
hub = AuthServiceApi.get_hub(connected_unit['dest_hub'])
InternalApi.send_data_to_unit(hub, payload)
return HttpResponseRedirect(self.get_success_url())
def mqtt_callback(client, userdata, message):
global models
global serializers
print(message.payload)
try:
obj = json.loads(message.payload if not isinstance(
message.payload, bytes) else message.payload.decode("UTF-8"))
except Exception as e:
print(e)
if 'device' not in obj or 'unit' not in obj or 'data' not in obj:
return
device = models.Device.objects.get(pk=obj['device'])
unit = models.DeviceUnit.objects.get(pk=obj['unit'], device=device)
if device.type_of_device == DeviceType.GENERIC_HUMIDITY_SENSOR:
return
elif device.type_of_device == DeviceType.GENERIC_TEMPERATURE_SENSOR:
objs = drivers.GTS.driver.driver_function(models, unit, obj['data'])
elif device.type_of_device == DeviceType.GENERIC_LAMP:
objs = drivers.GL.driver.driver_function(models, unit, obj['data'])
else:
return
prepared_objs = []
for o in objs:
o.save()
if isinstance(o, models.TemperatureUnitValue):
serializer_obj = json.dumps(
serializers.TemperatureUnitValueSerializer(o).data)
prepared_obj = {
'data': serializer_obj,
'type': 'TemperatureUnitValue'
}
prepared_objs.append(json.dumps(prepared_obj))
if isinstance(o, models.SwitchUnitValue):
serializer_obj = json.dumps(
serializers.SwitchUnitValueSerializer(o).data)
prepared_obj = {'data': serializer_obj, 'type': 'SwitchUnitValue'}
prepared_objs.append(json.dumps(prepared_obj))
connected_units = models.ConnectedUnit.objects.filter(from_unit=unit)
print(connected_units)
for connected_unit in connected_units:
payload = {
'device': connected_unit.dest_device,
'unit': connected_unit.dest_unit,
'data': prepared_objs
}
try:
hub = AuthServiceApi.get_hub(connected_unit.dest_hub)
except Exception as e:
print(e)
try:
InternalApi.send_data_to_unit(hub, payload)
except Exception as e:
print(e)
def get(self, request, *args, **kwargs):
token = self.request.COOKIES.get('user_token')
self.hub = AuthServiceApi.get_hub(self.kwargs.get('dest_hub'))
self.device = InternalApi.get_device(token, self.hub,
self.kwargs.get('dest_device'))
self.unit = InternalApi.get_unit(token, self.hub, self.device['pk'],
self.kwargs.get('dest_unit'))
context = self.get_context_data()
return self.render_to_response(context)
def has_permission(self, request, view):
key = request.META.get("HTTP_X_API_KEY")
if key is None:
raise PermissionDenied("Unauthorized Hub")
hub_id = request.META.get("HTTP_HUB_ID")
if hub_id is None:
raise PermissionDenied("Unauthorized Hub")
response = AuthServiceApi.verify_hub_api_key(hub_id, key)
return response['is_valid']
def get(self, request, *args, **kwargs):
token = self.request.COOKIES.get('user_token')
self.hub = AuthServiceApi.get_hub(self.kwargs.get('hub'))
self.device = InternalApi.get_device(token, self.hub,
self.kwargs.get('device'))
self.unit = InternalApi.get_unit(token, self.hub, self.device['pk'],
self.kwargs.get('pk'))
self.connected_units = InternalApi.get_connected_units_with_unit(
token, self.hub, self.unit['pk'])
return super(ConnectedUnitList, self).get(request, *args, **kwargs)
def post(self, request, *args, **kwargs):
token = self.request.COOKIES.get('user_token')
hub = AuthServiceApi.get_hub(self.kwargs.get('hub'))
InternalApi.add_connected_unit(
token, hub, {
'from_unit': int(self.kwargs.get('pk')),
'dest_hub': int(self.kwargs.get('dest_hub')),
'dest_device': int(self.kwargs.get('dest_device')),
'dest_unit': int(self.kwargs.get('dest_unit'))
})
return HttpResponseRedirect(self.get_success_url())
def post(self, request, device, format=None):
me = AuthServiceApi.get_me(self.request.headers.get('Authorization'))
if not me['is_staff']:
return Response(status=status.HTTP_403_FORBIDDEN)
serializer = DeviceUnitSerializer(data=request.data)
if serializer.is_valid():
device = Device.objects.get(pk=device)
DeviceUnit.objects.create(device=device,
**serializer.validated_data)
return Response(serializer.validated_data,
status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, pk, format=None):
me = AuthServiceApi.get_me(self.request.headers.get('Authorization'))
if not me['is_staff']:
return Response(status=status.HTTP_403_FORBIDDEN)
try:
device = Device.objects.get(pk=pk)
except Device.DoesNotExist:
raise Http404
serializer = DeviceSerializer(device, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_200_OK)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, device, pk, format=None):
me = AuthServiceApi.get_me(self.request.headers.get('Authorization'))
if not me['is_staff']:
return Response(status=status.HTTP_403_FORBIDDEN)
serializer = DeviceUnitSerializer(data=request.data)
if serializer.is_valid():
unit = DeviceUnit.objects.get(pk=pk)
unit.name = serializer.validated_data['name']
unit.direction = serializer.validated_data['direction']
unit.type_of_unit = serializer.validated_data['type_of_unit']
unit.save()
return Response(serializer.validated_data,
status=status.HTTP_200_OK)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get(self, request, device, pk=None, format=None):
me = AuthServiceApi.get_me(self.request.headers.get('Authorization'))
device_obj = Device.objects.get(pk=device)
if pk is None:
if me['is_staff']:
objects = DeviceUnit.objects.filter(device=device_obj)
else:
read_permission = AuthServiceApi.has_read_permission(
HUB_ID, device, me['pk'])
if not read_permission['has_read_perm']:
return Response(status=status.HTTP_403_FORBIDDEN)
objects = DeviceUnit.objects.filter(device=device_obj)
else:
read_permission = AuthServiceApi.has_read_permission(
HUB_ID, device, me['pk'])
if me['is_staff']:
objects = DeviceUnit.objects.get(device=device_obj, pk=pk)
else:
if not read_permission['has_read_perm']:
return Response(status=status.HTTP_403_FORBIDDEN)
objects = DeviceUnit.objects.get(device=device_obj, pk=pk)
serializer = DeviceUnitSerializer(objects, many=pk is None)
return Response(serializer.data)
