class StaffAbsenceSerializer(StaffUserDecisionBySerializer): user = StaffByUserSerializer('user', required=False) decision_by = StaffByUserSerializer('decision_by', required=False, allow_null=True) start_date = DateField(required=False, allow_null=True) end_date = DateField(required=False, allow_null=True) class Meta: model = Absence fields = FIELDS
def get_queryset(self): item_id = self.kwargs.get(self.lookup_field) first_day = timezone.now().replace(day=1).date() start = DateField().to_internal_value( self.request.query_params.get('start')) or first_day end = DateField().to_internal_value( self.request.query_params.get('end')) or (first_day + timedelta(days=31)) return EventClass.objects.get(id=item_id).get_calendar(start, end).values()
def get_queryset(self): first_day = timezone.now().replace(day=1).date() start = DateField().to_internal_value( self.request.query_params.get('start').split('T')[0] ) or first_day end = DateField().to_internal_value( self.request.query_params.get('end').split('T')[0] ) or (first_day + timedelta(days=31)) events = [] for ec in EventClass.objects.in_range(start, end): events.extend(list(ec.get_calendar(start, end).values())) return events
def get(self, request: Request): user = self.request.user theses_ready_for_review = Thesis.objects.filter( Q(supervisor=user) | Q(opponent=user), state=Thesis.State.READY_FOR_REVIEW, ).exclude(review_thesis__user=user) reservations_ready_for_prepare = () if self.request.user.has_perm('thesis.change_reservation'): reservations_ready_for_prepare = Reservation.objects.filter( state=Reservation.State.CREATED, ) theses_just_submitted = () if self.request.user.has_perm('thesis.change_thesis'): theses_just_submitted = Thesis.objects.filter( state=Thesis.State.SUBMITTED, ) author_theses = Thesis.objects.filter(authors=user, ) author_theses_serializer: ListSerializer = ThesisBaseSerializer( many=True, instance=author_theses) # dynamically add submit_deadline to standard thesis serializer author_theses_serializer.child.fields['submit_deadline'] = DateField() return Response(data=dict( theses_ready_for_review=ThesisBaseSerializer( many=True, instance=theses_ready_for_review).data, reservations_ready_for_prepare=ReservationSerializer( many=True, instance=reservations_ready_for_prepare).data, theses_just_submitted=ThesisBaseSerializer( many=True, instance=theses_just_submitted).data, author_theses=author_theses_serializer.data, ))
class BlogPage(Page): published_date = models.DateField("Post date") intro = models.CharField(max_length=250) body = RichTextField(blank=True) search_fields = Page.search_fields + [ index.SearchField('intro'), index.SearchField('body'), ] content_panels = Page.content_panels + [ FieldPanel('published_date'), FieldPanel('intro'), FieldPanel('body', classname="full"), ] # Export fields over the API api_fields = [ APIField('published_date'), # Date in ISO8601 format (the default) APIField( 'published_date_display', serializer=DateField(format='%A $d %B %Y', source='published_date') ), # A separate published_date_display field with a different format APIField('body'), APIField( 'authors' ), # This will nest the relevant BlogPageAuthor objects in the API response ]
class DailyProductivityLogCreateUpdateSerializer( BaseCreateUpdateSerializer, ModelValidatorsMixin ): # allow an regular isoformat of milliseconds also be passed date = DateField(input_formats=["iso-8601"]) source = ChoiceField(choices=BETTERSELF_LOG_INPUT_SOURCES, default=WEB_INPUT_SOURCE) mistakes = CharField(trim_whitespace=True, default="", allow_blank=True) class Meta: model = DailyProductivityLog fields = ( "source", "date", "very_productive_time_minutes", "productive_time_minutes", "neutral_time_minutes", "distracting_time_minutes", "very_distracting_time_minutes", "pomodoro_count", "notes", "mistakes", "user", ) def validate(self, validated_data): user = self.context["request"].user is_creating_instance = not self.instance if is_creating_instance: if self.Meta.model.objects.filter( user=user, date=validated_data["date"], ).exists(): raise ValidationError(f"Fields user and date need to be unique!") return validated_data
class GameResultsSerializer(ModelSerializer): date = DateField(format="%Y/%m/%d") def create(self, validated_data): game_result = super(GameResultsSerializer, self).create(validated_data) token = Token.objects.create(game_result=game_result) send_game_results_email(player=validated_data['player'], scores={ 'stage1Score': validated_data['stage1Score'], 'stage2Score': validated_data['stage2Score'], 'stage3Score': validated_data['stage3Score'], 'stage4Score': validated_data['stage4Score'], }, host=self.context['request'].get_host(), game_result=game_result, token=token) if self.context['request'].GET.get('push') == 'true': push_players() return game_result class Meta: model = GameResult list_serializer_class = FilteredGameResultsSerializer fields = '__all__'
class NewsLinkSerializer(Serializer): id = IntegerField(read_only=True) title = CharField(max_length=63) slug = SlugField(max_length=63) pub_date = DateField() link = URLField(max_length=255) startup = StartupSerializer()
def format_date_or_datetime(value): """ Formats a date or datetime using DRF fields. This is for use in tests when comparing dates and datetimes with JSON-formatted values. """ if isinstance(value, datetime): return DateTimeField().to_representation(value) return DateField().to_representation(value)
class StartupSerializer(Serializer): id = IntegerField(read_only=True) name = CharField(max_length=31) slug = SlugField(max_length=31) description = CharField() founded_date = DateField() contact = EmailField() website = URLField(max_length=255) tags = TagSerializer(many=True)
def test_to_native_with_item_field(self): """ When a ListField has an item-field, to_native should return a list of elements resulting from the application of the item-field's to_native method to each element of the input object list. """ field = ListField(DateField(format=ISO_8601)) obj = [date(2000, 1, 1), date(2000, 1, 2)] data = field.to_native(obj) self.assertEqual(["2000-01-01", "2000-01-02"], data)
def test_from_native_with_item_field(self): """ When a ListField has an item-field, from_native should return a list of elements resulting from the application of the item-field's from_native method to each element of the input data list. """ field = ListField(DateField()) data = ["2000-01-01", "2000-01-02"] obj = field.from_native(data) self.assertEqual([date(2000, 1, 1), date(2000, 1, 2)], obj)
def test_to_native_with_value_field(self): """ When a DictField has an value-field, to_native should return a dict of elements resulting from the application of the value-field's to_native method to each value of the input object dict. """ field = DictField(DateField(format=ISO_8601)) obj = {"a": date(2000, 1, 1), "b": date(2000, 1, 2)} data = field.to_native(obj) self.assertEqual({"a": "2000-01-01", "b": "2000-01-02"}, data)
def test_from_native_with_value_field(self): """ When a DictField has an value-field, from_native should return a dict of elements resulting from the application of the value-field's from_native method to each value of the input data dict. """ field = DictField(DateField()) data = {"a": "2000-01-01", "b": "2000-01-02"} obj = field.from_native(data) self.assertEqual({"a": date(2000, 1, 1), "b": date(2000, 1, 2)}, obj)
class ArticlesSerializer(serializers.ModelSerializer): title = CharField(validators=[required]) excerpt = CharField(validators=[required]) text = CharField(validators=[required]) date_created = DateField(validators=[required]) date_updated = DateField(validators=[required]) writer = WritersSerializer(validators=[required]) def create(self, validated_data): writer_data = validated_data.pop('writer') article = Articles.objects.create(**validated_data, writer=Writers.objects.create( **writer_data)) return article class Meta: model = Articles fields = ('id', 'title', 'excerpt', 'text', 'date_created', 'date_updated', 'writer')
class BillSerializer(Serializer): ''' Serializes a `CompletedCall` queryset into as a bill. ''' calls = BillCompletedCallSerializer(many=True) total = SerializerMethodField() period = DateField(format=PERIOD_FORMAT) source = RegexField(PHONE_REGEX) def get_total(self, obj): if obj['calls']: return sum(call.price for call in obj['calls'])
class AggregrateViewParamsSerializer(Serializer): start_date = DateField() end_date = DateField() supplement_uuids = ListField( child=UUIDField(validators=[generic_model_uuid_validator(Supplement)]), required=False, ) activity_uuids = ListField( child=UUIDField(validators=[generic_model_uuid_validator(Activity)]), required=False, ) food_uuids = ListField( child=UUIDField(validators=[generic_model_uuid_validator(Food)]), required=False ) class Meta: fields = ( "start_date", "end_date", "supplement_uuids", "activity_uuids", "food_uuids", )
class ThesisFullPublicSerializer(ThesisBaseSerializer): category = CategorySerializer(read_only=True) category_id = PrimaryKeyRelatedField( write_only=True, source='category', allow_null=True, required=False, queryset=Category.objects.all(), ) published_at = DateField(format="%Y/%m", required=False, read_only=True) reservable = BooleanField(read_only=True, source='_reservable') # set by queryset from viewset submit_deadline = DateField(required=False, allow_null=True) class Meta: model = Thesis fields = ThesisBaseSerializer.Meta.fields + ( 'registration_number', 'published_at', 'category', 'category_id', 'available_for_reservation', 'reservable', 'open_reservations_count', 'submit_deadline', )
class UserSerializer(serializers.ModelSerializer): # images = serializers.SlugRelatedField( # many=True, # read_only=True, # slug_field='photo' # ) # images = ImageSerializer() # images = serializers.HyperlinkedRelatedField(many=True, view_name='api:images-detail', read_only=True) birth = DateField(format='%d.%m.%Y', input_formats=None) class Meta: model = User fields = ('id', 'name', 'surname', 'age', 'birth', 'images')
class BillInputSerializer(Serializer): ''' Serializes and validate a `Bill` get request. ''' source = RegexField(PHONE_REGEX) period = DateField(required=False, format=PERIOD_FORMAT, input_formats=[PERIOD_FORMAT], default=_todays_period) def get_bill_data(self): calls_queryset = CompletedCall.objects.get_bill_queryset( **self.validated_data) serializer = BillSerializer({ 'calls': calls_queryset, 'period': self.validated_data['period'], 'source': self.validated_data['source'] }) return serializer.data
class BlogPage(Page): date = models.DateField("Post date") intro = models.CharField(max_length=250) body = RichTextField(blank=True) search_fields = Page.search_fields + [ index.SearchField('intro'), index.SearchField('body'), ] content_panels = Page.content_panels + [ FieldPanel('date'), FieldPanel('intro'), FieldPanel('body', classname="full"), ] api_fields = [ APIField('pub_date', serializer=DateField(format='%d %B %Y', source='date')), APIField('body'), ]
class serializer_class(Serializer): id = IntegerField() date = DateField() headline = HighlightField() mediumid = IntegerField() medium = CharField() creator = CharField() byline = CharField() addressee = CharField() section = CharField() url = CharField() length = IntegerField() page = IntegerField() def __init__(self, *args, **kwargs): Serializer.__init__(self, *args, **kwargs) ctx = kwargs.get("context", {}) columns = ctx.get("columns", []) queries = ctx.get("queries", None) if ctx.get('minimal'): for fn in list(self.fields): if fn != 'id' and fn not in list(columns): del self.fields[fn] if "hits" in columns and queries: for q in queries: self.fields[q.label] = ScoreField() if "text" in columns: self.fields['text'] = CharField() if "projectid" in columns: self.fields['projectid'] = IntegerField() if "lead" in columns: self.fields['lead'] = HighlightField() if "kwic" in columns: self.fields['left'] = KWICField(kwic='left') self.fields['keyword'] = KWICField(kwic='keyword') self.fields['right'] = KWICField(kwic='right')
class serializer_class(Serializer): id = IntegerField() date = DateField() headline = HighlightField() mediumid = IntegerField() medium = CharField() author = CharField() addressee = CharField() length = IntegerField() def __init__(self, *args, **kwargs): Serializer.__init__(self, *args, **kwargs) ctx = kwargs.get("context", {}) columns = ctx.get("columns", []) queries = ctx.get("queries", None) if "hits" in columns and queries: for q in queries: self.fields[q.label] = ScoreField() if "text" in columns: self.fields['text'] = CharField() if "lead" in columns: self.fields['lead'] = HighlightField()
class ProfileQuerySerializer(Serializer): """GET Profiles list query serializer.""" orderable_fields = ('full_name', 'date_created', 'rating', 'location') default_ordering = '-rating' order_by = CharField(default=default_ordering) full_name = CharField(required=False) registered_before = DateField(required=False) min_rating = IntegerField(required=False) online = BooleanField(required=False, allow_null=True, default=None) def validate_order_by(self, order_by): if not order_by.removeprefix('-') in self.orderable_fields: return self.default_ordering return order_by def to_representation(self, validated_data): filters = {} if full_name := validated_data.get('full_name'): filters['full_name__icontains'] = full_name if registered_before := validated_data.get('registered_before'): filters['date_created__lt'] = registered_before
class DateRangeField(RangeField): child = DateField() range_type = DateRange
def parse_date(value): """Parses a date from a string.""" return _parse_value(value, DateField())
class SubscriptionSerializer(serializers.Serializer): cardHolderName = CharField(min_length=4, max_length=40, required=True) cardNumber = CharField(min_length=16, max_length=40, required=True) expiry = DateField(required=True) cvc = CharField(max_length=4, required=True)
def list_archive_dates(self, request, *args, **kwargs): dates = Post.objects.dates('created_time', 'month', order='DESC') date_field = DateField() data = [date_field.to_representation(date) for date in dates] return Response(data=data, status=status.HTTP_200_OK)
class MetadataSerializer(Serializer): sam_load_date = DateField() fpds_load_date = DateField()
# CharField, TextField CharField(allow_blank=False), { 'type': 'string' }, ), ( # CharField, TextField CharField(trim_whitespace=False), { 'type': 'string' }, ), ( # DateField DateField(), { 'type': 'string', 'format': 'date' }, ), ( # DateTimeField DateTimeField(), { 'type': 'string', 'format': 'date-time' }, ), ( # DecimalField