def update(self, request, *args, **kwargs):
network = self.get_object()
device = Device.objects.get(pk=self.kwargs['device_id'])
serializer = DeviceNetworkUpdateSerializer(network, data=request.data)
serializer.is_valid(raise_exception=True)
if network.password != request.data['old_password']:
data = {
'code': getattr(settings, 'ERROR_CODE', 0),
'message': "Old password is not correct."
}
return Response(data, status=status.HTTP_400_BAD_REQUEST)
serializer.save(device=device)
message = "{network} network of device '{device}' of user '{email}' updated."
message = message.format(
network='Primary' if network.primary_network else 'Secondary',
device=device.serial_number,
email=request.auth.user.email)
create_activity_log(request, message)
data = {
'code': getattr(settings, 'SUCCESS_CODE', 1),
'message': "Device successfully updated.",
'data': serializer.data
}
return Response(data, status=status.HTTP_200_OK)
def create(self, request, *args, **kwargs):
instance = self.get_queryset()
serializer = DeviceSleepSerializer(instance, data=request.data)
serializer.is_valid(raise_exception=True)
serializer.save()
data_to_cache = {
'id':
instance.id,
'sleep_start': (datetime.datetime.strptime(
serializer.data['sleep_settings']['sleep_start'],
"%Y-%m-%dT%H:%M:%SZ")).strftime('%Y-%m-%d %H:%M:%S'),
'is_asleep':
serializer.data['sleep_settings']['is_asleep'],
'sleep_duration':
serializer.data['sleep_settings']['sleep_duration']
}
update_cached_device_list(data_to_cache)
create_activity_log(
request,
"Sleep setting of device '{device}' of user '{email} updated.".
format(device=instance.device.serial_number,
email=request.auth.user.email))
data = {
'code': getattr(settings, 'SUCCESS_CODE', 1),
'message': "Successfully sleep settings updated.",
'data': serializer.data
}
return Response(data, status=status.HTTP_200_OK)
def device_priority_view(request, device_id):
'''
API to prioritize/unprioritize device
:param request:
:param device_id:
:return:
'''
try:
device = Device.objects.get(pk=device_id)
device_setting, _ = DeviceSetting.objects.get_or_create(device=device)
serializer = DevicePrioritySettingSerializer(device_setting,
data=request.data)
serializer.is_valid(raise_exception=True)
serializer.save()
create_activity_log(
request,
"Priority of device '{device}' of user '{user}' updated.".format(
device=device.serial_number, user=request.auth.user.email))
data = {
'code': getattr(settings, 'SUCCESS_CODE', 1),
'message': "Successfully priority updated.",
'data': serializer.data
}
return Response(data, status=status.HTTP_200_OK)
except (AttributeError, ObjectDoesNotExist) as err:
return Response(
{
"code": getattr(settings, 'ERROR_CODE', 0),
"message": str(err)
},
status=status.HTTP_400_BAD_REQUEST)
def create(self, request, *args, **kwargs):
data = request.data
user = request.auth.user
# case sensitive validation of name
if franchise_type_name_already_exits(request.data['name'], user):
return Response(
{
'code': getattr(settings, 'ERROR_CODE', 0),
'message': "Franchise type with this name already exists.",
},
status=status.HTTP_400_BAD_REQUEST)
data['user'] = user.id
serializer = LocationTypeSerializer(data=data)
serializer.is_valid(raise_exception=True)
serializer.save()
create_activity_log(
request, "Location Type '{name}' added to user '{email}'.".format(
name=serializer.data['name'], email=user.email))
return Response(
{
'code': getattr(settings, 'SUCCESS_CODE', 1),
'message': "Successfully added location type.",
'data': serializer.data
},
status=status.HTTP_201_CREATED)
def update(self, request, *args, **kwargs):
industry_type = self.get_object()
user = request.auth.user
# case sensitive validation of name
if industry_type_name_already_exits(request.data['name'], user):
return Response(
{
'code': getattr(settings, 'ERROR_CODE', 0),
'message': "Industry type with this name already exists.",
},
status=status.HTTP_400_BAD_REQUEST)
serializer = IndustryTypeSerializer(industry_type, data=request.data)
serializer.is_valid(raise_exception=True)
serializer.save(user=user)
create_activity_log(
request,
"Industry Type '{name}' of user '{email}' updated.".format(
name=serializer.data['name'], email=user.email))
return Response(
{
'code': getattr(settings, 'SUCCESS_CODE', 1),
'message': "Successfully updated industry type.",
'data': serializer.data
},
status=status.HTTP_200_OK)
def destroy(self, request, *args, **kwargs):
instance = self.get_object()
create_activity_log(
request, "Device '{s_no}' of user '{email}' deleted.".format(
s_no=instance.serial_number, email=request.auth.user.email))
instance.delete()
data = {
'code': getattr(settings, 'SUCCESS_CODE', 1),
'message': "Device successfully deleted."
}
return Response(data, status=status.HTTP_200_OK)
def destroy(self, request, *args, **kwargs):
camera = self.get_object()
create_activity_log(
request,
"Camera information for device '{s_no}' of user '{email}' deleted."
.format(s_no=camera.camera_service.serial_number,
email=request.auth.user.email))
camera.delete()
data = {
'code': getattr(settings, 'SUCCESS_CODE', 1),
'message': "Successfully deleted device's camera information."
}
return Response(data, status=status.HTTP_200_OK)
def destroy(self, request, *args, **kwargs):
instance = self.get_object()
user = request.auth.user
create_activity_log(
request, "Preset '{preset}' of user '{email}' deleted.".format(
preset=instance.name, email=user.email))
self.perform_destroy(instance)
return Response(
{
'code': getattr(settings, 'SUCCESS_CODE', 1),
'message': "Successfully deleted preset filter."
},
status=status.HTTP_200_OK)
def mute_device_view(request, device_id):
'''
API to mute device
:param request:
:param device_id:
:return:
'''
try:
device_obj = Device.objects.get(pk=device_id)
device_setting, _ = DeviceSetting.objects.get_or_create(
device=device_obj)
mute_serializer = DeviceMuteSettingSerializer(device_setting,
data=request.data)
mute_serializer.is_valid(raise_exception=True)
mute_serializer.save()
create_activity_log(
request,
"Mute setting of device '{device}' of user '{email} updated.".
format(device=device_obj.serial_number,
email=request.auth.user.email))
data_to_cache = {
'id':
device_setting.id,
'mute_start': (datetime.datetime.strptime(
mute_serializer.data['mute_settings']['mute_start'],
"%Y-%m-%dT%H:%M:%SZ")).strftime('%Y-%m-%d %H:%M:%S'),
'is_muted':
mute_serializer.data['mute_settings']['is_muted'],
'mute_duration':
mute_serializer.data['mute_settings']['mute_duration']
}
update_cached_device_list(data_to_cache)
data = {
'code': getattr(settings, 'SUCCESS_CODE', 1),
'message': "Device Mute status is Changed.",
'data': mute_serializer.data
}
return Response(data, status=status.HTTP_200_OK)
except (AttributeError, ObjectDoesNotExist) as err:
return Response(
{
"code": getattr(settings, 'ERROR_CODE', 0),
"message": str(err)
},
status=status.HTTP_400_BAD_REQUEST)
def update(self, request, *args, **kwargs):
user = request.auth.user
serializer = UserSerializer(user, data=request.data)
serializer.is_valid(raise_exception=True)
serializer.save()
create_activity_log(request,
"User profile of '{}' updated.".format(user.email))
data = {
'code': getattr(settings, 'SUCCESS_CODE', 1),
'message': "User successfully updated",
'data': serializer.data
}
return Response(data, status=status.HTTP_200_OK)
def delete_billing_card(request):
'''
API to delete logged in User's billing info.
'''
stripe.api_key = settings.STRIPE_API_KEY
card_id = request.data['id']
user = request.auth.user
billing_obj = Billing.objects.get(user=user)
customer = stripe.Customer.retrieve(billing_obj.customer_id)
customer.sources.retrieve(card_id).delete()
create_activity_log(request, "A card of user '{email}' deleted.".format(email=user.email))
data = {
"code": getattr(settings, 'SUCCESS_CODE', 1),
"message": "Card is Successfully removed",
}
return Response(data, status=status.HTTP_200_OK)
def update(self, request, *args, **kwargs):
camera = self.get_object()
serializer = DeviceCameraSerializer(camera, data=request.data)
serializer.is_valid(raise_exception=True)
serializer.save()
create_activity_log(
request,
"Camera information for device '{s_no}' of user '{email}' updated."
.format(s_no=camera.camera_service.serial_number,
email=request.auth.user.email))
data = {
'code': getattr(settings, 'SUCCESS_CODE', 1),
'message': "Successfully updated device's camera information.",
'data': {
'camera_service': serializer.data
}
}
return Response(data, status=status.HTTP_200_OK)
def create(self, request, *args, **kwargs):
device_network = self.get_queryset()
if len(device_network) >= 2:
data = {
'code': getattr(settings, 'ERROR_CODE', 0),
'message': "Multiple secondary networks can't be set."
}
return Response(data, status=status.HTTP_400_BAD_REQUEST)
data = request.data
if len(device_network.filter(
primary_network=True)) == 0 and not data['primary_network']:
data = {
'code': getattr(settings, 'ERROR_CODE', 0),
'message': "Secondary network can't be set first."
}
return Response(data, status=status.HTTP_400_BAD_REQUEST)
if len(device_network.filter(
primary_network=True)) == 1 and data['primary_network']:
data = {
'code': getattr(settings, 'ERROR_CODE', 0),
'message': "Multiple primary network can't be set."
}
return Response(data, status=status.HTTP_400_BAD_REQUEST)
serializer = DeviceNetworkSerializer(data=data)
serializer.is_valid(raise_exception=True)
serializer.save(device=self.device)
message = "{network} network added to device '{device}' of user '{email}'."
message = message.format(
network='Primary' if data['primary_network'] else 'Secondary',
device=self.device.serial_number,
email=request.auth.user.email)
create_activity_log(request, message)
data = {
'code': getattr(settings, 'SUCCESS_CODE', 1),
'message': "Device successfully updated.",
'data': serializer.data
}
return Response(data, status=status.HTTP_200_OK)
def create(self, request, *args, **kwargs):
user = request.auth.user
device_obj = Device.objects.get(pk=self.kwargs['id'])
serializer = DeviceCameraSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
serializer.save(device=device_obj)
create_activity_log(
request,
"Camera information for device '{s_no}' of user '{email}' added.".
format(s_no=device_obj.serial_number, email=user.email))
data = {
'code': getattr(settings, 'SUCCESS_CODE', 1),
'message': "Successfully added device's camera information.",
'data': {
'camera_service': serializer.data
}
}
return Response(data, status=status.HTTP_201_CREATED)
def post(self, request, *args, **kwargs):
if not valid_password_regex(request.data['new_password1']):
return Response(
{
"code":
getattr(settings, 'ERROR_CODE', 0),
"message":
"Password must be 8 characters long with at least 1 number or 1 special character."
},
status=status.HTTP_400_BAD_REQUEST)
response = super().post(request, *args, **kwargs)
create_activity_log(
request, "Password of user '{email}' changed.".format(
email=request.auth.user.email))
response.data = {
"code": getattr(settings, 'SUCCESS_CODE', 1),
"message": "New password has been saved."
}
return response
def destroy(self, request, *args, **kwargs):
instance = self.get_object()
if instance.primary_network:
return Response(
{
'code': getattr(settings, 'ERROR_CODE', 0),
'message': "Primary network can't be deleted."
},
status=status.HTTP_400_BAD_REQUEST)
message = "Secondary network of device '{device}' of user '{email}' deleted."
message = message.format(device=instance.device.serial_number,
email=request.auth.user.email)
create_activity_log(request, message)
instance.delete()
return Response(
{
'code': getattr(settings, 'SUCCESS_CODE', 1),
'message': "Secondary network successfully deleted."
},
status=status.HTTP_200_OK)
def create(self, request, *args, **kwargs):
user = request.auth.user
industry_id = request.data.get('industry_type_id', '')
franchise_id = request.data.get('location_type_id', '')
if not industry_id:
return Response(
{
'code': getattr(settings, 'ERROR_CODE', 0),
'message': "Industry Type can't be null/blank."
},
status=status.HTTP_400_BAD_REQUEST)
if not franchise_id:
return Response(
{
'code': getattr(settings, 'ERROR_CODE', 0),
'message': "Location Type can't be null/blank."
},
status=status.HTTP_400_BAD_REQUEST)
industry = Industry.objects.get(pk=industry_id)
franchise = Franchise.objects.get(pk=franchise_id)
serializer = DeviceSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
serializer.save(user=user,
industry_type=industry,
location_type=franchise)
create_activity_log(
request, "Device '{s_no}' added to user '{email}'.".format(
s_no=serializer.data['serial_number'], email=user.email))
data = {
'code': getattr(settings, 'SUCCESS_CODE', 1),
'message': "Successfully device created.",
'data': serializer.data
}
return Response(data, status=status.HTTP_201_CREATED)
def create(self, request, *args, **kwargs):
user = request.auth.user
if self.get_queryset():
serializer = BusinessSerializer(self.get_queryset().first(),
data=request.data)
else:
serializer = BusinessSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
serializer.save(user=user)
create_activity_log(
request,
"Business information of user '{}' added.".format(user.email))
headers = self.get_success_headers(serializer.data)
data = {
'code':
getattr(settings, 'SUCCESS_CODE', 1),
'message':
"Business Info successfully created."
if self.get_queryset() else "Business Info successfully updated.",
'data':
serializer.data
}
return Response(data, status=status.HTTP_201_CREATED, headers=headers)
def create(self, request, *args, **kwargs):
data = request.data
stripe.api_key = settings.STRIPE_API_KEY
stripe_token = data['id'].strip()
email = data['email']
user = request.auth.user
billing_obj = Billing.objects.filter(user=user)
serializer = BillingSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
if billing_obj:
stripe.Customer.retrieve(billing_obj.first().customer_id).sources.create(source=stripe_token)
customer = stripe.Customer.retrieve(billing_obj.first().customer_id)
else:
try:
customer = stripe.Customer.create(
source=stripe_token,
email=email
)
serializer.save(user=user, customer_id=customer.id)
except Exception:
return Response({
'code': getattr(settings, 'ERROR_CODE', 0),
'message': "Stripe Token has already been used. Please try again with new token."
}, status=status.HTTP_400_BAD_REQUEST)
create_activity_log(request, "A card added to user '{email}'.".format(email=user.email))
data = {
'code': getattr(settings, 'SUCCESS_CODE', 1),
'message': "Billing Info successfully created.",
'data': customer
}
return Response(data, status=status.HTTP_201_CREATED)
def create(self, request, *args, **kwargs):
data = request.data
user = request.auth.user
serializer = PresetFilterSerializer(data=data)
serializer.is_valid(raise_exception=True)
try:
serializer.save(user=user)
create_activity_log(
request, "Preset '{preset}' added to user '{email}'.".format(
preset=serializer.data['name'], email=user.email))
return Response(
{
"code": getattr(settings, "SUCCESS_CODE", 1),
"message": "Successfully fetched preset filter data.",
"data": serializer.data
},
status=status.HTTP_200_OK)
except:
return Response(
{
"code": getattr(settings, "ERROR_CODE", 0),
"message": "This preset name already exists",
},
status=status.HTTP_400_BAD_REQUEST)
