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()
