class TestTimeField(FieldValues): """ Valid and invalid values for `TimeField`. """ valid_inputs = { '13:00': datetime.time(13, 00), datetime.time(13, 00): datetime.time(13, 00), } invalid_inputs = { 'abc': [ 'Time has wrong format. Use one of these formats instead: hh:mm[:ss[.uuuuuu]].' ], '99:99': [ 'Time has wrong format. Use one of these formats instead: hh:mm[:ss[.uuuuuu]].' ], } outputs = {datetime.time(13, 00): '13:00:00'} field = serializers.TimeField()
class MovieRetrieveSerializer(serializers.Serializer): movieId = serializers.IntegerField() movieName = serializers.CharField(validators=[validate_max_length(60)]) movieTime = serializers.TimeField(required=False) movieDescription = serializers.CharField( validators=[validate_max_length(4000)], required=False) movieDistribute = serializers.CharField( validators=[validate_max_length(60)], required=False) movieRelease = serializers.DateField(required=False) movieGen = serializers.CharField(validators=[validate_max_length(60)], required=False) directors = serializers.CharField(validators=[validate_max_length(60)], required=False) actors = serializers.CharField(validators=[validate_max_length(300)], required=False) moviePosterUrl = serializers.CharField( validators=[validate_max_length(500)], required=False) movieGrade = serializers.CharField(validators=[validate_max_length(2)], required=False)
class RainRegisterCreateSerializer(serializers.ModelSerializer): date_register = serializers.DateField() time_register = serializers.TimeField() class Meta: model = RainRegister fields = ['field', 'millimetres', 'date_register', 'time_register'] def create(self, validated_data): field = validated_data['field'] date_register = validated_data['date_register'] time_register = validated_data['time_register'] millimetres = validated_data['millimetres'] temp_date = datetime.datetime.combine(date_register, time_register) rain_register_obj = RainRegister(field=field, date=temp_date, millimetres=millimetres) rain_register_obj.save() return validated_data
class FilmListSerializer(serializers.Serializer): id = serializers.IntegerField(read_only=True) title = serializers.CharField(max_length=100) genre = serializers.CharField(max_length=20) premiere_date = serializers.DateField() session_time = serializers.TimeField() film_duration = serializers.IntegerField() tickets = serializers.PrimaryKeyRelatedField(many=True, read_only=True) price = serializers.FloatField() poster = serializers.ImageField(default=None) def to_representation(self, obj): serialized_data = super(FilmListSerializer, self).to_representation(obj) try: serialized_data['poster'] = str(Poster.objects.get(is_main=True, film=obj).pic) except: serialized_data['poster'] = None return serialized_data
def validate(self, data): if data.get('question').type == Question.TYPE_FILE: raise ValidationError( 'File uploads are currently not supported via the API.' ) elif data.get('question').type in (Question.TYPE_CHOICE, Question.TYPE_CHOICE_MULTIPLE): if not data.get('options'): raise ValidationError( 'You need to specify options if the question is of a choice type.' ) if data.get('question').type == Question.TYPE_CHOICE and len(data.get('options')) > 1: raise ValidationError( 'You can specify at most one option for this question.' ) data['answer'] = ", ".join([str(o) for o in data.get('options')]) else: if data.get('options'): raise ValidationError( 'You should not specify options if the question is not of a choice type.' ) if data.get('question').type == Question.TYPE_BOOLEAN: if data.get('answer') in ['true', 'True', '1', 'TRUE']: data['answer'] = 'True' elif data.get('answer') in ['false', 'False', '0', 'FALSE']: data['answer'] = 'False' else: raise ValidationError( 'Please specify "true" or "false" for boolean questions.' ) elif data.get('question').type == Question.TYPE_NUMBER: serializers.DecimalField( max_digits=50, decimal_places=25 ).to_internal_value(data.get('answer')) elif data.get('question').type == Question.TYPE_DATE: data['answer'] = serializers.DateField().to_internal_value(data.get('answer')) elif data.get('question').type == Question.TYPE_TIME: data['answer'] = serializers.TimeField().to_internal_value(data.get('answer')) elif data.get('question').type == Question.TYPE_DATETIME: data['answer'] = serializers.DateTimeField().to_internal_value(data.get('answer')) return data
class EstimateCreateQBOSerializer(serializers.Serializer): STATUSES = ['Pending', 'Accepted', 'Closed', 'Rejected'] customer_id = serializers.IntegerField() status = serializers.ChoiceField(choices=STATUSES) email = serializers.CharField() # used for billing email for invoice tag_number = serializers.CharField() bike_model = serializers.CharField() expiration_date = serializers.DateField() expiration_time = serializers.TimeField() category_items = serializers.JSONField( ) # individual items validated against EstimateLineQBOSerializer public_notes = serializers.CharField() private_notes = serializers.CharField() signature = serializers.CharField() # data uri discount_percent = serializers.FloatField( default=0, allow_null=True) # i.e "10.5" for "10.5%" discount_applied_to_all = serializers.BooleanField(default=False, allow_null=True)
class AppointmentSerializer(serializers.HyperlinkedModelSerializer): test_information = TestSerializerForAppointment(source='test', read_only=True) DATE_INPUT_FORMATS = [ '%m/%d/%Y', '%m/%d/%y', '%b %d %Y', '%b %d, %Y', '%B %d %Y', '%B %d, %Y', '%Y-%m-%d' ] date = serializers.DateField(input_formats=DATE_INPUT_FORMATS) time = serializers.TimeField(input_formats=[ '%I:%M %p', '%I%p', '%I:%M%p', '%I %p', ]) class Meta: model = Appointment fields = ('id', 'test', 'participant', 'date', \ 'time', 'created', 'test_information')
class OfferSerializer(serializers.ModelSerializer): origin = serializers.JSONField(required = True) destination = serializers.JSONField(required = True) seats_needed = serializers.IntegerField() departure_time = serializers.TimeField() is_full = serializers.BooleanField() is_ended = serializers.BooleanField() driver = ProfileSerializer(read_only=True) origin = LocationSerializer() destination = LocationSerializer() def create(self, validated_data): now = datetime.datetime.now() depature_time = validated_data.get('departure_time') is_full = validated_data.get("is_full") is_ended = validated_data.get("is_ended") request = self.context['request'] try: validated_data['driver'] = request.user.profile except Exception as e: raise ValidationError(detail='User has no profile', code='001--no_profile') for item in ['origin','destination']: _location = Location.objects.create(**validated_data.get(item)) validated_data[item] = _location return Offer.objects.create(**validated_data) def update(self, instance, validated_data, many=True): instance.is_full = validated_data.get('is_full', instance.is_full) instance.is_ended = validated_data.get('is_ended', instance.is_ended) # TODO : Check bugs on this endpoint instance.save() return instance class Meta: model = Offer fields = ('driver','origin','destination','seats_needed', 'departure_time','created_at', 'is_full','is_ended')
class PublicNoticeSerializers(serializers.ModelSerializer): user = serializers.SerializerMethodField('is_named_bar') images = serializers.SerializerMethodField('notice_images') images_list = serializers.SerializerMethodField('notice_images_list') profile = serializers.SerializerMethodField('user_profile') created_at = serializers.DateTimeField(format="%d-%m-%Y, %H:%M") time = serializers.TimeField(format="%H:%M") class Meta: model = Notice fields = ('id', 'title', 'description', 'is_event', 'date', 'time', 'venue', 'user', 'profile', 'images', 'images_list', 'department', 'public_notice', 'created_at') @staticmethod def is_named_bar(notice): return notice.user.name def user_profile(self, notice): request = self.context.get('request') if notice.user.profile: return request.build_absolute_uri(notice.user.profile.url) def notice_images(self, notice): request = self.context.get('request') data = notice.image_set.all() if data: return list( map(lambda d: request.build_absolute_uri(d.image.url), data)) return def notice_images_list(self, notice): request = self.context.get('request') data = notice.image_set.all() if data: return list( map( lambda d: { 'id': d.id, 'url': request.build_absolute_uri(d.image.url) }, data)) return
class MatchSerializer(serializers.HyperlinkedModelSerializer): park_name = serializers.ReadOnlyField(source='park.name') creator_name = serializers.ReadOnlyField(source='creator.username') time = serializers.TimeField(format="%I:%M %p") # add players date = serializers.DateField(format="%A %b, %d") distance = serializers.DecimalField(source='distance.mi', max_digits=10, decimal_places=2, required=False, read_only=True) class Meta: model = Match fields = ('url', 'id', 'creator', 'creator_name', 'title', 'description', 'park', 'park_name', 'sport', 'other', 'img_url', 'skill_level', 'date', 'time', 'players', 'status', 'distance') read_only_fields = ('url', 'id', 'creator', 'players', 'status', 'img_url', 'distance')
class FinanceCalendarSerializer(serializers.ModelSerializer): time = serializers.TimeField(format('%H:%M'), read_only=True) uploader = serializers.SerializerMethodField() class Meta: model = FinanceCalendar exclude = ( 'create_time', 'update_time', ) @staticmethod def get_uploader(obj): text = '' if obj.uploader: if obj.uploader.note: text = obj.uploader.note else: text = obj.uploader.phone[:3] + '****' + obj.uploader.phone[7:] return text
class DurationSerializer(serializers.ModelSerializer): service = serializers.PrimaryKeyRelatedField( queryset=Service.objects.all(), required=True) duration = serializers.TimeField(required=True) def validate_service(self, value): if self.instance: try: self.instance.reservationcontainsservices_set.get( service=value.pk) except ReservationContainsServices.DoesNotExist: raise serializers.ValidationError( "Service with id: %d doesn't belong to the reservation." % value.pk) return value class Meta: model = Reservation fields = ['service', 'duration'] list_serializer_class = ListDurationSerializer
class OcorrenciaSerializer(serializers.ModelSerializer): data = serializers.DateField( format = 'iso-8601', input_formats = None, label = 'Data da Ocorrência', ) hora = serializers.TimeField( format = 'iso-8601', input_formats = None, label = 'Hora da Ocorrência', ) descricao = serializers.CharField( allow_blank = True, max_length = None, min_length = None, label = 'Descrição', ) resposta = serializers.CharField( allow_blank=True, min_length=None, max_length=20, label = 'Resposta', ) validade = serializers.NullBooleanField( label = 'Validade', ) emergencia = serializers.NullBooleanField( label = 'Emergência', ) class Meta: model = Ocorrencia fields = ('id','data', 'hora', 'latitude', 'longitude', 'descricao', 'foto', 'validade', 'atendida', 'emergencia', 'vitimado', 'repetida', 'resposta', 'usuario_ID', 'tb_categoria_ID', 'tb_local_ID')
class NoteSerializer(serializers.ModelSerializer): reminder = serializers.TimeField(format="%H:%M", required=False) class Meta: model = Note fields = '__all__' read_only_fields = ['id', 'user', 'trash'] def create(self, validated_data): user = validated_data['user'] collaborators = validated_data.pop('collaborators') try: labels = validated_data['label'] except KeyError: labels = [] note = Note.objects.create(**validated_data) note.collaborators.set(collaborators) note.save() for label in labels: Label.objects.get_or_create(label_id=user, label=label) return note
class ActivitySerializer(serializers.ModelSerializer): city = CitySerializer() kind = KindSerializer() wage_status = serializers.CharField(source="get_wage_status_display") starting_date = serializers.DateField(format="%d/%m/%Y") starting_time = serializers.TimeField(format="%H:%M") activity_links = ActivityLinkSerializer(read_only=True, many=True) activity_documents = ActivityDocumentSerializer(read_only=True, many=True) class Meta: model = Activity fields = ('id', 'city', 'kind', 'address', 'coordinate', 'name', 'starting_date', 'starting_time', 'end_date', 'end_time', 'wage_status', 'image', 'statement', 'activity_documents', 'activity_links') def get_image(self, obj): if obj.image: return settings.DOMAIN + obj.image.url else: return None
class MessageSerializer(serializers.ModelSerializer): sender = ContactSerializer() time_sent = serializers.TimeField( read_only=True, required=False, format="%I: %M %p", ) attachments = AttachmentsSerializer(required=False, read_only=True, many=True) class Meta: model = Message fields = '__all__' def validate(self, attrs): if not attrs.get('sender') in attrs.get( 'conversation').participants.all(): raise serializers.ValidationError( 'cannot send to a conversation that is not joined') return attrs
class KonsultasiSerializer(serializers.ModelSerializer): id_konsul = serializers.CharField(max_length=10, required=True) klien = serializers.CharField(max_length=15, required=True) spesialisasi = serializers.CharField(max_length=1, required=True) tanggal = serializers.CharField(max_length=10, required=True) waktu = serializers.TimeField(required=True) durasi = serializers.CharField(max_length=1, required=True) def create(self, validated_data: Konsultasi): consultation_schedule = Konsultasi.objects.create( id_konsul=validated_data['id_konsul'], klien=validated_data['klien'], spesialisasi=validated_data['spesialisasi'], tanggal=validated_data['tanggal'], waktu=validated_data['waktu'], durasi=validated_data['durasi']) return consultation_schedule class Meta: model = Konsultasi fields = ('id_konsul', 'klien', 'tanggal', 'waktu', 'spesialisasi', 'durasi')
class PartyListSerializer(ModelSerializer): user = UsuarioSerializer() createdAt = serializers.DateTimeField(format="%d-%m-%Y a las %H:%M") #event_date = serializers.DateField(format="%d-%m-%Y") time = serializers.TimeField(format="%H:%M Hrs") class Meta: model = Party fields = [ 'id', 'name', 'description', 'status', 'location', 'user', 'place', 'category', 'createdAt', 'event_date', 'time', 'updatedAt', ]
class ClassSerializer(serializers.ModelSerializer): teaching_task = serializers.HyperlinkedRelatedField( view_name='task:task-detail', queryset=tm.Task.objects.all(), style={'base_template': 'input.html'}, ) ro_persons = ClassxPersonSerializer(read_only=True, many=True, source='class_x_person_set') ro_scheduled_date = serializers.DateField(source='scheduled_date') ro_start_time = serializers.TimeField(source='start_time') class Meta: model = tm.Class fields = ( 'id', 'canceled', 'certification_tag', 'department', 'info', 'materials_fee', 'max_students', 'member_price', 'minor_policy', 'nonmember_price', 'prerequisite_tag', 'printed_handout', 'publicity_image', 'ro_persons', 'ro_scheduled_date', 'ro_start_time', 'rsvp_period', 'short_desc', 'teaching_task', 'title', )
class BookSlotSerializer(BaseSlotSerializer): date = serializers.DateField() start_time = serializers.TimeField() duration = serializers.CharField(default='1h') def validate(self, data): start_datetime = datetime.combine(data["date"], data["start_time"]) slot = Slot.objects.filter(start_time=start_datetime, status=SlotStatus.AVAILABLE).first() if slot: data["slot"] = slot else: raise serializers.ValidationError( "Slot is not available for the requested time.") return data def create(self, validated_data): slot = validated_data["slot"] slot.booked_by = validated_data["booked_by"] slot.status = SlotStatus.BOOKED slot.save() return validated_data
class CreatePagoSerializer(serializers.ModelSerializer): fecha = serializers.DateField(required=False) hora = serializers.TimeField(required=False) def to_internal_value(self, data): try: data["cuenta"] = data["cuenta_id"] data["titular"] = data["titular_id"] except KeyError: pass try: data["fecha"] = datetime.strftime( datetime.strptime(data["fecha"], "%d/%m/%Y"), "%Y-%m-%d") except (ValueError, KeyError) as err: pass return super().to_internal_value(data) class Meta: model = Pago fields = '__all__'
class UserScheduledTimetableSerializer(BaseSerializer): start_date_and_time = serializers.DateTimeField(format=None) end_time = serializers.TimeField(format=None) class Meta: model = models.UserScheduledTimetable fields = ('id', 'user', 'course', 'name', 'venue', 'purpose', 'start_date_and_time', 'end_time') read_only_fields = ['id', 'user'] def validate(self, attrs): start = attrs.get('start_date_and_time').time() end = attrs.get('end_time') date = attrs.get('start_date_and_time').date() date_time = attrs.get('start_date_and_time') venue = attrs.get('venue') today_date = utc.localize(datetime.now()) if today_date > date_time.replace(tzinfo=utc): msg = "Enter a future date and time" raise serializers.ValidationError(msg) if date.weekday() == 6: raise serializers.ValidationError( "Working days are from Monday to Saturday") if end <= start: raise serializers.ValidationError("The end must occur after start") if not check_time_within_working_hours(start=start, end=end): raise serializers.ValidationError( "Time must be within working hours") avail_ven = get_available_venues(start=start, end=end, date=date) if str(venue.id) not in avail_ven: raise serializers.ValidationError("Venue no longer available") return attrs
class MovieCreateSerializer(serializers.Serializer): movieName = serializers.CharField(validators=[validate_max_length(60)]) movieTime = serializers.TimeField(required=False) movieDescription = serializers.CharField( validators=[validate_max_length(4000)], required=False) movieDistribute = serializers.CharField( validators=[validate_max_length(60)], required=False) movieRelease = serializers.DateField(required=False) movieGen = serializers.CharField(validators=[validate_max_length(60)], required=False) directors = serializers.CharField(validators=[validate_max_length(60)], required=False) actors = serializers.CharField(validators=[validate_max_length(300)], required=False) moviePosterUrl = serializers.CharField( validators=[validate_max_length(500)], required=False) movieGrade = serializers.CharField(validators=[validate_max_length(2)], required=False) def validate_movieGrade(self, value): if not re.match('^\\d{2}$', value): raise ValidationError('영화등급은 숫자 두자리만 올 수 있습니다.') return value
class BookingSerializer(serializers.Serializer): user = UserSerializer() excursion = ExcursionsIdSerializer() status = serializers.CharField() id_pay = serializers.CharField() name = serializers.CharField() mail = serializers.EmailField(allow_null=True) phone = serializers.CharField(allow_null=True) day = serializers.DateField() time = serializers.TimeField() bay_status = serializers.CharField() bay_access = serializers.CharField() people_stay = serializers.IntegerField() def create(self, validated_data): user = User.objects.get( username=validated_data.pop('user')['username']) excursion = Excursions.objects.get( id=validated_data.pop('excursion')['id']) return Booking.objects.create(user=user, excursion=excursion, **validated_data)
class EventsSerializer(serializers.Serializer): id = serializers.IntegerField(read_only=True) #club_id= ClubSerializer() name = serializers.CharField(max_length=30) description = serializers.CharField(max_length=300) location = serializers.CharField(max_length=300, required=False) date = serializers.DateField(required=False) time = serializers.TimeField(required=False) #sport_id = SportSerializer() def create(self, validated_data): return Events.objects.create(**validated_data) def update(self, instance, validated_data): instance.name = validated_data.get('name', instance.name) instance.description = validated_data.get('description', instance.description) instance.location = validated_data.get('location', instance.location) instance.date = validated_data.get('date', instance.date) instance.time = validated_data.get('time', instance.time) instance.save() return instance
class ShowtimeSerializer(serializers.Serializer): id = serializers.IntegerField( read_only=True ) auditorium = serializers.PrimaryKeyRelatedField( queryset=Auditorium.objects.all(), allow_null=False ) date = serializers.DateField( required=True ) time = serializers.TimeField( required=True ) price = serializers.DecimalField( max_digits=6, decimal_places=2, required=True ) movie = serializers.PrimaryKeyRelatedField( queryset=Movie.objects.all(), allow_null=False ) seats = serializers.ListField( read_only=True ) def create(self, validated_data): showtime = Showtime.objects.create(**validated_data) showtime.save() return showtime def update(self, showtime, validated_data): for k, v in validated_data.items(): setattr(showtime, k, v) showtime.save() return showtime
class BleachingCSVSerializer(CollectRecordCSVSerializer): protocol = BLEACHINGQC_PROTOCOL sample_unit = "quadrat_collection" observations_fields = [ "data__obs_colonies_bleached", "data__obs_quadrat_benthic_percent", ] ordering_field = "data__obs_quadrat_benthic_percent__quadrat_number" additional_group_fields = CollectRecordCSVSerializer.additional_group_fields.copy( ) additional_group_fields.append("data__quadrat_collection__label") header_map = CollectRecordCSVSerializer.header_map.copy() header_map.update({ "Sample time": "data__quadrat_collection__sample_time", "Depth *": "data__quadrat_collection__depth", "Visibility": "data__quadrat_collection__visibility", "Current": "data__quadrat_collection__current", "Relative depth": "data__quadrat_collection__relative_depth", "Tide": "data__quadrat_collection__tide", "Quadrat size *": "data__quadrat_collection__quadrat_size", "Label": "data__quadrat_collection__label", "Benthic attribute": "data__obs_colonies_bleached__attribute", "Growth form": "data__obs_colonies_bleached__growth_form", "Number of colonies normal": "data__obs_colonies_bleached__count_normal", "Number of colonies pale": "data__obs_colonies_bleached__count_pale", "Number of colonies bleached 0-20% bleached": "data__obs_colonies_bleached__count_20", "Number of colonies bleached 20-50% bleached": "data__obs_colonies_bleached__count_50", "Number of colonies bleached 50-80% bleached": "data__obs_colonies_bleached__count_80", "Number of colonies bleached 80-100% bleached": "data__obs_colonies_bleached__count_100", "Number of colonies recently dead": "data__obs_colonies_bleached__count_dead", "Quadrat number": "data__obs_quadrat_benthic_percent__quadrat_number", "Hard coral % cover": "data__obs_quadrat_benthic_percent__percent_hard", "Soft coral % cover": "data__obs_quadrat_benthic_percent__percent_soft", "Macroalgae % cover": "data__obs_quadrat_benthic_percent__percent_algae", }) obs_colonies_bleached_fields = ( "data__obs_colonies_bleached__attribute", "data__obs_colonies_bleached__growth_form", "data__obs_colonies_bleached__count_normal", "data__obs_colonies_bleached__count_pale", "data__obs_colonies_bleached__count_20", "data__obs_colonies_bleached__count_50", "data__obs_colonies_bleached__count_80", "data__obs_colonies_bleached__count_100", "data__obs_colonies_bleached__count_dead", ) obs_quadrat_benthic_percent_fields = ( "data__obs_quadrat_benthic_percent__quadrat_number", "data__obs_quadrat_benthic_percent__percent_hard", "data__obs_quadrat_benthic_percent__percent_soft", "data__obs_quadrat_benthic_percent__percent_algae", ) data__quadrat_collection__sample_time = serializers.TimeField( required=False, allow_null=True) data__quadrat_collection__depth = serializers.DecimalField( max_digits=3, decimal_places=1) data__quadrat_collection__visibility = LazyChoiceField( choices=visibility_choices, required=False, allow_null=True, allow_blank=True) data__quadrat_collection__current = LazyChoiceField( choices=current_choices, required=False, allow_null=True, allow_blank=True) data__quadrat_collection__relative_depth = LazyChoiceField( choices=relative_depth_choices, required=False, allow_null=True, allow_blank=True, ) data__quadrat_collection__tide = LazyChoiceField(choices=tide_choices, required=False, allow_null=True, allow_blank=True) data__quadrat_collection__quadrat_size = serializers.DecimalField( max_digits=4, decimal_places=2) data__quadrat_collection__label = serializers.CharField(allow_blank=True, required=False, default="") data__obs_colonies_bleached__attribute = LazyChoiceField( choices=benthic_attributes_choices, required=False, allow_null=True, allow_blank=True, ) data__obs_colonies_bleached__growth_form = LazyChoiceField( choices=growth_form_choices, required=False, allow_null=True, allow_blank=True) data__obs_colonies_bleached__count_normal = PositiveIntegerField() data__obs_colonies_bleached__count_pale = PositiveIntegerField() data__obs_colonies_bleached__count_20 = PositiveIntegerField() data__obs_colonies_bleached__count_50 = PositiveIntegerField() data__obs_colonies_bleached__count_80 = PositiveIntegerField() data__obs_colonies_bleached__count_100 = PositiveIntegerField() data__obs_colonies_bleached__count_dead = PositiveIntegerField() data__obs_quadrat_benthic_percent__quadrat_number = PositiveIntegerField() data__obs_quadrat_benthic_percent__percent_hard = PositiveIntegerField() data__obs_quadrat_benthic_percent__percent_soft = PositiveIntegerField() data__obs_quadrat_benthic_percent__percent_algae = PositiveIntegerField() def skip_field(self, data, field): empty_fields = [] if (data.get("data__obs_colonies_bleached__attribute") or "").strip() == "": empty_fields = "obs_colonies_bleached_fields" elif (data.get("data__obs_quadrat_benthic_percent__quadrat_number") or "").strip() == "": empty_fields = "obs_quadrat_benthic_percent_fields" return field in getattr(self, empty_fields) def _get_original_benthic_attribute_value(self, data): if hasattr(self, "_attribute_col_name") is False: _reverse_header_map = {v: k for k, v in self.header_map.items()} self._attribute_col_name = _reverse_header_map.get( "data__obs_colonies_bleached__attribute") _row_number = self._row_index.get(str(data["id"])) orig_row = self.original_data[_row_number - 2] return orig_row.get(self._attribute_col_name) def validate(self, data): data = super().validate(data) attribute_value = data.get("data__obs_colonies_bleached__attribute") quadrat_number = data.get( "data__obs_quadrat_benthic_percent__quadrat_number") if not attribute_value and not quadrat_number: benthic_attr_name = self._get_original_benthic_attribute_value( data) if benthic_attr_name is not None: raise ValidationError( f"'{benthic_attr_name}' benthic attribute has no match in MERMAID." ) raise ValidationError( "One of 'Colonies Bleached' or 'Percent Cover' columns are required." ) if data.get("data__obs_colonies_bleached__attribute") and data.get( "data__obs_quadrat_benthic_percent__quadrat_number"): raise ValidationError( "Only one of 'Colonies Bleached' or 'Percent Cover' columns can be defined." ) return data def get_sample_event_time(self, row): return row.get("data__quadrat_collection__sample_time")
class ProgramSerialzer(serializers.Serializer): date = serializers.DateField() time = serializers.TimeField() title = serializers.CharField(max_length=50) speaker = serializers.CharField(max_length=50) presenter = serializers.CharField(max_length=50)
class WorkshopDetailSerializer(serializers.ModelSerializer): time = serializers.TimeField(allow_null=True, default=None) club = ClubSerializer(read_only=True, required=False) contacts = UserProfileSerializer(many=True, read_only=True) resources = serializers.SerializerMethodField() is_interested = serializers.SerializerMethodField() interested_users = serializers.SerializerMethodField() is_workshop_contact = serializers.SerializerMethodField() is_por_holder = serializers.SerializerMethodField() tags = TagSerializer(read_only=True, many=True) @swagger_serializer_method(serializer_or_field=serializers.BooleanField) def get_is_interested(self, obj): """ true, if the user is interested for the workshop, otherwise false null, in case of anonymous login """ # pylint: disable=no-member user = self.context['request'].user if not user.is_authenticated: return None profile = UserProfile.objects.get(user=user) return profile in obj.interested_users.all() @swagger_serializer_method(serializer_or_field=serializers.IntegerField) def get_interested_users(self, obj): """ Total number of users interested for the workshop """ return obj.interested_users.count() @swagger_serializer_method(serializer_or_field=serializers.BooleanField) def get_is_workshop_contact(self, obj): """ true, if the user making the request is a workshop contact, otherwise false """ user = self.context['request'].user if not user.is_authenticated: return False # pylint: disable=no-member profile = UserProfile.objects.get(user=user) return profile in obj.contacts.all() @swagger_serializer_method(serializer_or_field=serializers.BooleanField) def get_is_por_holder(self, obj): """ true, if the user is a POR holder of the Club or Club's Council, otherwise false """ user = self.context['request'].user if not user.is_authenticated: return False # pylint: disable=no-member profile = UserProfile.objects.get(user=user) if profile == obj.club.secy: return True if profile in obj.club.joint_secy.all(): return True if profile == obj.club.council.gensec: return True if profile in obj.club.council.joint_gensec.all(): return True return False @swagger_serializer_method(serializer_or_field=WorkshopResourceSerializer(many=True)) def get_resources(self, obj): """ All the resources for the workshop """ return WorkshopResourceSerializer(obj.resources, many=True).data class Meta: model = Workshop read_only_fields = ('club', 'contacts', 'is_interested', 'interested_users', 'resources', 'tags') fields = ( 'id', 'title', 'description', 'club', 'date', 'time', 'location', 'latitude', 'longitude', 'audience', 'resources', 'contacts', 'image_url', 'is_interested', 'interested_users', 'is_workshop_contact', 'is_por_holder', 'tags', 'link')
class InputSerializer(serializers.Serializer): user = serializers.IntegerField() specialty = serializers.IntegerField() date = serializers.DateField() time = serializers.TimeField()