def test_validate_form_against_field_choices(self):
self.table.field_set.filter(name__in=["uf", "city"]).update(
frontend_filter=True)
uf_field = self.table.get_field("uf")
uf_field.has_choices = True
uf_field.choices = {"data": ["RJ", "SP", "MG"]}
uf_field.save()
city_field = self.table.get_field("city")
city_field.has_choices = True
city_field.choices = {
"data": ["Rio de Janeiro", "São Pauyo", "Belo Horizonte"]
}
city_field.save()
# valid form
DynamicFormClasss = get_table_dynamic_form(self.table, cache=False)
form = DynamicFormClasss(data={"uf": "RJ", "city": "Rio de Janeiro"})
assert isinstance(form.fields["uf"], ChoiceField)
assert isinstance(form.fields["city"], ChoiceField)
assert form.is_valid()
assert {"uf": "RJ", "city": "Rio de Janeiro"} == form.cleaned_data
# invalid form
DynamicFormClasss = get_table_dynamic_form(self.table, cache=False)
form = DynamicFormClasss(data={"uf": "XXX", "city": "Rio de Janeiro"})
assert not form.is_valid()
assert "uf" in form.errors
assert "city" not in form.errors
assert {"city": "Rio de Janeiro"} == form.cleaned_data
def test_filter_form_does_not_invalidate_if_no_data(self):
self.table.field_set.filter(name__in=["uf", "city"]).update(
frontend_filter=True)
DynamicFormClasss = get_table_dynamic_form(self.table, cache=False)
form = DynamicFormClasss(data={})
assert form.is_valid()
assert {"uf": "", "city": ""} == form.cleaned_data
def test_generate_form_based_in_table_filtering(self):
self.table.field_set.filter(name__in=["uf", "city"]).update(
frontend_filter=True)
DynamicFormClasss = get_table_dynamic_form(self.table, cache=False)
form = DynamicFormClasss()
assert "uf" in form.fields
assert "city" in form.fields
assert isinstance(form.fields["uf"],
type(self.get_model_field("uf").formfield()))
assert isinstance(form.fields["city"],
type(self.get_model_field("city").formfield()))
def get_queryset(self):
querystring = self.request.query_params.copy()
for pagination_key in ("limit", "offset"):
if pagination_key in querystring:
del querystring[pagination_key]
Model = self.get_model_class()
query, search_query, order_by = parse_querystring(querystring)
DynamicForm = get_table_dynamic_form(self.get_table())
filter_form = DynamicForm(data=query)
if filter_form.is_valid():
query = {
k: v
for k, v in filter_form.cleaned_data.items() if v != ""
}
else:
raise InvalidFiltersException(filter_form.errors)
return Model.objects.composed_query(query, search_query, order_by)
def test_none_value_should_display_vazio(self):
self.table.field_set.filter(name__in=["uf"]).update(
frontend_filter=True)
uf_field = self.table.get_field("uf")
uf_field.has_choices = True
uf_field.choices = {"data": ["RJ", "SP", "MG", "None"]}
uf_field.save()
expected = [
("", "Todos"),
("RJ", "RJ"),
("SP", "SP"),
("MG", "MG"),
("None", "(vazio)"),
]
# valid form
DynamicFormClasss = get_table_dynamic_form(self.table, cache=False)
assert sorted(expected) == sorted(
DynamicFormClasss().fields["uf"].choices)
def test_choice_failback_to_default_type_if_has_choice_field_but_no_data(
self):
self.table.field_set.filter(name__in=["uf", "city"]).update(
frontend_filter=True)
uf_field = self.table.get_field("uf")
uf_field.has_choices = True
uf_field.save()
city_field = self.table.get_field("city")
city_field.has_choices = True
city_field.save()
DynamicFormClasss = get_table_dynamic_form(self.table, cache=False)
form = DynamicFormClasss()
assert "uf" in form.fields
assert "city" in form.fields
assert isinstance(form.fields["uf"],
type(self.get_model_field("uf").formfield()))
assert isinstance(form.fields["city"],
type(self.get_model_field("city").formfield()))
def dataset_detail(request, slug, tablename=""):
if len(request.GET) > 0 and not request.user.is_authenticated:
return redirect(f"{settings.LOGIN_URL}?next={request.get_full_path()}")
try:
dataset = Dataset.objects.get(slug=slug)
except Dataset.DoesNotExist:
context = {"message": "Dataset does not exist"}
return render(request, "404.html", context, status=404)
if not tablename:
tablename = dataset.get_default_table().name
return redirect(
reverse(
"core:dataset-table-detail",
kwargs={
"slug": slug,
"tablename": tablename
},
))
try:
allow_hidden = request.user.is_superuser
table = dataset.get_table(tablename, allow_hidden=allow_hidden)
except Table.DoesNotExist:
context = {"message": "Table does not exist"}
try:
# log 404 request only if hidden table exist
hidden_table = dataset.get_table(tablename, allow_hidden=True)
if hidden_table:
log_blocked_request(request, 404)
except Table.DoesNotExist:
pass
return render(request, "404.html", context, status=404)
querystring = request.GET.copy()
page_number = querystring.pop("page", ["1"])[0].strip() or "1"
items_per_page = querystring.pop("items", [str(
settings.ROWS_PER_PAGE)])[0].strip() or str(settings.ROWS_PER_PAGE)
download_csv = querystring.pop("format", [""]) == ["csv"]
try:
page = int(page_number)
except ValueError:
context = {"message": "Invalid page number."}
return render(request, "404.html", context, status=404)
try:
items_per_page = int(items_per_page)
except ValueError:
context = {"message": "Invalid items per page."}
return render(request, "404.html", context, status=404)
items_per_page = min(items_per_page, 1000)
version = dataset.version_set.order_by("-order").first()
TableModel = table.get_model()
query, search_query, order_by = parse_querystring(querystring)
DynamicForm = get_table_dynamic_form(table)
filter_form = DynamicForm(data=query)
if filter_form.is_valid():
query = {k: v for k, v in filter_form.cleaned_data.items() if v != ""}
else:
query = {}
all_data = TableModel.objects.composed_query(query, search_query, order_by)
if download_csv:
user_agent = request.headers.get("User-Agent", "")
block_agent = any(True for agent in settings.BLOCKED_AGENTS
if agent.lower() in user_agent.lower())
if not any([query, search_query]) or not user_agent or block_agent:
# User trying to download a CSV without custom filters or invalid
# user-agent specified.
context = {
"html_code_snippet": "core/400-csv-without-filters.html",
"download_url": dataset.files_url,
}
return render(request, "4xx.html", context, status=400)
if all_data.count() > settings.CSV_EXPORT_MAX_ROWS:
context = {
"message": "Max rows exceeded.",
"title_4xx": "Oops! Ocorreu um erro:"
}
return render(request, "4xx.html", context, status=400)
filename = "{}-{}.csv".format(slug, uuid.uuid4().hex)
pseudo_buffer = Echo()
writer = csv.writer(pseudo_buffer, dialect=csv.excel)
csv_rows = queryset_to_csv(all_data, table.fields)
response = StreamingHttpResponse(
(writer.writerow(row) for row in csv_rows),
content_type="text/csv;charset=UTF-8",
)
response["Content-Disposition"] = 'attachment; filename="{}"'.format(
filename)
response.encoding = "UTF-8"
return response
paginator = Paginator(all_data, items_per_page)
data = paginator.get_page(page)
for key, value in list(querystring.items()):
if not value:
del querystring[key]
context = {
"data": data,
"dataset": dataset,
"filter_form": filter_form,
"max_export_rows": settings.CSV_EXPORT_MAX_ROWS,
"search_term": querystring.get("search", ""),
"querystring": querystring.urlencode(),
"slug": slug,
"table": table,
"total_count": all_data.count(),
"version": version,
}
status = 200
if filter_form.errors:
status = 400
return render(request, "core/dataset-detail.html", context, status=status)
def test_table_without_filters_gets_empty_form(self):
DynamicFormClasss = get_table_dynamic_form(self.table, cache=False)
form = DynamicFormClasss()
assert 0 == len(form.fields)
