def add_comms_log(self, request, *args, **kwargs):
try:
with transaction.atomic():
instance = self.get_object()
mutable=request.data._mutable
request.data._mutable=True
request.data['emailuser'] = u'{}'.format(instance.id)
request.data['staff'] = u'{}'.format(request.user.id)
request.data._mutable=mutable
serializer = EmailUserLogEntrySerializer(data=request.data)
serializer.is_valid(raise_exception=True)
comms = serializer.save()
# Save the files
for f in request.FILES:
document = comms.documents.create()
document.name = str(request.FILES[f])
document._file = request.FILES[f]
document.save()
# End Save Documents
return add_cache_control(Response(serializer.data))
except serializers.ValidationError:
print(traceback.print_exc())
raise
except ValidationError as e:
print(traceback.print_exc())
raise serializers.ValidationError(repr(e.error_dict))
except Exception as e:
print(traceback.print_exc())
raise serializers.ValidationError(str(e))
def create(self, request, *args, **kwargs):
response = super(PaymentViewSet, self).create(request, *args, **kwargs)
# here may be placed additional operations for
# extracting id of the object and using reverse()
fallback_url = request.build_absolute_uri('/')
return add_cache_control(
HttpResponseRedirect(redirect_to=fallback_url + '/success/'))
def first_time(request):
context = {}
if request.method == 'POST':
form = FirstTimeForm(request.POST)
redirect_url = form.data['redirect_url']
if not redirect_url:
redirect_url = '/'
if form.is_valid():
# set user attributes
request.user.first_name = form.cleaned_data['first_name']
request.user.last_name = form.cleaned_data['last_name']
request.user.dob = form.cleaned_data['dob']
request.user.save()
return redirect(redirect_url)
context['form'] = form
context['redirect_url'] = redirect_url
return render(request, 'mooringlicensing/user_profile.html', context)
# GET default
if 'next' in request.GET:
context['redirect_url'] = request.GET['next']
else:
context['redirect_url'] = '/'
context['dev'] = settings.DEV_STATIC
context['dev_url'] = settings.DEV_STATIC_URL
return add_cache_control(
render(request, 'mooringlicensing/dash/index.html', context))
def get(self, request, format=None):
data = cache.get('department_users')
if not data:
retrieve_department_users()
data = cache.get('department_users')
return add_cache_control(Response(data))
serializer = UserSerializer(request.user)
def get(self, request, format=None):
# Return current and future seasons for the DCV permit
application_type = ApplicationType.objects.get(
code=settings.APPLICATION_TYPE_DCV_PERMIT['code'])
fee_constructors = FeeConstructor.get_current_and_future_fee_constructors_by_application_type_and_date(
application_type, )
data = [{
'id': item.fee_season.id,
'name': item.fee_season.__str__()
} for item in fee_constructors]
return add_cache_control(Response(data))
def lookup_dcv_vessel(self, request, *args, **kwargs):
dcv_vessel = self.get_object()
serializer = DcvVesselSerializer(dcv_vessel)
dcv_vessel_data = serializer.data
dcv_vessel_data['annual_admission_permits'] = [
] # TODO: retrieve the permits
dcv_vessel_data['authorised_user_permits'] = [
] # TODO: retrieve the permits
dcv_vessel_data['mooring_licence'] = [] # TODO: retrieve the licences
return add_cache_control(Response(dcv_vessel_data))
def process_request(self, request):
#print ("FirstTimeNagScreenMiddleware: REQUEST SESSION")
if request.user.is_authenticated(
) and request.method == 'GET' and 'api' not in request.path and 'admin' not in request.path:
if (not request.user.first_name or not request.user.last_name):
path_ft = reverse('first_time')
path_logout = reverse('accounts:logout')
if request.path not in (path_ft, path_logout):
#response = add_cache_control(redirect(reverse('first_time')+"?next="+urlquote_plus(request.get_full_path())))
return add_cache_control(
redirect(
reverse('first_time') + "?next=" +
urlquote_plus(request.get_full_path())))
def comms_log(self, request, *args, **kwargs):
try:
instance = self.get_object()
qs = instance.comms_logs.all()
serializer = EmailUserCommsSerializer(qs,many=True)
return add_cache_control(Response(serializer.data))
except serializers.ValidationError:
print(traceback.print_exc())
raise
except ValidationError as e:
print(traceback.print_exc())
raise serializers.ValidationError(repr(e.error_dict))
except Exception as e:
print(traceback.print_exc())
raise serializers.ValidationError(str(e))
def update_personal(self, request, *args, **kwargs):
try:
instance = self.get_object()
serializer = PersonalSerializer(instance,data=request.data)
serializer.is_valid(raise_exception=True)
instance = serializer.save()
serializer = UserSerializer(instance)
return add_cache_control(Response(serializer.data))
except serializers.ValidationError:
print(traceback.print_exc())
raise
except ValidationError as e:
print(traceback.print_exc())
raise serializers.ValidationError(repr(e.error_dict))
except Exception as e:
print(traceback.print_exc())
raise serializers.ValidationError(str(e))
def pending_org_requests(self, request, *args, **kwargs):
try:
instance = self.get_object()
serializer = OrganisationRequestDTSerializer(
instance.organisationrequest_set.filter(
status='with_assessor'),
many=True,
context={'request': request})
return add_cache_control(Response(serializer.data))
except serializers.ValidationError:
print(traceback.print_exc())
raise
except ValidationError as e:
print(traceback.print_exc())
raise serializers.ValidationError(repr(e.error_dict))
except Exception as e:
print(traceback.print_exc())
raise serializers.ValidationError(str(e))
def update_address(self, request, *args, **kwargs):
try:
instance = self.get_object()
# residential address
residential_serializer = UserAddressSerializer(data=request.data.get('residential_address'))
residential_serializer.is_valid(raise_exception=True)
residential_address, created = Address.objects.get_or_create(
line1 = residential_serializer.validated_data['line1'],
locality = residential_serializer.validated_data['locality'],
state = residential_serializer.validated_data['state'],
country = residential_serializer.validated_data['country'],
postcode = residential_serializer.validated_data['postcode'],
user = instance
)
instance.residential_address = residential_address
# postal address
postal_address_data = request.data.get('postal_address')
if postal_address_data and postal_address_data.get('same_as_residential'):
instance.postal_address = residential_address
elif postal_address_data:
postal_serializer = UserAddressSerializer(data=postal_address_data)
postal_serializer.is_valid(raise_exception=True)
postal_address, created = Address.objects.get_or_create(
line1 = postal_serializer.validated_data['line1'],
locality = postal_serializer.validated_data['locality'],
state = postal_serializer.validated_data['state'],
country = postal_serializer.validated_data['country'],
postcode = postal_serializer.validated_data['postcode'],
user = instance
)
instance.postal_address = postal_address
instance.save()
serializer = UserSerializer(instance)
return add_cache_control(Response(serializer.data))
except serializers.ValidationError:
print(traceback.print_exc())
raise
except ValidationError as e:
print(traceback.print_exc())
raise serializers.ValidationError(repr(e.error_dict))
except Exception as e:
print(traceback.print_exc())
raise serializers.ValidationError(str(e))
def upload_id(self, request, *args, **kwargs):
try:
instance = self.get_object()
instance.upload_identification(request)
with transaction.atomic():
instance.save()
instance.log_user_action(EmailUserAction.ACTION_ID_UPDATE.format(
'{} {} ({})'.format(instance.first_name, instance.last_name, instance.email)), request)
serializer = UserSerializer(instance, partial=True)
return add_cache_control(Response(serializer.data))
except serializers.ValidationError:
print(traceback.print_exc())
raise
except ValidationError as e:
print(traceback.print_exc())
raise serializers.ValidationError(repr(e.error_dict))
except Exception as e:
print(traceback.print_exc())
raise serializers.ValidationError(str(e))
def get(self, request, format=None):
try:
data = {
"date": request.GET.get("date"),
"override": request.GET.get("override")
}
serializer = OracleSerializer(data=data)
serializer.is_valid(raise_exception=True)
oracle_integration(
serializer.validated_data['date'].strftime('%Y-%m-%d'),
serializer.validated_data['override'])
data = {'successful': True}
return add_cache_control(Response(data))
except serializers.ValidationError:
print(traceback.print_exc())
raise
except ValidationError as e:
raise serializers.ValidationError(repr(e.error_dict)) if hasattr(
e, 'error_dict') else serializers.ValidationError(e)
except Exception as e:
print(traceback.print_exc())
raise serializers.ValidationError(str(e[0]))
def update_system_settings(self, request, *args, **kwargs):
try:
instance = self.get_object()
# serializer = UserSystemSettingsSerializer(data=request.data)
# serializer.is_valid(raise_exception=True)
user_setting, created = UserSystemSettings.objects.get_or_create(
user = instance
)
serializer = UserSystemSettingsSerializer(user_setting, data=request.data)
serializer.is_valid(raise_exception=True)
#instance.residential_address = address
serializer.save()
instance = self.get_object()
serializer = UserSerializer(instance)
return add_cache_control(Response(serializer.data))
except serializers.ValidationError:
print(traceback.print_exc())
raise
except ValidationError as e:
print(traceback.print_exc())
raise serializers.ValidationError(repr(e.error_dict))
except Exception as e:
print(traceback.print_exc())
raise serializers.ValidationError(str(e))
def get(self, request, format=None):
#logger.info('request user: {}'.format(request.user))
serializer = UserSerializer(request.user, context={'request':request})
#logger.info('user serializer data: {}'.format(serializer.data))
response = Response(serializer.data)
return add_cache_control(response)
