mirror of
https://github.com/Southampton-RSG/breccia-mapper.git
synced 2026-03-03 11:27:09 +00:00
127 lines
3.7 KiB
Python
127 lines
3.7 KiB
Python
"""
|
|
Serialize models to and deserialize from JSON.
|
|
"""
|
|
|
|
from collections import OrderedDict
|
|
import typing
|
|
|
|
from rest_framework import serializers
|
|
|
|
from . import models
|
|
|
|
|
|
class FlattenedModelSerializer(serializers.ModelSerializer):
|
|
@classmethod
|
|
def flatten_data(cls, data,
|
|
sub_type: typing.Type = dict,
|
|
sub_value_accessor: typing.Callable = lambda x: x.items()) -> typing.OrderedDict:
|
|
"""
|
|
Flatten a dictionary so that subdictionaries become a series of `key[.subkey[.subsubkey ...]]` entries
|
|
in the top level dictionary.
|
|
|
|
Works for other data structures (e.g. DRF Serializers) by providing suitable values for the
|
|
`sub_type` and `sub_value_accessor` parameters.
|
|
|
|
:param data: Dictionary or other data structure to flatten
|
|
:param sub_type: Type to recursively flatten
|
|
:param sub_value_accessor: Function to access keys and values contained within sub_type.
|
|
"""
|
|
data_out = OrderedDict()
|
|
|
|
for key, value in sub_value_accessor(data):
|
|
if isinstance(value, sub_type):
|
|
# Recursively flatten nested structures of type `sub_type`
|
|
sub_flattened = cls.flatten_data(value,
|
|
sub_type=sub_type,
|
|
sub_value_accessor=sub_value_accessor).items()
|
|
|
|
# Enter recursively flattened values into result dictionary
|
|
for sub_key, sub_value in sub_flattened:
|
|
# Keys in result dictionary are of format `key[.subkey[.subsubkey ...]]`
|
|
data_out[f'{key}.{sub_key}'] = sub_value
|
|
|
|
else:
|
|
data_out[key] = value
|
|
|
|
return data_out
|
|
|
|
@property
|
|
def column_headers(self) -> typing.List[str]:
|
|
"""
|
|
Get all column headers that will be output by this serializer.
|
|
"""
|
|
fields = self.flatten_data(self.fields,
|
|
sub_type=serializers.BaseSerializer,
|
|
sub_value_accessor=lambda x: x.fields.items())
|
|
|
|
return list(fields)
|
|
|
|
def to_representation(self, instance) -> typing.OrderedDict:
|
|
"""
|
|
|
|
"""
|
|
rep = super().to_representation(instance)
|
|
|
|
rep = self.flatten_data(rep)
|
|
|
|
return rep
|
|
|
|
|
|
class PersonSerializer(serializers.ModelSerializer):
|
|
class Meta:
|
|
model = models.Person
|
|
fields = [
|
|
'pk',
|
|
'name',
|
|
]
|
|
|
|
|
|
class PersonExportSerializer(serializers.ModelSerializer):
|
|
class Meta:
|
|
model = models.Person
|
|
fields = [
|
|
'pk',
|
|
'name',
|
|
'core_member',
|
|
'gender',
|
|
'age_group',
|
|
'nationality',
|
|
'country_of_residence',
|
|
]
|
|
|
|
|
|
class RelationshipSerializer(FlattenedModelSerializer):
|
|
source = PersonSerializer()
|
|
target = PersonSerializer()
|
|
|
|
class Meta:
|
|
model = models.Relationship
|
|
fields = [
|
|
'pk',
|
|
'source',
|
|
'target',
|
|
]
|
|
|
|
@property
|
|
def column_headers(self) -> typing.List[str]:
|
|
headers = super().column_headers
|
|
|
|
# Add relationship questions to columns
|
|
for question in models.RelationshipQuestion.objects.all():
|
|
headers.append(question.slug)
|
|
|
|
return headers
|
|
|
|
def to_representation(self, instance):
|
|
rep = super().to_representation(instance)
|
|
|
|
try:
|
|
# Add relationship question answers to data
|
|
for answer in instance.current_answers.question_answers.all():
|
|
rep[answer.question.slug] = answer.slug
|
|
|
|
except AttributeError:
|
|
pass
|
|
|
|
return rep
|