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)