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 = [{"title": f.name, "required": f.required} for f in schema.fields]
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)
kwargs['upload_spreadsheet_form'] = UploadSpreadsheetForm()
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"] = 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()
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'] = CommunicationsLogEntryForm(to=to.get_full_name(), fromm=self.request.user.get_full_name())
return super(CurateReturnView, 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 _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_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_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 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'))
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'] = 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 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 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 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 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')))
validated_rows = list(schema.rows_validator(table_data.rows_by_col_header_it()))
table['data'] = validated_rows
else:
messages.warning(request, 'Missing worksheet ' + table.get('name'))
finally:
shutil.rmtree(temp_file_dir)
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')))
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 _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')))
validated_rows = list(schema.rows_validator(table_data.rows_by_col_header_it()))
table['data'] = validated_rows
else:
messages.warning(request, 'Missing worksheet ' + table.get('name'))
finally:
shutil.rmtree(temp_file_dir)
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)
ret.lodgement_number = '%s-%s' % (str(ret.licence.licence_type.pk).zfill(LICENCE_TYPE_NUM_CHARS),
str(ret.pk).zfill(LODGEMENT_NUMBER_NUM_CHARS))
ret.lodgement_date = date.today()
if is_officer(request.user):
ret.proxy_customer = request.user
ret.status = 'submitted'
ret.save()
message = 'Return successfully submitted.'
# update next return in line's status to become the new current return
next_ret = Return.objects.filter(licence=ret.licence, status='future').order_by('due_date').first()
if next_ret is not None:
next_ret.status = 'current'
next_ret.save()
message += ' The next return for this licence can now be entered and is due on {}.'.\
format(next_ret.due_date.strftime(DATE_FORMAT))
return_submitted.send(sender=self.__class__, ret=ret)
messages.success(request, message)
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 {}".format(table.get('name')))
return render(request, self.template_name, context)
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 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())
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"))
)
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)
class TestLatLongEastingNorthingCase(TestCase):
"""
Test the conditional requirement between long/lat and easting/northing.
One or the other must be required.
"""
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_lat_long_only(self):
"""
Lat/Long + datum should not generate an error
:return:
"""
data = {
"DATUM": "WGS84",
"LATITUDE": -32,
"LONGITUDE": 116,
"EASTING": None,
"NORTHING": None,
"ZONE": None
}
self.assertTrue(self.schema.is_row_valid(data))
# datum always required
data = {
"DATUM": None,
"LATITUDE": -32,
"LONGITUDE": 116,
"EASTING": None,
"NORTHING": None,
"ZONE": None
}
self.assertFalse(self.schema.is_row_valid(data))
errors = self.schema.get_error_fields(data)
self.assertEqual(len(errors), 1)
self.assertEqual('DATUM', errors[0][0])
def test_east_north_only(self):
"""
Northing/Easting + Datum + Zone should be valid
:return:
"""
data = {
"DATUM": "WGS84",
"LATITUDE": None,
"LONGITUDE": None,
"EASTING": 123456,
"NORTHING": 654321,
"ZONE": 50
}
self.assertTrue(self.schema.is_row_valid(data))
# datum always required
data = {
"DATUM": None,
"LATITUDE": None,
"LONGITUDE": None,
"EASTING": 123456,
"NORTHING": 654321,
"ZONE": 50
}
self.assertFalse(self.schema.is_row_valid(data))
errors = self.schema.get_error_fields(data)
self.assertEqual(len(errors), 1)
self.assertEqual('DATUM', errors[0][0])
# ZONE always required
data = {
"DATUM": "WGS84",
"LATITUDE": None,
"LONGITUDE": None,
"EASTING": 123456,
"NORTHING": 654321,
"ZONE": ''
}
self.assertFalse(self.schema.is_row_valid(data))
errors = self.schema.get_error_fields(data)
self.assertEqual(len(errors), 1)
self.assertEqual('ZONE', errors[0][0])
def test_no_lat_long_and_no_east_north(self):
data = {
"DATUM": "WGS84",
"LATITUDE": '',
"LONGITUDE": '',
"EASTING": None,
"NORTHING": None,
"ZONE": 50
}
self.assertFalse(self.schema.is_row_valid(data))
error_fields = [e[0] for e in self.schema.get_error_fields(data)]
self.assertTrue('LATITUDE' in error_fields)
self.assertTrue('LONGITUDE' in error_fields)
self.assertTrue('EASTING' in error_fields)
self.assertTrue('NORTHING' in error_fields)
def test_half_baked_data(self):
"""
Missing either lat or long ot east or north
:return:
"""
data = {
"DATUM": "WGS84",
"LATITUDE": -32,
"LONGITUDE": None,
"EASTING": None,
"NORTHING": None,
"ZONE": 50
}
self.assertFalse(self.schema.is_row_valid(data))
error_fields = [e[0] for e in self.schema.get_error_fields(data)]
self.assertFalse('LATITUDE' in error_fields)
self.assertTrue('NORTHING' in error_fields)
self.assertTrue('LONGITUDE' in error_fields)
self.assertTrue('EASTING' in error_fields)
data = {
"DATUM": "WGS84",
"LATITUDE": None,
"LONGITUDE": 115,
"EASTING": None,
"NORTHING": None,
"ZONE": 50
}
self.assertFalse(self.schema.is_row_valid(data))
error_fields = [e[0] for e in self.schema.get_error_fields(data)]
self.assertFalse('LONGITUDE' in error_fields)
self.assertTrue('EASTING' in error_fields)
self.assertTrue('LATITUDE' in error_fields)
self.assertTrue('NORTHING' in error_fields)
data = {
"DATUM": "WGS84",
"LATITUDE": None,
"LONGITUDE": None,
"EASTING": 123456,
"NORTHING": None,
"ZONE": 50
}
self.assertFalse(self.schema.is_row_valid(data))
error_fields = [e[0] for e in self.schema.get_error_fields(data)]
self.assertTrue('LONGITUDE' in error_fields)
self.assertFalse('EASTING' in error_fields)
self.assertTrue('LATITUDE' in error_fields)
self.assertTrue('NORTHING' in error_fields)
data = {
"DATUM": "WGS84",
"LATITUDE": None,
"LONGITUDE": None,
"EASTING": None,
"NORTHING": 645321,
"ZONE": 50
}
self.assertFalse(self.schema.is_row_valid(data))
error_fields = [e[0] for e in self.schema.get_error_fields(data)]
self.assertFalse('NORTHING' in error_fields)
self.assertTrue('LATITUDE' in error_fields)
self.assertTrue('LONGITUDE' in error_fields)
self.assertTrue('EASTING' in error_fields)
def test_mixed_data(self):
"""
Test that data that mixed lat/long and noth/east are not valid
E.g provide lat but not long and provide easting but not northing
:return:
"""
data = {
"DATUM": "WGS84",
"LATITUDE": -32,
"LONGITUDE": None,
"EASTING": 12345,
"NORTHING": None,
"ZONE": 50
}
self.assertFalse(self.schema.is_row_valid(data))
error_fields = [e[0] for e in self.schema.get_error_fields(data)]
self.assertFalse('LATITUDE' in error_fields)
self.assertFalse('EASTING' in error_fields)
self.assertTrue('LONGITUDE' in error_fields)
self.assertTrue('NORTHING' in error_fields)
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 test_no_species(self):
descriptor = clone(helpers.GENERIC_SCHEMA)
sch = Schema(descriptor)
# no species field
self.assertFalse(sch.species_fields)
class TestLatLongEastingNorthingCase(TestCase):
"""
Test the conditional requirement between long/lat and easting/northing.
One or the other must be required.
"""
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_lat_long_only(self):
"""
Lat/Long + datum should not generate an error
:return:
"""
data = {
"DATUM": "WGS84",
"LATITUDE": -32,
"LONGITUDE": 116,
"EASTING": None,
"NORTHING": None,
"ZONE": None
}
self.assertTrue(self.schema.is_row_valid(data))
# datum always required
data = {
"DATUM": None,
"LATITUDE": -32,
"LONGITUDE": 116,
"EASTING": None,
"NORTHING": None,
"ZONE": None
}
self.assertFalse(self.schema.is_row_valid(data))
errors = self.schema.get_error_fields(data)
self.assertEqual(len(errors), 1)
self.assertEqual('DATUM', errors[0][0])
def test_east_north_only(self):
"""
Northing/Easting + Datum + Zone should be valid
:return:
"""
data = {
"DATUM": "WGS84",
"LATITUDE": None,
"LONGITUDE": None,
"EASTING": 123456,
"NORTHING": 654321,
"ZONE": 50
}
self.assertTrue(self.schema.is_row_valid(data))
# datum always required
data = {
"DATUM": None,
"LATITUDE": None,
"LONGITUDE": None,
"EASTING": 123456,
"NORTHING": 654321,
"ZONE": 50
}
self.assertFalse(self.schema.is_row_valid(data))
errors = self.schema.get_error_fields(data)
self.assertEqual(len(errors), 1)
self.assertEqual('DATUM', errors[0][0])
# ZONE always required
data = {
"DATUM": "WGS84",
"LATITUDE": None,
"LONGITUDE": None,
"EASTING": 123456,
"NORTHING": 654321,
"ZONE": ''
}
self.assertFalse(self.schema.is_row_valid(data))
errors = self.schema.get_error_fields(data)
self.assertEqual(len(errors), 1)
self.assertEqual('ZONE', errors[0][0])
def test_no_lat_long_and_no_east_north(self):
data = {
"DATUM": "WGS84",
"LATITUDE": '',
"LONGITUDE": '',
"EASTING": None,
"NORTHING": None,
"ZONE": 50
}
self.assertFalse(self.schema.is_row_valid(data))
error_fields = [e[0] for e in self.schema.get_error_fields(data)]
self.assertTrue('LATITUDE' in error_fields)
self.assertTrue('LONGITUDE' in error_fields)
self.assertTrue('EASTING' in error_fields)
self.assertTrue('NORTHING' in error_fields)
def test_half_baked_data(self):
"""
Missing either lat or long ot east or north
:return:
"""
data = {
"DATUM": "WGS84",
"LATITUDE": -32,
"LONGITUDE": None,
"EASTING": None,
"NORTHING": None,
"ZONE": 50
}
self.assertFalse(self.schema.is_row_valid(data))
error_fields = [e[0] for e in self.schema.get_error_fields(data)]
self.assertFalse('LATITUDE' in error_fields)
self.assertTrue('NORTHING' in error_fields)
self.assertTrue('LONGITUDE' in error_fields)
self.assertTrue('EASTING' in error_fields)
data = {
"DATUM": "WGS84",
"LATITUDE": None,
"LONGITUDE": 115,
"EASTING": None,
"NORTHING": None,
"ZONE": 50
}
self.assertFalse(self.schema.is_row_valid(data))
error_fields = [e[0] for e in self.schema.get_error_fields(data)]
self.assertFalse('LONGITUDE' in error_fields)
self.assertTrue('EASTING' in error_fields)
self.assertTrue('LATITUDE' in error_fields)
self.assertTrue('NORTHING' in error_fields)
data = {
"DATUM": "WGS84",
"LATITUDE": None,
"LONGITUDE": None,
"EASTING": 123456,
"NORTHING": None,
"ZONE": 50
}
self.assertFalse(self.schema.is_row_valid(data))
error_fields = [e[0] for e in self.schema.get_error_fields(data)]
self.assertTrue('LONGITUDE' in error_fields)
self.assertFalse('EASTING' in error_fields)
self.assertTrue('LATITUDE' in error_fields)
self.assertTrue('NORTHING' in error_fields)
data = {
"DATUM": "WGS84",
"LATITUDE": None,
"LONGITUDE": None,
"EASTING": None,
"NORTHING": 645321,
"ZONE": 50
}
self.assertFalse(self.schema.is_row_valid(data))
error_fields = [e[0] for e in self.schema.get_error_fields(data)]
self.assertFalse('NORTHING' in error_fields)
self.assertTrue('LATITUDE' in error_fields)
self.assertTrue('LONGITUDE' in error_fields)
self.assertTrue('EASTING' in error_fields)
def test_mixed_data(self):
"""
Test that data that mixed lat/long and noth/east are not valid
E.g provide lat but not long and provide easting but not northing
:return:
"""
data = {
"DATUM": "WGS84",
"LATITUDE": -32,
"LONGITUDE": None,
"EASTING": 12345,
"NORTHING": None,
"ZONE": 50
}
self.assertFalse(self.schema.is_row_valid(data))
error_fields = [e[0] for e in self.schema.get_error_fields(data)]
self.assertFalse('LATITUDE' in error_fields)
self.assertFalse('EASTING' in error_fields)
self.assertTrue('LONGITUDE' in error_fields)
self.assertTrue('NORTHING' in error_fields)
