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', ]