class ParentCategoryHALSerializer(HALSerializer):
serializer_url_field = CategoryHyperlinkedIdentityField
_display = DisplayField()
sub_categories = CategoryHALSerializer(many=True, source='children')
is_public_accessible = serializers.SerializerMethodField(method_name='get_is_public_accessible')
class Meta:
model = Category
fields = (
'_links',
'_display',
'name',
'slug',
'public_name',
'is_public_accessible',
'sub_categories',
)
def get_is_public_accessible(self, obj):
"""
If there are child categories that are public accessible this should return True OR return the value of
'is_public_accessible' of the ParentCategory
"""
return any([
child_is_public_accessible
for child_is_public_accessible in obj.children.values_list('is_public_accessible', flat=True)
]) or obj.is_public_accessible
class StoredSignalFilterSerializer(HALSerializer):
serializer_url_field = StoredSignalFilterLinksField
_display = DisplayField()
class Meta:
model = StoredSignalFilter
fields = (
'_links',
'_display',
'id',
'name',
'created_at',
'options',
'refresh',
)
def validate(self, attrs):
if 'options' not in attrs:
raise ValidationError(
'No filters specified, "options" object missing.')
signal_filter = SignalFilter(data=attrs['options'],
queryset=Signal.objects.none())
if not signal_filter.is_valid():
raise ValidationError(signal_filter.errors)
return super(StoredSignalFilterSerializer, self).validate(attrs)
def create(self, validated_data):
validated_data.update(
{'created_by': self.context['request'].user.email})
return super(StoredSignalFilterSerializer,
self).create(validated_data=validated_data)
class ContainerDetailSerializer(serializers.ModelSerializer):
_display = DisplayField()
class Meta:
model = EnevoContainer
fields = '__all__'
depth = 1
class CategoryHALSerializer(HALSerializer):
serializer_url_field = CategoryHyperlinkedIdentityField
_display = DisplayField()
departments = serializers.SerializerMethodField()
class Meta:
model = Category
fields = (
'_links',
'_display',
'name',
'slug',
'handling',
'departments',
'is_active',
'description',
'handling_message',
'category_level_name1',
'category_level_name2',
'category_level_name3',
'category_level_name4',
'filter_label',
)
def get_departments(self, obj):
# print("Called")
return _NestedDepartmentSerializer(
obj.departments.filter(categorydepartment__is_responsible=True),
many=True
).data
class CategoryHALSerializer(HALSerializer):
serializer_url_field = CategoryHyperlinkedIdentityField
_display = DisplayField()
departments = serializers.SerializerMethodField()
handling_message = serializers.SerializerMethodField()
class Meta:
model = Category
fields = (
'_links',
'_display',
'name',
'slug',
'handling',
'departments',
'is_active',
'description',
'handling_message',
)
def get_handling_message(self, obj):
return ALL_AFHANDELING_TEXT[obj.handling]
def get_departments(self, obj):
return _NestedDepartmentSerializer(
obj.departments.filter(categorydepartment__is_responsible=True),
many=True).data
class SiteSerializer(FlexFieldsModelSerializer, HALSerializer):
_display = DisplayField()
wells = RelatedSummaryField()
fracties = serializers.SerializerMethodField()
class Meta(object):
model = Site
fields = [
"_links",
"_display",
"id",
"short_id",
"stadsdeel",
"straatnaam",
"huisnummer",
"wells",
"fracties",
"centroid",
]
def get_fracties(self, obj):
return fracties(obj)
expandable_fields = {
'wells': (WellModelSerializer, {
'source':
'wells',
'many':
True,
'fields': ['id', 'id_number', 'geometrie', 'site', 'buurt_code']
}),
}
class SiteDetailSerializer(HALSerializer):
_display = DisplayField()
wells = WellModelSerializer(many=True)
fracties = serializers.SerializerMethodField()
distance_to_address = serializers.IntegerField(source='distance')
class Meta(object):
model = Site
fields = [
"_links",
"_display",
"id",
"short_id",
"stadsdeel",
"buurt_code",
"straatnaam",
"huisnummer",
"wells",
"fracties",
"bgt_based",
"extra_attributes",
"centroid",
"geometrie",
"distance_to_address",
]
def get_fracties(self, obj):
return fracties(obj)
class SiteFractieSerializer(FlexFieldsModelSerializer, HALSerializer):
_display = DisplayField()
class Meta:
model = SiteFractie
fields = [
"_links",
'_display',
'site',
'fractie',
'volume_m3',
'containers',
]
expandable_fields = {
'site': (SiteModelSerializer, {
'fields': [
'id',
'short_id',
'buurt_code',
'straatnaam',
'huisnummer',
]
}),
}
class SiteFractieDetailSerializer(FlexFieldsModelSerializer, HALSerializer):
_display = DisplayField()
class Meta:
model = SiteFractie
fields = [
# "_links",
"_display",
# 'site_id',
"site",
# 'site',
'fractie',
'volume_m3',
'containers',
]
expandable_fields = {
'site': (SiteModelSerializer, {
'fields': [
'id',
'short_id',
'centroid'
'buurt_code',
]
}),
}
class TemporaryCategoryHALSerializer(HALSerializer):
"""
TODO: Refactor the TemporaryCategoryHALSerializer and TemporaryParentCategoryHALSerializer serializers
"""
serializer_url_field = CategoryHyperlinkedIdentityField
_display = DisplayField()
departments = serializers.SerializerMethodField()
class Meta:
model = Category
fields = (
'_links',
'_display',
'id',
'name',
'slug',
'handling',
'departments',
'is_active',
'description',
'handling_message',
)
def get_departments(self, obj):
return _NestedDepartmentSerializer(
obj.departments.filter(categorydepartment__is_responsible=True),
many=True).data
class CategoryHALSerializer(HALSerializer):
serializer_url_field = CategoryHyperlinkedIdentityField
_display = DisplayField()
departments = serializers.SerializerMethodField()
questionnaire = serializers.UUIDField(source='questionnaire.uuid', required=False, read_only=True)
class Meta:
model = Category
fields = (
'_links',
'_display',
'name',
'slug',
'handling',
'departments',
'is_active',
'description',
'handling_message',
'questionnaire',
'public_name',
'is_public_accessible',
)
def get_departments(self, obj):
return _NestedPublicDepartmentSerializer(
obj.departments.filter(categorydepartment__is_responsible=True),
many=True
).data
class PrivateSignalAttachmentSerializer(SignalAttachmentSerializerMixin,
HALSerializer):
serializer_url_field = PrivateSignalAttachmentLinksField
_display = DisplayField()
location = serializers.FileField(source='file', required=False)
class Meta:
model = Attachment
fields = (
'_display',
'_links',
'location',
'is_image',
'created_at',
'file',
'created_by',
)
read_only = (
'_display',
'_links',
'location',
'is_image',
'created_at',
'created_by',
)
extra_kwargs = {'file': {'write_only': True}}
class PrivateSignalsPlanSerializerList(HALSerializer):
_display = DisplayField()
signal = serializers.SerializerMethodField()
reporter = serializers.SerializerMethodField()
updated_by = serializers.SerializerMethodField()
class Meta:
model = SignalsPlan
fields = ('_display', 'id', 'signal', 'reporter', 'updated_by',
'report_days', 'created_at', 'updated_at', 'forman_email',
'schedule_datetime')
def get_signal(self, obj):
# print(obj.signal_id)
if obj.signal_id:
return PublicSignalSerializerDetail(
Signal.objects.get(id=obj.signal_id)).data
return None
def get_reporter(self, obj):
if obj.reporter_id:
return _NestedReporterModelSerializer(
Reporter.objects.get(id=obj.reporter_id)).data
return None
def get_updated_by(self, obj):
if obj.updated_by and obj.updated_by.email:
return UserListHALSerializer(
User.objects.get(email=obj.updated_by.email)).data
return None
class PrivateSignalsPlanSerializerDetail(HALSerializer):
_display = DisplayField()
signal_id = serializers.CharField()
reporter_id = serializers.CharField()
updated_by = UserDetailHALSerializer(required=False)
signal = serializers.SerializerMethodField()
reporter = serializers.SerializerMethodField()
class Meta:
model = SignalsPlan
fields = ('_display', 'id', 'signal_id', 'reporter_id', 'updated_by',
'updated_at', 'report_days', 'created_at', 'forman_email',
'schedule_datetime', 'signal', 'reporter')
def get_signal(self, obj):
if obj.signal_id:
return PublicSignalSerializerDetail(
Signal.objects.get(id=obj.signal_id)).data
return None
def get_reporter(self, obj):
if obj.reporter_id:
return _NestedReporterModelSerializer(
Reporter.objects.get(id=obj.reporter_id)).data
return None
def create(self, validated_data):
# print(validated_data)
signal_id = validated_data.pop('signal_id', None)
reporter_id = validated_data.pop('reporter_id', None)
signal = Signal.objects.get(id=signal_id)
reporter = Reporter.objects.get(id=reporter_id)
instance = super(PrivateSignalsPlanSerializerDetail,
self).create(validated_data)
instance.signal = signal
instance.reporter = reporter
instance.save()
return instance
def update(self, instance, validated_data):
signal_id = validated_data.pop('signal_id', None)
reporter_id = validated_data.pop('reporter_id', None)
# logged in user
logged_in_user = self.context['request'].user
instance = super(PrivateSignalsPlanSerializerDetail,
self).update(instance, validated_data)
instance.updated_by = logged_in_user
instance.save()
instance.refresh_from_db()
return instance
class ParkeervakSerializer(BaseSerializer, HALSerializer):
_display = DisplayField()
filter_fields = ('id')
class Meta(object):
model = Parkeervak
fields = ["_links", "_display", "id", "buurtcode", "straatnaam", "aantal", "type", "e_type", "e_type_desc", "bord", "geometrie"]
class TestDisplayFieldSerializer(ModelSerializer):
"""Test display field."""
_display = DisplayField()
class Meta: # noqa
model = WeatherStation
fields = '__all__'
class SignalAuthHALSerializerDetail(HALSerializer):
"""Read-only serializer for single `Signal` object."""
_display = DisplayField()
id = serializers.IntegerField(label='ID', read_only=True)
signal_id = serializers.CharField(label='SIGNAL_ID', read_only=True)
location = _NestedLocationModelSerializer(read_only=True)
reporter = _NestedReporterModelSerializer(read_only=True)
status = _NestedStatusModelSerializer(read_only=True)
category = _NestedCategoryModelSerializer(source='category_assignment',
read_only=True)
priority = _NestedPriorityModelSerializer(read_only=True)
image = serializers.ImageField(source='image_crop', read_only=True)
notes_count = serializers.SerializerMethodField()
parent_id = serializers.IntegerField(read_only=True)
child_ids = serializers.SerializerMethodField(read_only=True)
serializer_url_field = SignalLinksField
def get_notes_count(self, obj):
return obj.notes.count()
class Meta(object):
model = Signal
fields = (
'_links',
'_display',
'id',
'signal_id',
'source',
'text',
'text_extra',
'status',
'location',
'category',
'reporter',
'priority',
'created_at',
'updated_at',
'incident_date_start',
'incident_date_end',
'operational_date',
'image',
'extra_properties',
'notes_count',
'parent_id',
'child_ids',
)
read_only_fields = (
'id',
'signal_id',
'created_at',
'updated_at',
)
def get_child_ids(self, obj):
return obj.children.values_list('id', flat=True)
class PrivateDepartmentSerializerDetail(HALSerializer):
_display = DisplayField()
categories = CategoryDepartmentSerializer(
source='active_categorydepartment_set', many=True, required=False)
class Meta:
model = Department
fields = (
'_links',
'_display',
'id',
'name',
'code',
'is_intern',
'categories',
'can_direct',
)
def _save_category_department(self, instance, validated_data):
instance.category_set.clear()
for category_department_validated_data in validated_data:
category_department_validated_data['department'] = instance
category_department = CategoryDepartment(
**category_department_validated_data)
category_department.save()
def create(self, validated_data):
categorydepartment_set_validated_data = None
if 'active_categorydepartment_set' in validated_data:
categorydepartment_set_validated_data = validated_data.pop(
'active_categorydepartment_set')
instance = super(PrivateDepartmentSerializerDetail,
self).create(validated_data)
if categorydepartment_set_validated_data:
self._save_category_department(
instance=instance,
validated_data=categorydepartment_set_validated_data)
instance.refresh_from_db()
return instance
def update(self, instance, validated_data):
if 'active_categorydepartment_set' in validated_data:
self._save_category_department(
instance=instance,
validated_data=validated_data.pop(
'active_categorydepartment_set'))
instance = super(PrivateDepartmentSerializerDetail,
self).update(instance, validated_data)
instance.refresh_from_db()
return instance
class ContainerSerializer(HALSerializer):
_display = DisplayField()
# container_type = InlineContainerTypeSerializer()
class Meta:
model = EnevoContainer
fields = ('_links', '_display', 'id', 'container_type_id', 'site_id',
'site_content_type_id', 'container_slot_id', 'geometrie',
'geometrie_rd', 'geo_accuracy', 'customer_key',
'last_modified', 'valid')
class TypeSerializer(HALSerializer):
_display = DisplayField()
containers = RelatedSummaryField()
class Meta(object):
model = ContainerType
fields = [
"_links", "_display", "id", "name", "volume", "weight",
"containers"
]
class PublicQuestionnaireSerializer(HALSerializer):
serializer_url_field = QuestionnairePublicHyperlinkedIdentityField
_display = DisplayField()
first_question = PublicQuestionSerializer()
class Meta:
model = Questionnaire
fields = ('_links', '_display', 'uuid', 'name', 'description',
'is_active', 'first_question')
read_only_fields = fields # No create or update allowed
class PublicAnswerSerializer(HALSerializer):
serializer_url_field = EmptyHyperlinkedIdentityField
_display = DisplayField()
session = UUIDRelatedField(
uuid_field='uuid',
queryset=Session.objects.retrieve_valid_sessions(),
required=False)
questionnaire = UUIDRelatedField(uuid_field='uuid',
queryset=Questionnaire.objects.active(),
required=False)
class Meta:
model = Answer
fields = (
'_links',
'_display',
'payload',
'session',
'questionnaire',
'created_at',
)
read_only_fields = ('created_at', )
def validate(self, attrs):
attrs = super(PublicAnswerSerializer, self).validate(attrs=attrs)
if 'session' in attrs and 'questionnaire' in attrs:
raise ValidationError(
'session and questionnaire cannot be used both!')
elif 'session' not in attrs and 'questionnaire' not in attrs:
raise ValidationError(
'Either the session or questionnaire is mandatory!')
# TODO: Add a check to see if the question belongs to the questionnaire that is being processed
return attrs
def create(self, validated_data):
question = self.context['question']
payload = validated_data.pop('payload')
if 'session' in validated_data:
session = validated_data.pop('session')
questionnaire = session.questionnaire
else:
session = None
questionnaire = validated_data.pop('questionnaire')
return QuestionnairesService.create_answer(answer_payload=payload,
question=question,
questionnaire=questionnaire,
session=session)
class PrivateCategorySerializer(HALSerializer):
serializer_url_field = PrivateCategoryHyperlinkedIdentityField
_display = DisplayField()
sla = serializers.SerializerMethodField()
new_sla = PrivateCategorySLASerializer(write_only=True)
departments = _NestedPrivateCategoryDepartmentSerializer(
source='categorydepartment_set', many=True, read_only=True)
class Meta:
model = Category
fields = (
'_links',
'_display',
'id',
'name',
'slug',
'is_active',
'description',
'handling_message',
'sla',
'new_sla',
'departments',
'note',
)
read_only_fields = ('slug', )
def get_sla(self, obj):
return PrivateCategorySLASerializer(obj.slo.first()).data
def update(self, instance, validated_data):
if 'new_sla' in validated_data:
new_sla = validated_data.pop('new_sla')
new_sla.update({'category_id': instance.pk
}) # Add the category instance to the new SLA data
create_new_slo = True
slo_qs = ServiceLevelObjective.objects.filter(
category_id=instance.pk).order_by('-created_at')
if slo_qs.count() > 0:
# Check if there are any changes to the SLA data
latest_slo = slo_qs.first()
create_new_slo = any([
new_sla['n_days'] != latest_slo.n_days,
new_sla['use_calendar_days'] !=
latest_slo.use_calendar_days
])
if create_new_slo:
ServiceLevelObjective.objects.create(**new_sla)
instance.refresh_from_db()
return super().update(instance, validated_data)
class StoredSignalFilterSerializer(HALSerializer):
serializer_url_field = StoredSignalFilterLinksField
_display = DisplayField()
class Meta:
model = StoredSignalFilter
fields = (
'_links',
'_display',
'id',
'name',
'created_at',
'options',
'refresh',
'show_on_overview',
)
def validate(self, attrs):
if 'options' not in attrs and self.context[
'view'].action != 'partial_update':
"""
When doing a partial_update the "options" are not mandatory, for all other actions they are!
"""
raise ValidationError(
'No filters specified, "options" object missing.')
return super().validate(attrs)
def validate_options(self, value):
if type(value) != dict:
raise ValidationError('Expected an object for "options"')
signal_filter = SignalFilterSet(data=value,
queryset=Signal.objects.none())
if not signal_filter.is_valid():
raise ValidationError(signal_filter.errors)
# Check that we are only accepting filter data for which there are
# actual Filter definitions on the SignalFilter FilterSet (SIG-2322).
filter_names = set(signal_filter.get_filters())
undefined_filters = set(value) - filter_names
if undefined_filters:
raise ValidationError(
'FilterSet data to store contains unknown filters {}'.format(
repr(list(undefined_filters))))
return value
def create(self, validated_data):
validated_data.update(
{'created_by': self.context['request'].user.email})
return super().create(validated_data=validated_data)
class ParentCategoryHALSerializer(HALSerializer):
serializer_url_field = ParentCategoryHyperlinkedIdentityField
_display = DisplayField()
sub_categories = CategoryHALSerializer(many=True, source='children')
class Meta:
model = Category
fields = (
'_links',
'_display',
'name',
'slug',
'sub_categories',
)
class PrivateCategorySerializer(HALSerializer):
serializer_url_field = PrivateCategoryHyperlinkedIdentityField
_display = DisplayField()
sla = serializers.SerializerMethodField()
new_sla = PrivateCategorySLASerializer(write_only=True)
departments = serializers.SerializerMethodField()
class Meta:
model = Category
fields = (
'_links',
'_display',
'id',
'name',
'slug',
'is_active',
'description',
'handling_message',
'sla',
'new_sla',
'departments',
)
read_only_fields = (
'id',
'slug',
'sla',
'departments', # noqa Is read-only by default because we use the SerializerMethodField but also added here for readability
)
def get_sla(self, obj):
return PrivateCategorySLASerializer(
obj.slo.all().order_by('-created_at').first()).data
def get_departments(self, obj):
return _NestedPrivateCategoryDepartmentSerializer(
CategoryDepartment.objects.filter(
category_id=obj.pk).order_by('department__code'),
many=True).data
def update(self, instance, validated_data):
new_sla = validated_data.pop(
'new_sla') if 'new_sla' in validated_data else None
if new_sla:
ServiceLevelObjective.objects.create(category=instance, **new_sla)
instance.refresh_from_db()
return super(PrivateCategorySerializer,
self).update(instance, validated_data)
class StatusHALSerializer(AddExtrasMixin, HALSerializer):
_display = DisplayField()
_signal = serializers.PrimaryKeyRelatedField(queryset=Signal.objects.all())
serializer_url_field = StatusLinksField
state_display = serializers.CharField(source='get_state_display',
read_only=True)
class Meta(object):
model = Status
fields = (
'_links',
'_display',
'_signal',
'text',
'user',
'target_api',
'state',
'state_display',
'extra_properties',
'created_at',
)
extra_kwargs = {'state': {'choices': workflow.STATUS_CHOICES_API}}
def create(self, validated_data):
validated_data = self.add_user(validated_data)
signal = validated_data.pop('_signal')
status = Signal.actions.update_status(validated_data, signal)
return status
def validate(self, data):
is_status_change_to_sigmax = (data['state'] == workflow.TE_VERZENDEN
and data.get('target_api', None)
== Status.TARGET_API_SIGMAX)
if is_status_change_to_sigmax:
request = self.context.get('request', None)
if request and not request.user.has_perm('signals.push_to_sigmax'):
raise PermissionDenied({
'state':
"You don't have permissions to push to Sigmax/CityControl."
})
try:
status = Status(**data)
status.clean()
except ValidationError as e:
raise serializers.ValidationError(e.error_dict)
return data
class PassageSerializer(HALSerializer):
_display = DisplayField()
class Meta:
model = Passage
fields = [
'_display',
'_links',
'id',
'versie',
'merk',
'created_at',
'passage_at',
]
class PrivateQuestionnaireSerializer(HALSerializer):
serializer_url_field = QuestionnairePrivateHyperlinkedIdentityField
_display = DisplayField()
first_question = PrivateQuestionSerializer()
class Meta:
model = Questionnaire
fields = ('_links', '_display', 'id', 'uuid', 'name', 'description',
'is_active', 'created_at', 'first_question')
read_only_fields = (
'id',
'uuid',
'created_at',
)
class PublicSignalAttachmentSerializer(SignalAttachmentSerializerMixin,
HALSerializer):
serializer_url_field = PublicSignalAttachmentLinksField
_display = DisplayField()
location = serializers.FileField(source='file', required=False)
class Meta:
model = Attachment
fields = (
'_display',
'_links',
'location',
'is_image',
'created_at',
'file',
)
read_only = (
'_display',
'_links',
'location',
'is_image',
'created_at',
)
extra_kwargs = {'file': {'write_only': True}}
def create(self, validated_data):
signal = self.context['view'].get_signal()
if signal.status.state not in PUBLIC_UPLOAD_ALLOWED_STATES:
msg = 'Public uploads not allowed in current signal state.'
raise ValidationError(msg)
# Only allow uploads in state AFGEHANDELD if there is an open/active
# request for feedback from the reporter. Note several feedback requests
# can be open/active at once.
if signal.status.state == AFGEHANDELD:
qs = (Feedback.objects.filter(_signal=signal).filter(
submitted_at__isnull=True).filter(
created_at__gte=timezone.now() -
timedelta(days=FEEDBACK_EXPECTED_WITHIN_N_DAYS)))
if not qs.exists():
msg = 'No feedback expected for this signal hence no uploads allowed.'
raise ValidationError(msg)
return super().create(validated_data)
