def delete(self, request, table_id):
"""Deletes an existing table."""
TableHandler().delete_table(
request.user,
TableHandler().get_table(request.user, table_id))
return Response(status=204)
def post(self, request, table_id):
"""
Creates a new row for the given table_id. Also the post data is validated
according to the tables field types.
"""
table = TableHandler().get_table(table_id)
TokenHandler().check_table_permissions(request, 'create', table, False)
model = table.get_model()
validation_serializer = get_row_serializer_class(model)
data = validate_data(validation_serializer, request.data)
before_id = request.GET.get('before')
before = (RowHandler().get_row(request.user, table, before_id, model)
if before_id else None)
row = RowHandler().create_row(request.user,
table,
data,
model,
before=before)
serializer_class = get_row_serializer_class(model,
RowSerializer,
is_response=True)
serializer = serializer_class(row)
return Response(serializer.data)
def get(self, request, table_id):
"""
Lists all the rows of the given table id paginated. It is also possible to
provide a search query.
"""
table = TableHandler().get_table(request.user, table_id)
TokenHandler().check_table_permissions(request, 'read', table, False)
model = table.get_model()
search = request.GET.get('search')
order_by = request.GET.get('order_by')
queryset = model.objects.all().enhance_by_fields().order_by('id')
if search:
queryset = queryset.search_all_fields(search)
if order_by:
queryset = queryset.order_by_fields_string(order_by)
paginator = PageNumberPagination(
limit_page_size=settings.ROW_PAGE_SIZE_LIMIT)
page = paginator.paginate_queryset(queryset, request, self)
serializer_class = get_row_serializer_class(model,
RowSerializer,
is_response=True)
serializer = serializer_class(page, many=True)
return paginator.get_paginated_response(serializer.data)
def patch(self, request, table_id, row_id):
"""
Updates the row with the given row_id for the table with the given
table_id. Also the post data is validated according to the tables field types.
"""
table = TableHandler().get_table(request.user, table_id)
TokenHandler().check_table_permissions(request, 'update', table, False)
# Small side effect of generating the model for only the fields that need to
# change is that the response it not going to contain the other fields. It is
# however much faster because it doesn't need to get the specific version of
# all the field objects.
field_ids = RowHandler().extract_field_ids_from_dict(request.data)
model = table.get_model(field_ids=field_ids)
validation_serializer = get_row_serializer_class(model)
data = validate_data(validation_serializer, request.data)
row = RowHandler().update_row(request.user, table, row_id, data, model)
serializer_class = get_row_serializer_class(model,
RowSerializer,
is_response=True)
serializer = serializer_class(row)
return Response(serializer.data)
def patch(self, request, data, table_id):
"""Updates the values a table instance."""
table = TableHandler().update_table(request.user,
TableHandler().get_table(
request.user, table_id),
name=data['name'])
serializer = TableSerializer(table)
return Response(serializer.data)
def patch(self, request, data, table_id):
"""Updates the values a table instance."""
table = TableHandler().update_table(
request.user,
TableHandler().get_table(table_id),
base_queryset=Table.objects.select_for_update(),
name=data['name'])
serializer = TableSerializer(table)
return Response(serializer.data)
def test_fill_example_table_data(data_fixture):
user = data_fixture.create_user()
database = data_fixture.create_database_application(user=user)
table_handler = TableHandler()
table_handler.create_table(user, database, fill_example=True, name='Table 1')
assert Table.objects.all().count() == 1
assert GridView.objects.all().count() == 1
assert TextField.objects.all().count() == 1
assert LongTextField.objects.all().count() == 1
assert BooleanField.objects.all().count() == 1
assert GridViewFieldOptions.objects.all().count() == 2
def get(self, request, table_id, filters, sortings):
"""
Responds with a list of serialized views that belong to the table if the user
has access to that group.
"""
table = TableHandler().get_table(table_id)
table.database.group.has_user(
request.user, raise_error=True, allow_if_template=True
)
views = View.objects.filter(table=table).select_related("content_type")
if filters:
views = views.prefetch_related("viewfilter_set")
if sortings:
views = views.prefetch_related("viewsort_set")
data = [
view_type_registry.get_serializer(
view, ViewSerializer, filters=filters, sortings=sortings
).data
for view in views
]
return Response(data)
def can_add(self, user, web_socket_id, table_id, **kwargs):
"""
The user should only have access to this page if the table exists and if he
has access to the table.
"""
if not table_id:
return False
try:
handler = TableHandler()
handler.get_table(user, table_id)
except (UserNotInGroupError, TableDoesNotExist):
return False
return True
def get(self, request, table_id):
"""Responds with a serialized table instance."""
table = TableHandler().get_table(table_id)
table.database.group.has_user(request.user, raise_error=True)
serializer = TableSerializer(table)
return Response(serializer.data)
def get(self, request, table_id, filters, sortings):
"""
Responds with a list of serialized views that belong to the table if the user
has access to that group.
"""
table = TableHandler().get_table(request.user, table_id)
views = View.objects.filter(table=table).select_related('content_type')
if filters:
views = views.prefetch_related('viewfilter_set')
if sortings:
views = views.prefetch_related('viewsort_set')
data = [
view_type_registry.get_serializer(
view,
ViewSerializer,
filters=filters,
sortings=sortings
).data
for view in views
]
return Response(data)
def post(self, request, data, database_id):
"""Updates to order of the tables in a table."""
database = CoreHandler().get_application(
database_id, base_queryset=Database.objects)
TableHandler().order_tables(request.user, database, data["table_ids"])
return Response(status=204)
def can_add(self, user, web_socket_id, table_id, **kwargs):
"""
The user should only have access to this page if the table exists and if he
has access to the table.
"""
if not table_id:
return False
try:
handler = TableHandler()
table = handler.get_table(table_id)
table.database.group.has_user(user, raise_error=True)
except (UserNotInGroup, TableDoesNotExist):
return False
return True
def post(self, request, table_id):
"""
Creates a new row for the given table_id. Also the post data is validated
according to the tables field types.
"""
table = TableHandler().get_table(request.user, table_id)
model = table.get_model()
validation_serializer = get_row_serializer_class(model)
data = validate_data(validation_serializer, request.data)
row = RowHandler().create_row(request.user, table, data, model)
serializer_class = get_row_serializer_class(model, RowSerializer)
serializer = serializer_class(row)
return Response(serializer.data)
def get(self, request, table_id, row_id):
"""
Responds with a serializer version of the row related to the provided row_id
and table_id.
"""
table = TableHandler().get_table(table_id)
TokenHandler().check_table_permissions(request, 'read', table, False)
model = table.get_model()
row = RowHandler().get_row(request.user, table, row_id, model)
serializer_class = get_row_serializer_class(model,
RowSerializer,
is_response=True)
serializer = serializer_class(row)
return Response(serializer.data)
def get(self, request, table_id):
"""
Lists all the rows of the given table id paginated. It is also possible to
provide a search query.
"""
table = TableHandler().get_table(table_id)
table.database.group.has_user(request.user, raise_error=True)
TokenHandler().check_table_permissions(request, 'read', table, False)
search = request.GET.get('search')
order_by = request.GET.get('order_by')
include = request.GET.get('include')
exclude = request.GET.get('exclude')
fields = RowHandler().get_include_exclude_fields(
table, include, exclude)
model = table.get_model(fields=fields,
field_ids=[] if fields else None)
queryset = model.objects.all().enhance_by_fields()
if search:
queryset = queryset.search_all_fields(search)
if order_by:
queryset = queryset.order_by_fields_string(order_by)
filter_type = (FILTER_TYPE_OR
if str(request.GET.get('filter_type')).upper() == 'OR'
else FILTER_TYPE_AND)
filter_object = {
key: request.GET.getlist(key)
for key in request.GET.keys()
}
queryset = queryset.filter_by_fields_object(filter_object, filter_type)
paginator = PageNumberPagination(
limit_page_size=settings.ROW_PAGE_SIZE_LIMIT)
page = paginator.paginate_queryset(queryset, request, self)
serializer_class = get_row_serializer_class(model,
RowSerializer,
is_response=True)
serializer = serializer_class(page, many=True)
return paginator.get_paginated_response(serializer.data)
def post(self, request, data, table_id):
"""Creates a new view for a user."""
table = TableHandler().get_table(request.user, table_id)
view = ViewHandler().create_view(
request.user, table, data.pop('type'), **data)
serializer = view_type_registry.get_serializer(view, ViewSerializer)
return Response(serializer.data)
def delete(self, request, table_id, row_id):
"""
Deletes an existing row with the given row_id for table with the given table_id.
"""
table = TableHandler().get_table(request.user, table_id)
RowHandler().delete_row(request.user, table, row_id)
return Response(status=204)
def post(self, request, data, table_id):
"""Creates a new field for a table."""
type_name = data.pop('type')
table = TableHandler().get_table(request.user, table_id)
field = FieldHandler().create_field(request.user, table, type_name,
**data)
serializer = field_type_registry.get_serializer(field, FieldSerializer)
return Response(serializer.data)
def post(self, request, data, table_id, filters, sortings):
"""Creates a new view for a user."""
table = TableHandler().get_table(table_id)
view = ViewHandler().create_view(request.user, table, data.pop("type"), **data)
serializer = view_type_registry.get_serializer(
view, ViewSerializer, filters=filters, sortings=sortings
)
return Response(serializer.data)
def test_table_updated(mock_broadcast_to_group, data_fixture):
user = data_fixture.create_user()
table = data_fixture.create_database_table(user=user)
table = TableHandler().update_table(user=user, table=table, name="Test")
mock_broadcast_to_group.delay.assert_called_once()
args = mock_broadcast_to_group.delay.call_args
assert args[0][0] == table.database.group_id
assert args[0][1]["type"] == "table_updated"
assert args[0][1]["table_id"] == table.id
assert args[0][1]["table"]["id"] == table.id
def post(self, request, data, database_id):
"""Creates a new table in a database."""
database = CoreHandler().get_application(
request.user, database_id, base_queryset=Database.objects)
table = TableHandler().create_table(request.user,
database,
fill_initial=True,
name=data['name'])
serializer = TableSerializer(table)
return Response(serializer.data)
def test_table_updated(mock_broadcast_to_group, data_fixture):
user = data_fixture.create_user()
table = data_fixture.create_database_table(user=user)
table = TableHandler().update_table(user=user, table=table, name='Test')
mock_broadcast_to_group.delay.assert_called_once()
args = mock_broadcast_to_group.delay.call_args
assert args[0][0] == table.database.group_id
assert args[0][1]['type'] == 'table_updated'
assert args[0][1]['table_id'] == table.id
assert args[0][1]['table']['id'] == table.id
def delete(self, request, table_id, row_id):
"""
Deletes an existing row with the given row_id for table with the given
table_id.
"""
table = TableHandler().get_table(table_id)
TokenHandler().check_table_permissions(request, 'delete', table, False)
RowHandler().delete_row(request.user, table, row_id)
return Response(status=204)
def test_tables_reordered(mock_broadcast_to_channel_group, data_fixture):
user = data_fixture.create_user()
database = data_fixture.create_database_application(user=user)
table = data_fixture.create_database_table(database=database)
TableHandler().order_tables(user=user, database=database, order=[table.id])
mock_broadcast_to_channel_group.delay.assert_called_once()
args = mock_broadcast_to_channel_group.delay.call_args
assert args[0][0] == table.database.group_id
assert args[0][1]["type"] == "tables_reordered"
assert args[0][1]["database_id"] == database.id
assert args[0][1]["order"] == [table.id]
def test_fill_example_table_data(data_fixture):
user = data_fixture.create_user()
database = data_fixture.create_database_application(user=user)
table_handler = TableHandler()
table = table_handler.create_table(user, database, fill_example=True,
name='Table 1')
assert Table.objects.all().count() == 1
assert GridView.objects.all().count() == 1
assert TextField.objects.all().count() == 1
assert LongTextField.objects.all().count() == 1
assert BooleanField.objects.all().count() == 1
assert GridViewFieldOptions.objects.all().count() == 2
model = table.get_model()
results = model.objects.all()
assert len(results) == 2
assert results[0].order == Decimal('1.00000000000000000000')
assert results[1].order == Decimal('2.00000000000000000000')
def test_delete_database_table(send_mock, data_fixture):
user = data_fixture.create_user()
user_2 = data_fixture.create_user()
group = data_fixture.create_group(user=user)
database = data_fixture.create_database_application(group=group)
table = data_fixture.create_database_table(user=user, database=database)
handler = TableHandler()
with pytest.raises(UserNotInGroup):
handler.delete_table(user=user_2, table=table)
assert Table.objects.all().count() == 1
assert f"database_table_{table.id}" in connection.introspection.table_names(
)
table_id = table.id
handler.delete_table(user=user, table=table)
send_mock.assert_called_once()
assert send_mock.call_args[1]["table_id"] == table_id
assert send_mock.call_args[1]["user"].id == user.id
assert Table.objects.all().count() == 0
assert f"database_table_{table.id}" not in connection.introspection.table_names(
)
def test_table_deleted(mock_broadcast_to_users, data_fixture):
user = data_fixture.create_user()
table = data_fixture.create_database_table(user=user)
table_id = table.id
database_id = table.database_id
TableHandler().delete_table(user=user, table=table)
mock_broadcast_to_users.delay.assert_called_once()
args = mock_broadcast_to_users.delay.call_args
assert args[0][0] == table.database.group_id
assert args[0][1]["type"] == "table_deleted"
assert args[0][1]["database_id"] == database_id
assert args[0][1]["table_id"] == table_id
def patch(self, request, table_id, row_id):
"""
Updates the row with the given row_id for the table with the given
table_id. Also the post data is validated according to the tables field types.
"""
table = TableHandler().get_table(table_id)
TokenHandler().check_table_permissions(request, "update", table, False)
field_ids = RowHandler().extract_field_ids_from_dict(request.data)
model = table.get_model()
validation_serializer = get_row_serializer_class(model, field_ids=field_ids)
data = validate_data(validation_serializer, request.data)
row = RowHandler().update_row(request.user, table, row_id, data, model)
serializer_class = get_row_serializer_class(
model, RowSerializer, is_response=True
)
serializer = serializer_class(row)
return Response(serializer.data)
def patch(self, request, table_id, row_id):
"""Moves the row to another position."""
table = TableHandler().get_table(table_id)
TokenHandler().check_table_permissions(request, "update", table, False)
model = table.get_model()
before_id = request.GET.get("before_id")
before = (
RowHandler().get_row(request.user, table, before_id, model)
if before_id
else None
)
row = RowHandler().move_row(
request.user, table, row_id, before=before, model=model
)
serializer_class = get_row_serializer_class(
model, RowSerializer, is_response=True
)
serializer = serializer_class(row)
return Response(serializer.data)
