def test_species_by_wl_tag(self):
# adding a wl species tag to a field turns it into a species field (whatever its name)
descriptor = clone(helpers.GENERIC_SCHEMA)
sch = Schema(descriptor)
# no species field
self.assertFalse(sch.species_fields)
# tag
field = descriptor['fields'][0]
field['wl'] = {'type': 'species'}
sch = Schema(descriptor)
self.assertEqual(1, len(sch.species_fields))
self.assertEquals(field['name'], sch.species_fields[0].name)
def get(self, request, *args, **kwargs):
return_type = get_object_or_404(ReturnType,
pk=kwargs.get('return_type_pk'))
# for API purpose, increase the session timeout
set_api_session_timeout(request)
resource_number = kwargs.get('resource_number')
if not resource_number:
resource_number = 0
else:
resource_number = int(resource_number)
all_resources = return_type.resources
if resource_number >= len(all_resources):
raise Http404(
"Invalid resource number {}. The Return Type {} has only {} resources"
.format(resource_number, return_type.licence_type,
len(all_resources)))
resource_name = return_type.get_resources_names()[resource_number]
qs = ReturnRow.objects.filter(return_table__name=resource_name)
schema = Schema(return_type.get_schema_by_name(resource_name))
response = HttpResponse(content_type='text/csv')
file_name = 'wl_returns_{}.csv'.format(resource_name)
response['Content-Disposition'] = 'attachment; filename={}'.format(
file_name)
writer = csv.writer(response)
writer.writerow(schema.headers)
for ret_row in qs:
row = []
for field in schema.field_names:
row.append(
smart_text(ret_row.data.get(field, ''), errors='replace'))
writer.writerow(row)
return response
def get_context_data(self, **kwargs):
ret = get_object_or_404(Return, pk=self.args[0])
kwargs['return'] = ret
kwargs['tables'] = []
for resource in ret.return_type.resources:
resource_name = resource.get('name')
schema = Schema(resource.get('schema'))
table = {
'name': resource_name,
'title': resource.get('title', resource.get('name')),
'headers': schema.headers
}
try:
return_table = ret.returntable_set.get(name=resource_name)
table['data'] = [
return_row.data
for return_row in return_table.returnrow_set.all()
]
except ReturnTable.DoesNotExist:
pass
kwargs['tables'].append(table)
return super(ViewReturnReadonlyView, self).get_context_data(**kwargs)
def _is_post_data_valid(ret, tables_info, post_data):
for table in tables_info:
table_rows = _get_table_rows_from_post(table.get('name'), post_data)
if len(table_rows) == 0:
return False
schema = Schema(ret.return_type.get_schema_by_name(table.get('name')))
if not schema.is_all_valid(table_rows):
return False
return True
def setUp(self):
self.schema_descriptor = {
"fields": [
{
"type": "string",
"name": "DATUM",
"constraints": {
"required": True,
"enum": ["GDA94", "WGS84", "AGD84", "AGD66"]
},
},
{
"type": "number",
"name": "LATITUDE",
"constraints": {
"minimum": -60.0,
"maximum": 0,
"required": True
}
},
{
"type": "number",
"name": "LONGITUDE",
"constraints": {
"minimum": 80.0,
"maximum": 170.0,
"required": True
}
},
{
"type": "number",
"name": "ZONE",
"constraints": {
"required": True,
"enum": [49, 50, 51, 52]
}
},
{
"type": "number",
"name": "EASTING",
"constraints": {
"required": True,
}
},
{
"type": "number",
"name": "NORTHING",
"constraints": {
"required": True,
}
},
]
}
self.schema = Schema(self.schema_descriptor)
self.assertTrue(self.schema.is_lat_long_easting_northing_schema())
def test_species_by_field_name(self):
"""
A previous implementation supported species field detection by just the field name.
Not anymore
:return:
"""
names = [
'species name', 'Species Name', 'SPECIES_NAME', 'species_Name'
]
for name in names:
descriptor = clone(helpers.GENERIC_SCHEMA)
sch = Schema(descriptor)
# no species field
self.assertFalse(sch.species_fields)
# add a field named name
field = clone(BASE_FIELD)
field['name'] = name
descriptor['fields'].append(field)
sch = Schema(descriptor)
self.assertEqual(0, len(sch.species_fields))
def get_context_data(self, **kwargs):
ret = get_object_or_404(Return, pk=self.args[0])
kwargs['return'] = ret
kwargs['tables'] = []
for resource in ret.return_type.resources:
resource_name = resource.get('name')
schema = Schema(resource.get('schema'))
headers = []
for f in schema.fields:
header = {
"title": f.name,
"required": f.required
}
if f.is_species:
header["species"] = f.species_type
headers.append(header)
table = {
'name': resource_name,
'title': resource.get('title', resource.get('name')),
'headers': headers
}
try:
return_table = ret.returntable_set.get(name=resource_name)
rows = [return_row.data for return_row in return_table.returnrow_set.all()]
validated_rows = list(schema.rows_validator(rows))
table['data'] = validated_rows
except ReturnTable.DoesNotExist:
pass
kwargs['tables'].append(table)
if 'upload_spreadsheet_form' not in kwargs:
kwargs['upload_spreadsheet_form'] = UploadSpreadsheetForm()
kwargs['nil_return_form'] = NilReturnForm()
pending_amendments = ret.pending_amendments_qs
if pending_amendments:
kwargs['amendments'] = pending_amendments
return super(EnterReturnView, self).get_context_data(**kwargs)
def get_context_data(self, **kwargs):
ret = get_object_or_404(Return, pk=self.args[0])
kwargs['return'] = serialize(ret, posthook=format_return)
kwargs['tables'] = []
for resource in ret.return_type.resources:
resource_name = resource.get('name')
schema = Schema(resource.get('schema'))
table = {
'name': resource_name,
'title': resource.get('title', resource.get('name')),
'headers': schema.headers
}
try:
return_table = ret.returntable_set.get(name=resource_name)
rows = [
return_row.data
for return_row in return_table.returnrow_set.all()
]
validated_rows = list(schema.rows_validator(rows))
table['data'] = validated_rows
except ReturnTable.DoesNotExist:
pass
kwargs['tables'].append(table)
kwargs['upload_spreadsheet_form'] = UploadSpreadsheetForm()
if ret.proxy_customer is None:
to = ret.licence.holder
else:
to = ret.proxy_customer
kwargs['log_entry_form'] = ReturnsLogEntryForm(
to=to.get_full_name(),
fromm=self.request.user.get_full_name(),
)
return super(CurateReturnView, self).get_context_data(**kwargs)
def _get_validated_rows_from_post(ret, table_name, post_data):
rows = _get_table_rows_from_post(table_name, post_data)
schema = Schema(ret.return_type.get_schema_by_name(table_name))
return list(schema.rows_validator(rows))
def post(self, request, *args, **kwargs):
context = self.get_context_data()
ret = context['return']
if 'upload' in request.POST:
form = UploadSpreadsheetForm(request.POST, request.FILES)
if form.is_valid():
temp_file_dir = tempfile.mkdtemp(dir=settings.MEDIA_ROOT)
try:
data = form.cleaned_data.get('spreadsheet_file')
path = default_storage.save(os.path.join(temp_file_dir, str(data)), ContentFile(data.read()))
workbook = excel.load_workbook_content(path)
for table in context['tables']:
worksheet = excel.get_sheet(workbook, table.get('title')) \
or excel.get_sheet(workbook, table.get('name'))
if worksheet is not None:
table_data = excel.TableData(worksheet)
schema = Schema(ret.return_type.get_schema_by_name(table.get('name')))
excel_rows = list(table_data.rows_by_col_header_it())
has_errors = not schema.is_all_valid(excel_rows)
if has_errors:
messages.error(request, "Your return contains some errors. See below.")
validated_rows = list(schema.rows_validator(excel_rows))
# We want to stringify the datetime/date that might have been created by the excel parser
for vr in validated_rows:
for col, validation in vr.items():
value = validation.get('value')
if isinstance(value, datetime.datetime) or isinstance(value, datetime.date):
validation['value'] = value.strftime(DATE_FORMAT)
table['data'] = validated_rows
else:
messages.warning(request, 'Missing worksheet ' + table.get('name'))
finally:
shutil.rmtree(temp_file_dir)
else:
context['upload_spreadsheet_form'] = form
elif 'draft' in request.POST or 'draft_continue' in request.POST:
_create_return_data_from_post_data(ret, context['tables'], request.POST)
if is_officer(request.user):
ret.proxy_customer = request.user
ret.status = 'draft'
ret.save()
messages.warning(request, 'Return saved as draft.')
# redirect or reshow page depending on whether save or save/continue was clicked
if 'draft' in request.POST:
return redirect('home')
else:
for table in context['tables']:
table['data'] = _get_validated_rows_from_post(ret, table.get('name'), request.POST)
elif 'lodge' in request.POST:
if _is_post_data_valid(ret, context['tables'], request.POST):
_create_return_data_from_post_data(ret, context['tables'], request.POST)
self._set_submitted(ret)
return redirect('home')
else:
for table in context['tables']:
table['data'] = _get_validated_rows_from_post(ret, table.get('name'), request.POST)
if len(table['data']) == 0:
messages.warning(request,
"You must enter data for {} or submit a Nil Return".format(table.get('name')))
else:
messages.error(request,
"Your return contains some errors. See below.")
elif 'nil' in request.POST:
form = NilReturnForm(request.POST)
if form.is_valid():
ret.nil_return = True
ret.comments = form.cleaned_data['comments']
self._set_submitted(ret)
return redirect('home')
return render(request, self.template_name, context)
def test_no_species(self):
descriptor = clone(helpers.GENERIC_SCHEMA)
sch = Schema(descriptor)
# no species field
self.assertFalse(sch.species_fields)
