class ActivitySerializer(ModelSerializer):
"""Activity serializer."""
duration = DurationField(read_only=True)
user = ResourceRelatedField(read_only=True, default=CurrentUserDefault())
task = ResourceRelatedField(queryset=Task.objects.all(),
allow_null=True,
required=False)
blocks = ResourceRelatedField(read_only=True, many=True)
included_serializers = {
'blocks': 'timed.tracking.serializers.ActivityBlockSerializer',
'task': 'timed.projects.serializers.TaskSerializer',
'user': '******',
}
class Meta:
"""Meta information for the activity serializer."""
model = models.Activity
fields = [
'comment',
'start_datetime',
'duration',
'user',
'task',
'blocks',
]
class ReportSerializer(ModelSerializer):
"""Report serializer."""
task = ResourceRelatedField(queryset=Task.objects.all())
activity = ResourceRelatedField(queryset=models.Activity.objects.all(),
allow_null=True,
required=False)
user = ResourceRelatedField(read_only=True,
default=CurrentUserDefault())
included_serializers = {
'task': 'timed.projects.serializers.TaskSerializer',
'user': '******'
}
class Meta:
"""Meta information for the report serializer."""
model = models.Report
fields = [
'comment',
'date',
'duration',
'review',
'not_billable',
'task',
'activity',
'user',
]
class AbsenceSerializer(ModelSerializer):
"""Absence serializer."""
duration = DurationField(read_only=True)
type = ResourceRelatedField(queryset=AbsenceType.objects.all())
user = ResourceRelatedField(read_only=True,
default=CurrentUserDefault())
included_serializers = {
'user': '******',
}
def validate(self, data):
"""Validate the absence data.
An absence should not be created on a public holiday or a weekend.
:returns: The validated data
:rtype: dict
"""
location = Employment.objects.for_user(
data.get('user'),
data.get('date')
).location
if PublicHoliday.objects.filter(
location_id=location.id,
date=data.get('date')
).exists():
raise ValidationError(
'You can\'t create an absence on a public holiday'
)
workdays = [int(day) for day in location.workdays]
if data.get('date').isoweekday() not in workdays:
raise ValidationError('You can\'t create an absence on a weekend')
return data
class Meta:
"""Meta information for the absence serializer."""
model = models.Absence
fields = [
'comment',
'date',
'duration',
'type',
'user',
]
class ReportSerializer(ModelSerializer):
"""Report serializer."""
task = ResourceRelatedField(queryset=Task.objects.all())
activity = ResourceRelatedField(queryset=models.Activity.objects.all(),
allow_null=True,
required=False)
user = ResourceRelatedField(read_only=True, default=CurrentUserDefault())
included_serializers = {
'task': 'timed.projects.serializers.TaskSerializer',
'user': '******'
}
def validate_date(self, value):
"""Only owner is allowed to change date."""
if self.instance is not None:
user = self.context['request'].user
owner = self.instance.user
if self.instance.date != value and user != owner:
raise ValidationError('Only owner may change date')
return value
def validate_duration(self, value):
"""Only owner is allowed to change duration."""
if self.instance is not None:
user = self.context['request'].user
owner = self.instance.user
if self.instance.duration != value and user != owner:
raise ValidationError('Only owner may change duration')
return value
class Meta:
"""Meta information for the report serializer."""
model = models.Report
fields = [
'comment',
'date',
'duration',
'review',
'not_billable',
'task',
'activity',
'user',
]
class AttendanceSerializer(ModelSerializer):
"""Attendance serializer."""
user = ResourceRelatedField(read_only=True, default=CurrentUserDefault())
included_serializers = {
'user': '******',
}
class Meta:
"""Meta information for the attendance serializer."""
model = models.Attendance
fields = [
'from_datetime',
'to_datetime',
'user',
]
def __init__(self, *args, **kwargs):
kwargs["default"] = CurrentUserDefault()
super().__init__(*args, **kwargs)
class ReportSerializer(ModelSerializer):
"""Report serializer."""
task = ResourceRelatedField(queryset=Task.objects.all())
activity = ResourceRelatedField(queryset=models.Activity.objects.all(),
allow_null=True,
required=False)
user = ResourceRelatedField(read_only=True, default=CurrentUserDefault())
verified_by = ResourceRelatedField(queryset=get_user_model().objects,
required=False,
allow_null=True)
included_serializers = {
'task': 'timed.projects.serializers.TaskSerializer',
'user': '******',
'verified_by': 'timed.employment.serializers.UserSerializer'
}
def validate_date(self, value):
"""Only owner is allowed to change date."""
if self.instance is not None:
user = self.context['request'].user
owner = self.instance.user
if self.instance.date != value and user != owner:
raise ValidationError(_('Only owner may change date'))
return value
def validate_verified_by(self, value):
user = self.context['request'].user
current_verified_by = self.instance and self.instance.verified_by
if value == current_verified_by:
# no validation needed when nothing has changed
return value
if value is None and user.is_staff:
# staff is allowed to reset verified by
return value
if value is not None and user.is_staff and value == user:
# staff user is allowed to set it's own user as verified by
return value
raise ValidationError(_('Only staff user may verify reports.'))
def validate_duration(self, value):
"""Only owner is allowed to change duration."""
if self.instance is not None:
user = self.context['request'].user
owner = self.instance.user
if self.instance.duration != value and user != owner:
raise ValidationError(_('Only owner may change duration'))
return value
class Meta:
"""Meta information for the report serializer."""
model = models.Report
fields = [
'comment',
'date',
'duration',
'review',
'not_billable',
'verified_by',
'task',
'activity',
'user',
]
class AbsenceSerializer(ModelSerializer):
"""Absence serializer."""
duration = SerializerMethodField(source='get_duration')
type = ResourceRelatedField(queryset=AbsenceType.objects.all())
user = ResourceRelatedField(read_only=True, default=CurrentUserDefault())
included_serializers = {
'user': '******',
'type': 'timed.employment.serializers.AbsenceTypeSerializer',
}
def get_duration(self, instance):
try:
employment = Employment.objects.get_at(instance.user,
instance.date)
except Employment.DoesNotExist:
# absence is invalid if no employment exists on absence date
return duration_string(timedelta())
return duration_string(instance.calculate_duration(employment))
def validate_date(self, value):
"""Only owner is allowed to change date."""
if self.instance is not None:
user = self.context['request'].user
owner = self.instance.user
if self.instance.date != value and user != owner:
raise ValidationError(_('Only owner may change date'))
return value
def validate_type(self, value):
"""Only owner is allowed to change type."""
if self.instance is not None:
user = self.context['request'].user
owner = self.instance.user
if self.instance.date != value and user != owner:
raise ValidationError(_('Only owner may change absence type'))
return value
def validate(self, data):
"""Validate the absence data.
An absence should not be created on a public holiday or a weekend.
:returns: The validated data
:rtype: dict
"""
try:
location = Employment.objects.get_at(data.get('user'),
data.get('date')).location
except Employment.DoesNotExist:
raise ValidationError(
_('You can\'t create an absence on an unemployed day.'))
if PublicHoliday.objects.filter(location_id=location.id,
date=data.get('date')).exists():
raise ValidationError(
_('You can\'t create an absence on a public holiday'))
workdays = [int(day) for day in location.workdays]
if data.get('date').isoweekday() not in workdays:
raise ValidationError(
_('You can\'t create an absence on a weekend'))
return data
class Meta:
"""Meta information for the absence serializer."""
model = models.Absence
fields = [
'comment',
'date',
'duration',
'type',
'user',
]
class ReportSerializer(TotalTimeRootMetaMixin, ModelSerializer):
"""Report serializer."""
task = ResourceRelatedField(queryset=Task.objects.all())
activity = ResourceRelatedField(queryset=models.Activity.objects.all(),
allow_null=True,
required=False)
user = ResourceRelatedField(read_only=True, default=CurrentUserDefault())
verified_by = ResourceRelatedField(queryset=get_user_model().objects,
required=False,
allow_null=True)
included_serializers = {
'task': 'timed.projects.serializers.TaskSerializer',
'user': '******',
'verified_by': 'timed.employment.serializers.UserSerializer'
}
def validate_date(self, value):
"""Only owner is allowed to change date."""
if self.instance is not None:
user = self.context['request'].user
owner = self.instance.user
if self.instance.date != value and user != owner:
raise ValidationError(_('Only owner may change date'))
return value
def validate_duration(self, value):
"""Only owner is allowed to change duration."""
if self.instance is not None:
user = self.context['request'].user
owner = self.instance.user
if self.instance.duration != value and user != owner:
raise ValidationError(_('Only owner may change duration'))
return value
def validate(self, data):
"""Validate that verified by is only set by reviewer or superuser."""
user = self.context['request'].user
current_verified_by = self.instance and self.instance.verified_by
new_verified_by = data.get('verified_by')
task = data.get('task') or self.instance.task
if new_verified_by != current_verified_by:
is_reviewer = (user.is_superuser or
task.project.reviewers.filter(id=user.id).exists())
if not is_reviewer:
raise ValidationError(_('Only reviewer may verify reports.'))
if new_verified_by is not None and new_verified_by != user:
raise ValidationError(
_('You may only verifiy with your own user'))
return data
class Meta:
model = models.Report
fields = [
'comment',
'date',
'duration',
'review',
'not_billable',
'task',
'activity',
'user',
'verified_by',
]
