def get_type(self, instance):
# It could be that the view related to the instance is already in the context
# else we can call the specific_class property to find it.
view = self.context.get('instance_type')
if not view:
view = view_type_registry.get_by_model(instance.specific_class)
return view.type
def export_serialized(self, database):
"""
Exports the database application type to a serialized format that can later be
be imported via the `import_serialized`.
"""
tables = database.table_set.all().prefetch_related(
'field_set',
'view_set',
'view_set__viewfilter_set',
'view_set__viewsort_set'
)
serialized_tables = []
for table in tables:
fields = table.field_set.all()
serialized_fields = []
for f in fields:
field = f.specific
field_type = field_type_registry.get_by_model(field)
serialized_fields.append(field_type.export_serialized(field))
serialized_views = []
for v in table.view_set.all():
view = v.specific
view_type = view_type_registry.get_by_model(view)
serialized_views.append(view_type.export_serialized(view))
model = table.get_model(fields=fields)
serialized_rows = []
table_cache = {}
for row in model.objects.all():
serialized_row = {
'id': row.id,
'order': str(row.order)
}
for field_object in model._field_objects.values():
field_name = field_object['name']
field_type = field_object['type']
serialized_row[field_name] = field_type.get_export_serialized_value(
row,
field_name,
table_cache
)
serialized_rows.append(serialized_row)
serialized_tables.append({
'id': table.id,
'name': table.name,
'order': table.order,
'fields': serialized_fields,
'views': serialized_views,
'rows': serialized_rows,
})
serialized = super().export_serialized(database)
serialized['tables'] = serialized_tables
return serialized
def export_serialized(self, database, files_zip, storage):
"""
Exports the database application type to a serialized format that can later be
be imported via the `import_serialized`.
"""
tables = database.table_set.all().prefetch_related(
"field_set",
"view_set",
"view_set__viewfilter_set",
"view_set__viewsort_set",
)
serialized_tables = []
for table in tables:
fields = table.field_set.all()
serialized_fields = []
for f in fields:
field = f.specific
field_type = field_type_registry.get_by_model(field)
serialized_fields.append(field_type.export_serialized(field))
serialized_views = []
for v in table.view_set.all():
view = v.specific
view_type = view_type_registry.get_by_model(view)
serialized_views.append(view_type.export_serialized(view))
model = table.get_model(fields=fields)
serialized_rows = []
table_cache = {}
for row in model.objects.all():
serialized_row = {"id": row.id, "order": str(row.order)}
for field_object in model._field_objects.values():
field_name = field_object["name"]
field_type = field_object["type"]
serialized_row[
field_name] = field_type.get_export_serialized_value(
row, field_name, table_cache, files_zip, storage)
serialized_rows.append(serialized_row)
serialized_tables.append({
"id": table.id,
"name": table.name,
"order": table.order,
"fields": serialized_fields,
"views": serialized_views,
"rows": serialized_rows,
})
serialized = super().export_serialized(database, files_zip, storage)
serialized["tables"] = serialized_tables
return serialized
def patch(self, request, view_id):
"""Updates the view if the user belongs to the group."""
view = ViewHandler().get_view(request.user, view_id).specific
view_type = view_type_registry.get_by_model(view)
data = validate_data_custom_fields(
view_type.type, view_type_registry, request.data,
base_serializer_class=UpdateViewSerializer
)
view = ViewHandler().update_view(request.user, view, **data)
serializer = view_type_registry.get_serializer(view, ViewSerializer)
return Response(serializer.data)
def for_view(cls, view) -> "QuerysetSerializer":
"""
Generates a queryset serializer for the provided view according to it's view
type and any relevant view settings it might have (filters, sorts,
hidden columns etc).
:param view: The view to serialize.
:return: A QuerysetSerializer ready to serialize the table.
"""
view_type = view_type_registry.get_by_model(view.specific_class)
fields, model = view_type.get_fields_and_model(view)
qs = ViewHandler().get_queryset(view, model=model)
return cls(qs, fields)
def _raise_if_invalid_view_or_table_for_exporter(exporter_type: str,
view: Optional[View]):
"""
Raises an exception if the exporter_type does not support the provided view,
or if no view is provided raises if the exporter does not support exporting just the
table.
:param exporter_type: The exporter type to check.
:param view: None if we are exporting just the table, otherwise the view we are
exporting.
"""
exporter = table_exporter_registry.get(exporter_type)
if not exporter.can_export_table and view is None:
raise TableOnlyExportUnsupported()
if view is not None:
view_type = view_type_registry.get_by_model(view.specific_class)
if view_type.type not in exporter.supported_views:
raise ViewUnsupportedForExporterType()
