class ExchangeConfigurationSerializer(serializers.ModelSerializer):
"""
Serializer for :class:`mail_collector.models.ExchangeConfiguration`
This is a read-only serializer.
"""
config_name = serializers.CharField(max_length=64)
exchange_accounts = ExchangeAccountSerializer(many=True, read_only=True)
debug = serializers.BooleanField()
autorun = serializers.BooleanField()
mail_check_period = serializers.DurationField()
ascii_address = serializers.BooleanField()
utf8_address = serializers.BooleanField()
check_mx = serializers.BooleanField()
check_mx_timeout = serializers.DurationField()
min_wait_receive = serializers.DurationField()
backoff_factor = serializers.IntegerField()
max_wait_receive = serializers.DurationField()
tags = serializers.CharField()
email_subject = serializers.CharField(max_length=78)
witness_addresses = WitnessEmailSerializer(many=True, read_only=True)
class Meta:
model = ExchangeConfiguration
fields = ('config_name', 'exchange_accounts', 'debug', 'autorun',
'mail_check_period', 'ascii_address', 'utf8_address',
'check_mx', 'check_mx_timeout', 'min_wait_receive',
'backoff_factor', 'max_wait_receive', 'tags',
'email_subject', 'witness_addresses')
class SentenceLengthSerializer(S.Serializer):
min_time = S.DurationField(
required=False) # S.IntegerField(required=False)
min_unit = S.CharField(required=False)
max_time = S.DurationField(
required=False) # S.IntegerField(required=False)
max_unit = S.CharField(required=False)
class EmployeeReportSerializer(serializers.ModelSerializer):
time_spent_on_workflows = WorkflowTimeSerializer(many=True)
number_of_workflows_assigned = serializers.IntegerField(min_value=0)
number_of_tasks = serializers.IntegerField(min_value=0)
total_time_spent_on_tasks = serializers.DurationField()
avg_time_spent_on_tasks = serializers.DurationField()
max_time_spent_on_tasks = serializers.DurationField()
min_time_spent_on_tasks = serializers.DurationField()
total_time_spent_on_workflows = serializers.DurationField()
avg_time_spent_on_workflows = serializers.DurationField()
max_time_spent_on_workflows = serializers.DurationField()
min_time_spent_on_workflows = serializers.DurationField()
last_task_completed = TaskBasicSerializer()
last_workflow_completed = WorkflowBasicSerializer()
workflows_completed_monthly = IJLEmployeeCountSerializer(many=True)
class Meta:
model = User
fields = ('first_name', 'last_name', 'email',
'time_spent_on_workflows', 'number_of_workflows_assigned',
'number_of_tasks', 'total_time_spent_on_tasks',
'avg_time_spent_on_tasks', 'max_time_spent_on_tasks',
'min_time_spent_on_tasks', 'total_time_spent_on_workflows',
'avg_time_spent_on_workflows', 'max_time_spent_on_workflows',
'min_time_spent_on_workflows', 'last_task_completed',
'last_workflow_completed', 'workflows_completed_monthly')
class BehaviourSafetyABCVehicleRowSerializer(serializers.Serializer):
vehicleId = serializers.CharField(read_only=True)
vehicleName = serializers.CharField(read_only=True)
score = serializers.FloatField(read_only=True)
distance = serializers.FloatField(read_only=True)
duration = serializers.DurationField(read_only=True)
aPerThousand = serializers.FloatField(read_only=True)
aCount = serializers.IntegerField(read_only=True)
bPerThousand = serializers.FloatField(read_only=True)
bCount = serializers.IntegerField(read_only=True)
cPerThousand = serializers.FloatField(read_only=True)
cCount = serializers.IntegerField(read_only=True)
speedingDistance = serializers.FloatField(read_only=True)
idleDuration = serializers.DurationField(read_only=True)
class SongSerializer(serializers.Serializer):
id = serializers.IntegerField(label='ID', read_only=True)
added_at = serializers.DateTimeField(read_only=True)
name = serializers.CharField(max_length=128)
lyrics = serializers.CharField(allow_blank=True, required=False, style={'base_template': 'textarea.html'})
listenings = serializers.IntegerField(read_only=True)
album = serializers.HyperlinkedRelatedField(queryset=Album.objects.all(), view_name='album-detail')
album_name = serializers.CharField(source='album.name', read_only=True)
owner_name = serializers.CharField(source='album.owner.username', read_only=True)
image = serializers.ImageField(source='album.image', read_only=True)
playlist_set = serializers.HyperlinkedRelatedField(allow_empty=True, many=True,
view_name='playlist-detail', read_only=True)
song_duration = serializers.DurationField()
audio_file = serializers.FileField(allow_null=True, max_length=100, required=False)
def validate_album(self, value):
if value.owner != self.context['request'].user:
raise serializers.ValidationError("Current user isn't author of album")
return value
def update(self, instance, validated_data):
instance.name = validated_data.get('name', instance.name)
instance.lyrics = validated_data.get('lyrics', instance.lyrics)
instance.album = validated_data.get('album', instance.lyrics)
instance.song_duration = validated_data.get('song_duration', instance.song_duration)
instance.audio_file = validated_data.get('audio_file', instance.audio_file)
return instance
def create(self, validated_data):
return Song.objects.create(**validated_data)
def save(self, **kwargs):
super(SongSerializer, self).save(**kwargs)
class LessonSerializer(serializers.ModelSerializer):
class Meta:
model = Lesson
fields = ('id', 'student_id', 'questions', 'lesson_type', 'start_time',
'end_time', 'expected_duration', 'title', 'target_ids',
'planned_start_time')
questions = QuestionSerializer(many=True, read_only=True)
lesson_type = serializers.ChoiceField(allow_blank=True,
default=Lesson.TYPE_LECTURE,
choices=Lesson.TYPES)
target_ids = serializers.ListField(child=serializers.IntegerField(),
write_only=True)
planned_start_time = serializers.DateTimeField(default=timezone.now)
expected_duration = serializers.DurationField(default='60')
def save(self):
# target_ids may need to be validated if they belongs to the current user
target_ids = self.validated_data.pop('target_ids', [])
student_id = self.context['request'].user.id
lesson = super().save(student_id=student_id)
Question.objects.bulk_create([
Question(lesson=lesson, target_id=target_id)
for target_id in target_ids
])
return lesson
class ResolvedPatternOutDto(BaseDto):
from_time = serializers.DurationField(required=True)
until_time = serializers.DurationField(required=True)
days_of_week = serializers.CharField(required=True, max_length=255)
days_of_month = serializers.CharField(required=True, max_length=255)
months = serializers.CharField(required=True, max_length=255)
@classmethod
def from_pattern(cls, pattern: SimpleRecurringPattern):
dto = cls()
dto.from_time = pattern.from_time
dto.until_time = pattern.until_time
dto.days_of_week = pattern.days_of_week
dto.days_of_month = pattern.days_of_month
dto.months = pattern.months
return dto
class AIConstraintsSerializer(serializers.Serializer):
def __init__(self, schedule=None, *args, **kwargs):
self.schedule = schedule
super(AIConstraintsSerializer, self).__init__(*args, **kwargs)
duration = serializers.DurationField(required=True)
start_time = serializers.TimeField(required=True)
end_time = serializers.TimeField(required=True)
start_date = serializers.DateField(required=True)
end_date = serializers.DateField(required=True)
def SimpleBruteForceSearch(self):
start_time = self.validated_data['start_time']
end_time = self.validated_data['end_time']
start_date = self.validated_data['start_date']
end_date = self.validated_data['end_date']
duration = self.validated_data['duration']
assert self.schedule, "No Schedule error"
return GradientDecentAI(start_time=start_time,
end_time=end_time,
start_date=start_date,
end_date=end_date,
duration=duration,
schedule=self.schedule,
timezone=self.schedule.owner.timezone)
class BookingSerializer(serializers.Serializer):
# Dates and time
start_date = serializers.DateField(required=True)
duration = serializers.DurationField(required=True)
# Bikes and extras
number_adult_bikes = serializers.ChoiceField(
choices=[(number, '%s' % (number)) for number in range(1, 10)])
number_child_bikes = serializers.ChoiceField(
choices=[(number, '%s' % (number)) for number in range(1, 3)])
number_extras = serializers.MultipleChoiceField(
choices=BikeExtra.objects.all())
# Lunches
number_veg_lunches = serializers.IntegerField(
validators=[positive_integer])
number_meat_lunches = serializers.IntegerField(
validators=[positive_integer])
number_fish_lunches = serializers.IntegerField(
validators=[positive_integer])
# Guest info
first_name = serializers.CharField(max_length=25)
last_name = serializers.CharField(max_length=25)
phone_number = serializers.CharField(max_length=25, required=False)
email = serializers.EmailField()
newsletter = serializers.BooleanField(
default=True, help_text='Vill du ha nyheter och erbjudanden från oss?')
# Extra message
other = serializers.CharField(max_length=200)
class FlightSchedulerSerializer(serializers.Serializer):
period = serializers.IntegerField(required=True)
time_of_flight = serializers.TimeField(required=True)
flight_number = serializers.CharField(required=True, max_length=4)
flight_duration = serializers.DurationField(max_value=timedelta(hours=24),
required=True)
departure_airport = serializers.PrimaryKeyRelatedField(
required=True, queryset=reservation_models.Airport.objects.all())
arrival_airport = serializers.PrimaryKeyRelatedField(
required=True, queryset=reservation_models.Airport.objects.all())
def validate_arrival_airport(self, arrival_airport):
if self.initial_data.get('departure_airport',
None) == arrival_airport.code:
raise serializers.ValidationError(
'Arrival airport cant be same as departure.')
return arrival_airport
def validate_departure_airport(self, departure_airport):
if self.initial_data.get('arrival_airport',
None) == departure_airport.code:
raise serializers.ValidationError(
'Arrival airport cant be same as departure.')
return departure_airport
class EndServiceSerializer(serializers.ModelSerializer):
""" Start the service with the time of server. """
service_end = serializers.DateTimeField()
is_active = serializers.BooleanField()
total_cost = serializers.DecimalField(max_digits=7, decimal_places=2)
duration = serializers.DurationField()
class Meta:
""" Meta Class. """
model = Service
fields = ('service_end', 'is_active', 'total_cost', 'duration')
def validate_service_end(self, data):
""" Validate if the service start in the date. """
date = data.strftime("%A")
service_start = self.context['service'].service_start
if service_start:
if service_start < data:
return data
else:
raise serializers.ValidationError(
'The time of service end must be great than service start')
else:
raise serializers.ValidationError(
'The service still does not start')
def validate_is_active(self, data):
""" Validate if the service is in this moment active. """
is_active = self.context['service'].is_active
if is_active != data:
return data
else:
raise serializers.ValidationError('The service was finish before')
class FeatureSerializer(serializers.ModelSerializer):
created_at = serializers.SerializerMethodField()
title = serializers.CharField()
slug = serializers.SlugField(read_only=True)
turn_duration = serializers.DurationField(read_only=True)
guests = serializers.SerializerMethodField()
presenter_channel = serializers.CharField()
class Meta:
model = Feature
exclude = ["updated_at"]
def get_created_at(self, instance):
return instance.created_at.strftime("%B %d, %Y")
def get_guests(self, instance):
result = []
for session_key in instance.guest_queue:
session_store = get_session(session_key)
session_store["id"] = session_key
result.append(session_store)
return result
def get_presenter_channel(self, instance):
result = []
for session_key in instance.guest_queue:
session_store = get_session(session_key)
session_store["id"] = session_key
result.append(session_store)
return result
class MonitoringSummarySerializer(serializers.Serializer):
""" Serializer for Monitoring summary
"""
last_monitoring = MonitoringSerializer()
avg_response_time = serializers.DurationField()
avg_availability_percent = serializers.FloatField()
class ProgrammeSerializer(serializers.ModelSerializer):
runtime = serializers.DurationField()
photo = serializers.ImageField()
class Meta:
model = Programme
fields = ('id', 'slug', 'name', 'synopsis', 'runtime', 'photo', 'language', 'category')
class ScheduleSerializer(serializers.HyperlinkedModelSerializer):
file_id = serializers.IntegerField(source="file.id", read_only=True)
stream_id = serializers.IntegerField(source="stream.id", read_only=True)
instance_id = serializers.IntegerField(source="instance.id", read_only=True)
cue_out = serializers.DurationField(source="get_cueout", read_only=True)
ends = serializers.DateTimeField(source="get_ends", read_only=True)
class Meta:
model = Schedule
fields = [
"item_url",
"id",
"starts",
"ends",
"file",
"file_id",
"stream",
"stream_id",
"clip_length",
"fade_in",
"fade_out",
"cue_in",
"cue_out",
"media_item_played",
"instance",
"instance_id",
"playout_status",
"broadcasted",
"position",
]
class WorkflowReportSerializer(serializers.ModelSerializer):
unique_assignees = EmployeeBasicSerializer(many=True)
total_time_spend = serializers.DurationField()
number_of_assignees = serializers.IntegerField(min_value=0)
number_of_tasks = serializers.IntegerField(min_value=0)
average_task_complete_time = serializers.DurationField()
assingee_with_min_time = assingeeTimeSerializer()
assingee_with_max_time = assingeeTimeSerializer()
creator = EmployeeBasicSerializer()
class Meta:
model = Workflow
fields = ('name', 'status', 'start_at', 'completed_at', 'creator',
'unique_assignees', 'total_time_spend',
'number_of_assignees', 'number_of_tasks',
'average_task_complete_time', 'assingee_with_min_time',
'assingee_with_max_time')
class SerializerSearchMetaData(serializers.Serializer):
completed_in = serializers.DurationField()
max_id = serializers.IntegerField()
max_id_str = serializers.CharField()
next_results = serializers.CharField(required=False)
query = serializers.CharField()
count = serializers.IntegerField()
since_id = serializers.IntegerField()
since_id_str = serializers.CharField()
class MediationChatSerializer(serializers.Serializer):
session_id = serializers.IntegerField()
starttime = serializers.DateTimeField(default=datetime.now() -
timedelta(minutes=5))
interval = serializers.DurationField(default=timedelta(minutes=5))
endtime = serializers.DateTimeField(default=datetime.now())
semantics = serializers.FloatField(default=0.0)
parameter = serializers.IntegerField()
strategy = serializers.IntegerField()
class PlanIntervalSerializer(PlanSubscriptionSerializer):
duration = serializers.DurationField()
def create(self, validated_data):
return models.PlanInterval(
profile=self._get_profile(validated_data),
plan=validated_data['plan'],
duration=validated_data['duration'],
)
class ProgrammeSerializer(serializers.ModelSerializer):
runtime = serializers.DurationField()
photo_url = AbsoluteURLField(source='photo.url', read_only=True)
rss_url = AbsoluteURLField(source='slug', reverse_url='programmes:rss')
class Meta:
model = Programme
fields = ('id', 'slug', 'name', 'synopsis', 'runtime', 'photo_url',
'rss_url', 'language', 'category')
class FindingAidsGridSerializer(serializers.ModelSerializer):
time_start = serializers.DurationField()
time_end = serializers.DurationField()
original_locale = serializers.SlugRelatedField(
slug_field='locale_name', queryset=Locale.objects.all())
def to_internal_value(self, data):
date_from = data.get('date_from', None)
date_to = data.get('date_to', None)
time_start = data.get('time_start', None)
time_end = data.get('time_end', None)
duration = data.get('duration', None)
locale = data.get('original_locale', None)
if time_start:
hours, minutes, seconds = time_start.split(':')
data['time_start'] = datetime.timedelta(hours=int(hours),
minutes=int(minutes),
seconds=int(seconds))
if time_end:
hours, minutes, seconds = time_end.split(':')
data['time_end'] = datetime.timedelta(hours=int(hours),
minutes=int(minutes),
seconds=int(seconds))
if duration:
hours, minutes, seconds = duration.split(':')
data['duration'] = datetime.timedelta(hours=int(hours),
minutes=int(minutes),
seconds=int(seconds))
if date_from:
data['date_from'] = change_date(date_from, 'date_from')
if date_to:
data['date_to'] = change_date(date_to, 'date_to')
if locale:
data['original_locale'] = Locale.objects.get(locale_name=locale)
return data
class Meta:
model = FindingAidsEntity
fields = ('id', 'digital_version_exists', 'archival_reference_code',
'original_locale', 'title', 'title_original',
'contents_summary', 'contents_summary_original', 'date_from',
'date_to', 'time_start', 'time_end', 'duration', 'note',
'note_original')
class ExampleSerializer(serializers.Serializer):
charfield = serializers.CharField(min_length=1, max_length=2)
integerfield = serializers.IntegerField(min_value=1, max_value=2)
floatfield = serializers.FloatField(min_value=1, max_value=2)
decimalfield = serializers.DecimalField(max_digits=10,
decimal_places=1,
min_value=1,
max_value=2)
durationfield = serializers.DurationField(min_value=1, max_value=2)
listfield = serializers.ListField(min_length=1, max_length=2)
class StatusSerializer(serializers.Serializer):
remaning_time = serializers.DurationField()
def get_initial(self):
user = self.context['request'].user
remaning_time = get_user_remaning_time(user)
return {
'remaning_time': remaning_time,
'is_expired': not remaning_time,
}
class SprintSerializer(serializers.HyperlinkedModelSerializer):
team = serializers.SlugRelatedField(
queryset=Team.objects.all(),
slug_field='name'
)
left_to_end = serializers.DurationField(read_only=True)
class Meta:
model = Sprint
fields = '__all__'
class CheckSlotSerializer(serializers.Serializer):
date = serializers.DateTimeField()
duration = serializers.DurationField()
walker_id = serializers.IntegerField()
def checkslot(self):
date = self.validated_data['date']
duration = self.validated_data['date']
walker = Walker.objects.get(id=self.validated_data['id'])
slots = walker.slots(date, duration)
return (slots)
class BillSerializer(serializers.ModelSerializer):
start_date = serializers.DateField(read_only=True,
help_text='The call start date')
start_time = serializers.TimeField(read_only=True,
help_text='The call start time')
duration = serializers.DurationField(read_only=True,
help_text='The call duration')
class Meta:
model = Bill
fields = ('id', 'start_date', 'start_time', 'duration', 'price')
class PigletsSimpleSerializer(serializers.ModelSerializer):
# metatour_repr = serializers.ReadOnlyField()
week_tour = serializers.StringRelatedField(source='metatour.week_tour')
age = serializers.DurationField()
class Meta:
model = Piglets
fields = [
'id', 'quantity', 'gilts_quantity', 'transfer_part_number',
'birthday', 'week_tour', 'age'
]
class UserSerializer(serializers.Serializer):
pk = serializers.IntegerField()
nickname = serializers.CharField(max_length=30)
score = serializers.IntegerField(default=0)
ac_sub = serializers.DictField(child=serializers.IntegerField())
problem_time = serializers.DictField(child=serializers.DurationField())
problem_sub = serializers.DictField(child=serializers.IntegerField())
def toJson(self):
return JSONRenderer().render(self.data)
class SimplePatternOutDto(BaseDto):
id = serializers.IntegerField(required=True)
acl_id = serializers.IntegerField(required=True)
from_time = serializers.DurationField(required=True)
until_time = serializers.DurationField(required=True)
days_of_week = serializers.ListField(required=True)
days_of_month = serializers.ListField(required=True)
months = serializers.ListField(required=True)
@classmethod
def from_simple_pattern(cls, pattern: SimpleRecurringPattern):
dto = cls()
dto.id = pattern.id
dto.acl_id = pattern.acl.id
dto.from_time = pattern.from_time
dto.until_time = pattern.until_time
dto.days_of_week = pattern.get_days_of_week()
dto.days_of_month = pattern.get_days_of_month()
dto.months = pattern.get_months()
return dto
class ResponseSerializer(serializers.ModelSerializer):
answers = AnswerSerializer(many=True, required=False)
created_at = serializers.DateTimeField(required=False)
time_spent = serializers.DurationField(required=False)
is_frozen = serializers.BooleanField(required=False)
class Meta(object):
model = Response
fields = ('slug', 'created_at', 'time_spent', 'is_frozen', 'answers')
read_only_fields = ('slug', )
