def update(self, request, *args, **kwargs):
instance = self.get_object()
try:
with transaction.atomic():
request_data = request.data
if (
request_data.get('location', {}).get('geometry', {}).get('coordinates', {}) or
request_data.get('location', {}).get('properties', {}).get('postcode', {}) or
request_data.get('location', {}).get('properties', {}).get('details', {})
):
location_request_data = request.data.get('location')
returned_location = save_location(location_request_data)
if returned_location:
request_data.update({'location_id': returned_location.get('id')})
# self.save_email_user(request)
if request_data.get('renderer_data'):
self.form_data(request)
#if request_data.get('report_type_id'):
# request_data.update({'report_type_id': request_data.get('report_type', {}).get('id')})
if instance.report_type and 'report_type_id' in request.data.keys() and not request.data.get('report_type_id'):
del request.data['report_type_id']
serializer = SaveCallEmailSerializer(instance, data=request_data)
serializer.is_valid(raise_exception=True)
if serializer.is_valid():
saved_instance = serializer.save()
instance.log_user_action(
CallEmailUserAction.ACTION_SAVE_CALL_EMAIL_.format(
instance.number), request)
headers = self.get_success_headers(serializer.data)
return_serializer = CallEmailSerializer(instance=saved_instance, context={'request': request})
return Response(
return_serializer.data,
status=status.HTTP_201_CREATED,
headers=headers
)
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):
try:
with transaction.atomic():
# 1. Save Location
if (request.data.get('location', {}).get('geometry', {}).get(
'coordinates', {})
or request.data.get('location', {}).get(
'properties', {}).get('postcode', {})
or request.data.get('location', {}).get(
'properties', {}).get('details', {})):
location_request_data = request.data.get('location')
returned_location = save_location(location_request_data)
if returned_location:
request.data.update(
{'location_id': returned_location.get('id')})
serializer = SaveInspectionSerializer(data=request.data,
partial=True)
serializer.is_valid(raise_exception=True)
if serializer.is_valid():
instance = serializer.save()
instance.log_user_action(
InspectionUserAction.ACTION_CREATE_INSPECTION.format(
instance.number), request)
# Create comms_log and send mail
res = self.workflow_action(request,
instance,
create_inspection=True)
if instance.call_email:
print("update parent")
self.update_parent(request, instance)
return res
except serializers.ValidationError:
print(traceback.print_exc())
raise
except ValidationError as e:
if hasattr(e, 'error_dict'):
raise serializers.ValidationError(repr(e.error_dict))
else:
# raise serializers.ValidationError(repr(e[0].encode('utf-8')))
raise serializers.ValidationError(repr(e[0]))
except Exception as e:
print(traceback.print_exc())
raise serializers.ValidationError(str(e))
def update(self, request, workflow=False, *args, **kwargs):
try:
with transaction.atomic():
# 1. Save Location
if (
request.data.get('location', {}).get('geometry', {}).get('coordinates', {}) or
request.data.get('location', {}).get('properties', {}).get('postcode', {}) or
request.data.get('location', {}).get('properties', {}).get('details', {})
):
location_request_data = request.data.get('location')
returned_location = save_location(location_request_data)
if returned_location:
request.data.update({'location_id': returned_location.get('id')})
instance = self.get_object()
# record individual inspected before update
individual_inspected_id = instance.individual_inspected_id
# record organisation inspected before update
organisation_inspected_id = instance.organisation_inspected_id
# record party_inspected before update
party_inspected = instance.party_inspected
if request.data.get('renderer_data'):
self.form_data(request)
if instance.inspection_type and not request.data.get('inspection_type_id') and 'inspection_type_id' in request.data.keys():
del request.data['inspection_type_id']
serializer = SaveInspectionSerializer(instance, data=request.data)
serializer.is_valid(raise_exception=True)
if serializer.is_valid():
serializer.save()
instance.log_user_action(
InspectionUserAction.ACTION_SAVE_INSPECTION_.format(
instance.number), request)
# Log individual_inspected update if applicable
if instance.party_inspected == 'individual' and individual_inspected_id and \
(individual_inspected_id != instance.individual_inspected_id or \
party_inspected != instance.party_inspected):
prev_individual_inspected = EmailUser.objects.get(id=individual_inspected_id)
instance.log_user_action(
InspectionUserAction.ACTION_CHANGE_INDIVIDUAL_INSPECTED.format(
prev_individual_inspected.get_full_name(),
instance.individual_inspected.get_full_name()), request)
# Log organisation_inspected update if applicable
if instance.party_inspected == 'organisation' and organisation_inspected_id and \
(organisation_inspected_id != instance.organisation_inspected_id or \
party_inspected != instance.party_inspected):
prev_organisation_inspected = Organisation.objects.get(id=organisation_inspected_id)
instance.log_user_action(
InspectionUserAction.ACTION_CHANGE_ORGANISATION_INSPECTED.format(
prev_organisation_inspected.name,
instance.organisation_inspected.name), request)
headers = self.get_success_headers(serializer.data)
return_serializer = InspectionSerializer(instance, context={'request': request})
return Response(
return_serializer.data,
status=status.HTTP_201_CREATED,
headers=headers
)
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):
try:
with transaction.atomic():
request_data = request.data
# 1. Save Location
if (request_data.get('location', {}).get('geometry', {}).get(
'coordinates', {})
or request_data.get('location', {}).get(
'properties', {}).get('postcode', {})
or request_data.get('location', {}).get(
'properties', {}).get('details', {})):
location_request_data = request.data.get('location')
returned_location = save_location(location_request_data)
if returned_location:
request_data.update(
{'location_id': returned_location.get('id')})
# 2. Create Offence
request_data['status'] = 'open'
request_data['region_id'] = int(
request_data['region_id']
) if request_data['region_id'] else None
request_data['district_id'] = int(
request_data['district_id']
) if request_data['district_id'] else None
serializer = SaveOffenceSerializer(data=request_data)
serializer.is_valid(raise_exception=True)
saved_offence_instance = serializer.save(
) # Here, relations between this offence and location, and this offence and call_email/inspection are created
# 2.1. Determine allocated group and save it
new_group = Offence.get_compliance_permission_group(
saved_offence_instance.regionDistrictId)
saved_offence_instance.allocated_group = new_group
saved_offence_instance.assigned_to = None
saved_offence_instance.responsible_officer = request.user
saved_offence_instance.log_user_action(
OffenceUserAction.ACTION_CREATE.format(
saved_offence_instance.lodgement_number), request)
saved_offence_instance.save()
# 2.2. Update parents
self.update_parent(request, saved_offence_instance)
# Handle documents
from wildlifecompliance.components.main.models import TemporaryDocumentCollection
from wildlifecompliance.components.main.process_document import save_default_document_obj
temporary_document_collection_dict = request_data.get(
'temporary_document_collection_id', None)
if temporary_document_collection_dict:
temporary_document_collection_id = temporary_document_collection_dict.get(
'temp_doc_id', None)
if temporary_document_collection_id:
temp_doc_collection, created = TemporaryDocumentCollection.objects.get_or_create(
id=temporary_document_collection_id)
if temp_doc_collection:
for doc in temp_doc_collection.documents.all():
save_default_document_obj(
saved_offence_instance, doc)
pass
temp_doc_collection.delete()
## 2a. Log it to the call email, if applicable
#if saved_offence_instance.call_email:
# saved_offence_instance.call_email.log_user_action(
# CallEmailUserAction.ACTION_OFFENCE.format(
# saved_offence_instance.call_email.number),
# request)
## 2b. Log it to the inspection, if applicable
#if saved_offence_instance.inspection:
# saved_offence_instance.inspection.log_user_action(
# InspectionUserAction.ACTION_OFFENCE.format(
# saved_offence_instance.inspection.number),
# request)
# 3. Create relations between this offence and the alleged 0ffence(s)
for alleged_offence in request_data['alleged_offences']:
section_regulation = SectionRegulation.objects.get(
id=alleged_offence['section_regulation']['id'])
# Insert a record into the through table
alleged_offence = AllegedOffence.objects.create(
section_regulation=section_regulation,
offence=saved_offence_instance,
)
# 4. Create relations between this offence and offender(s)
for dict in request_data['offenders']:
if dict['data_type'] == 'individual':
offender = EmailUser.objects.get(id=dict['id'])
serializer_offender = SaveOffenderSerializer(
data={
'offence_id': saved_offence_instance.id,
'person_id': offender.id
})
serializer_offender.is_valid(raise_exception=True)
serializer_offender.save()
elif dict['data_type'] == 'organisation':
offender = Organisation.objects.get(id=dict['id'])
serializer_offender = SaveOffenderSerializer(
data={
'offence_id': saved_offence_instance.id,
'organisation_id': offender.id
})
serializer_offender.is_valid(raise_exception=True)
serializer_offender.save()
# 4. Return Json
headers = self.get_success_headers(serializer.data)
return_serializer = OffenceSerializer(
instance=saved_offence_instance,
context={'request': request})
# return_serializer = InspectionSerializer(saved_instance, context={'request': request})
ret = Response(return_serializer.data,
status=status.HTTP_201_CREATED,
headers=headers)
return ret
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(self, request, *args, **kwargs):
try:
with transaction.atomic():
instance = self.get_object()
request_data = request.data
# 1. Save Location
if (request_data.get('location', {}).get('geometry', {}).get(
'coordinates', {})
or request_data.get('location', {}).get(
'properties', {}).get('postcode', {})
or request_data.get('location', {}).get(
'properties', {}).get('details', {})):
location_request_data = request.data.get('location')
returned_location = save_location(location_request_data)
if returned_location:
request_data.update(
{'location_id': returned_location.get('id')})
# 2. Save Offence
serializer = SaveOffenceSerializer(instance,
data=request_data,
partial=True)
serializer.is_valid(raise_exception=True)
serializer.save(
) # Here, relations between this offence and location, and this offence and call_email/inspection are created
instance.log_user_action(
OffenceUserAction.ACTION_UPDATE.format(
instance.lodgement_number), request)
# 3. Handle alleged offences
for item in request_data['alleged_offences']:
alleged_offence, created = AllegedOffence.objects.get_or_create(
section_regulation_id=item['section_regulation']['id'],
offence_id=request_data['id'])
if created:
# new alleged offence is added to the offence
# Which should be added to all the sanction outcomes under the offence if the status is 'draft'
sanction_outcomes = SanctionOutcome.objects.filter(
status=SanctionOutcome.STATUS_DRAFT,
offence=instance)
for so in sanction_outcomes:
aco = AllegedCommittedOffence.objects.create(
included=False,
alleged_offence=alleged_offence,
sanction_outcome=so)
else:
serializer = None
alleged_offence_removed = False
alleged_offence_restored = False
# Update attributes of existing alleged offence
if not alleged_offence.removed and item['removed']:
# This alleged offence is going to be removed
alleged_offence_removed = True
serializer = UpdateAllegedOffenceAttributeSerializer(
alleged_offence,
data={
'removed':
item['removed'],
'removed_by_id':
request.user.id,
'reason_for_removal':
item['reason_for_removal']
})
elif alleged_offence.removed and not item['removed']:
# This alleged offence is going to be restored
alleged_offence_restored = True
serializer = UpdateAllegedOffenceAttributeSerializer(
alleged_offence,
data={
'removed': item['removed'],
'removed_by_id': None,
'reason_for_removal': ''
})
if serializer:
serializer.is_valid(raise_exception=True)
serializer.save()
# Action log
if alleged_offence_removed:
instance.log_user_action(
OffenceUserAction.
ACTION_REMOVE_ALLEGED_OFFENCE.format(
alleged_offence,
item['reason_for_removal']), request)
# Update alleged committed offence's included status to False
alleged_committed_offences = AllegedCommittedOffence.objects.filter(
Q(alleged_offence=alleged_offence))
for aco in alleged_committed_offences.all():
serializer_aco = UpdateAllegedCommittedOffenceSerializer(
aco,
data={'included': False},
context={
'sanction_outcome':
aco.sanction_outcome
})
serializer_aco.is_valid(
raise_exception=True)
serializer_aco.save()
elif alleged_offence_restored:
instance.log_user_action(
OffenceUserAction.
ACTION_RESTORE_ALLEGED_OFFENCE.format(
alleged_offence), request)
# 4. Create relations between this offence and offender(s)
for item in request_data['offenders']:
if item['person']:
offender, created = Offender.objects.get_or_create(
person_id=item['person']['id'],
offence_id=request_data['id'])
elif item['organisation']:
offender, created = Offender.objects.get_or_create(
organisation_id=item['organisation']['id'],
offence_id=request_data['id'])
if not created:
serializer = None
# Update attributes of existing offender
if not offender.removed and item['removed']:
# This offender is going to be removed
serializer = UpdateOffenderAttributeSerializer(
offender,
data={
'removed':
item['removed'],
'removed_by_id':
request.user.id,
'reason_for_removal':
item['reason_for_removal']
})
elif offender.removed and not item['removed']:
# This offender is going to be restored
serializer = UpdateOffenderAttributeSerializer(
offender,
data={
'removed': item['removed'],
'removed_by_id': None,
'reason_for_removal': ''
})
else:
# other case where nothing changed on this offender
pass
if serializer:
serializer.is_valid(raise_exception=True)
# Action log
if not offender.removed and item['removed']:
instance.log_user_action(
OffenceUserAction.ACTION_REMOVE_OFFENDER.
format(offender,
item['reason_for_removal']),
request)
elif offender.removed and not item['removed']:
instance.log_user_action(
OffenceUserAction.ACTION_RESTORE_OFFENDER.
format(offender), request)
serializer.save()
# 4. Return Json
return self.retrieve(request)
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):
try:
with transaction.atomic():
request_data = request.data
# Create location then include in request to create new Call/Email
returned_location = None
if (
request_data.get('location', {}).get('geometry', {}).get('coordinates', {}) or
request_data.get('location', {}).get('properties', {}).get('postcode', {}) or
request_data.get('location', {}).get('properties', {}).get('details', {})
):
#returned_location = self.save_location(request)
location_request_data = request.data.get('location')
returned_location = save_location(location_request_data)
if returned_location:
request_data.update({'location_id': returned_location.get('id')})
#if request_data.get('report_type'):
# request_data.update({'report_type_id': request_data.get('report_type', {}).get('id')})
# Initial allocated_group_id must be volunteers
compliance_content_type = ContentType.objects.get(model="compliancepermissiongroup")
permission = Permission.objects.filter(codename='volunteer').filter(content_type_id=compliance_content_type.id).first()
group = CompliancePermissionGroup.objects.filter(permissions=permission).first()
request_data.update({'allocated_group_id': group.id})
serializer = CreateCallEmailSerializer(data=request_data, partial=True)
serializer.is_valid(raise_exception=True)
if serializer.is_valid():
new_instance = serializer.save()
new_instance.log_user_action(
CallEmailUserAction.ACTION_CREATE_CALL_EMAIL.format(
new_instance.number), request)
new_returned = serializer.data
# Ensure classification_id and report_type_id is returned for Vue template evaluation
# new_returned.update({'classification_id': request_data.get('classification_id')})
new_returned.update({'report_type_id': request_data.get('report_type_id')})
# new_returned.update({'referrer_id': request_data.get('referrer_id')})
if request_data.get('location'):
new_returned.update({'location_id': request_data.get('location').get('id')})
if request.data.get('renderer_data'):
# option required for duplicated Call/Emails
ComplianceFormDataRecord.process_form(
request,
new_instance,
request.data.get('renderer_data'),
action=ComplianceFormDataRecord.ACTION_TYPE_ASSIGN_VALUE
)
# Serializer returns CallEmail.data for HTTP response
duplicate = CallEmailSerializer(instance=new_instance, context={'request': request})
headers = self.get_success_headers(duplicate.data)
# duplicate.data.update({'classification_id': request_data.get('classification_id')})
duplicate.data.update({'report_type_id': request_data.get('report_type_id')})
# duplicate.data.update({'referrer_id': request_data.get('referrer_id')})
if request_data.get('location'):
duplicate.data.update({'location_id': request_data.get('location').get('id')})
return Response(
duplicate.data,
status=status.HTTP_201_CREATED,
headers=headers
)
else:
headers = self.get_success_headers(serializer.data)
return Response(
new_returned,
status=status.HTTP_201_CREATED,
headers=headers
)
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))
