class InstructorSerializer(HyperlinkedModelSerializer): """ (de-)serialize the Instructor model. """ class Meta(HyperlinkedModelSerializer.Meta): model = Instructor fields = "__all__" #: an instructor teaches zero or more course instances course_terms = ResourceRelatedField( model=CourseTerm, many=True, read_only=False, allow_null=True, required=False, queryset=CourseTerm.objects.all(), self_link_view_name='instructor-relationships', related_link_view_name='instructor-related', ) #: an instructor is a person person = ResourceRelatedField( model=Person, many=False, read_only=False, allow_null=True, required=False, queryset=Person.objects.all(), self_link_view_name='instructor-relationships', related_link_view_name='instructor-related') #: `{json:api} compound document <https://jsonapi.org/format/#document-compound-documents>`_ included_serializers = { 'course_terms': 'myapp.serializers.CourseTermSerializer', 'person': 'myapp.serializers.PersonSerializer', }
class UserSerializer(serializers.ModelSerializer): class Meta: model = User fields = ( "first_name", "last_name", "username", "password", "type", "categories", "url", ) categories = ResourceRelatedField(queryset=Category.objects, many=True) included_serializers = {"categories": CategorySerializer}
class CourseTermSerializer(HyperlinkedModelSerializer): """ (de-)serialize the CourseTerm model. """ class Meta(HyperlinkedModelSerializer.Meta): model = CourseTerm #: a course_term has zero or one parent courses course = ResourceRelatedField( model=Course, many=False, read_only=False, allow_null=True, required=False, queryset=Course.objects.all(), self_link_view_name='course_term-relationships', related_link_view_name='course_term-related', ) #: a course_term can have many instructors instructors = ResourceRelatedField( model=Instructor, many=True, read_only=False, allow_null=True, required=False, queryset=Instructor.objects.all(), self_link_view_name='course_term-relationships', related_link_view_name='course_term-related', ) #: ``?include=course`` or ``?include=instructors`` #: `{json:api} compound document <https://jsonapi.org/format/#document-compound-documents>`_ included_serializers = { 'course': 'myapp.serializers.CourseSerializer', 'instructors': 'myapp.serializers.InstructorSerializer', }
class GeneSerializer(TermSerializer): diseases = ResourceRelatedField(model=DiseaseGeneAssociation, many=True, read_only=True) class Meta: model = Gene fields = '__all__' included_serializers = { 'diseases': 'core.serializers.DiseaseGeneAssociationSerializer' } class JSONAPIMeta: included_resources = ['diseases']
class FormFieldSerializer(WebDjangoSerializer): form = ResourceRelatedField( many=False, queryset=Form.objects, related_link_url_kwarg='pk', self_link_view_name='form-field-relationships', required=False, ) included_serializers = { 'form': 'libs.core.cms.api.serializers.FormSerializer.FormSerializer', } class Meta: model = FormField fields = '__all__'
class MessageSerializer(serializers.ModelSerializer): included_serializers = { 'user': UserSerializer, } message = serializers.CharField(required=True) user = ResourceRelatedField(read_only=True) class Meta: model = Message fields = ('id', 'user', 'message', 'created', 'modified') class JSONAPIMeta: included_resources = ['user']
class PaymentIntentSerializer(serializers.ModelSerializer): intent_id = serializers.CharField(read_only=True) client_secret = serializers.CharField(read_only=True) donation = ResourceRelatedField(queryset=Donation.objects.all()) included_serializers = { 'donation': 'bluebottle.funding.serializers.DonationSerializer', } class Meta(object): model = PaymentIntent fields = ('intent_id', 'client_secret', 'donation') class JSONAPIMeta(PaymentSerializer.JSONAPIMeta): resource_name = 'payments/stripe-payment-intents'
class ApplicantTransitionSerializer(TransitionSerializer): resource = ResourceRelatedField(queryset=Applicant.objects.all()) field = 'states' included_serializers = { 'resource': 'bluebottle.assignments.serializers.ApplicantSerializer', 'resource.activity': 'bluebottle.assignments.serializers.AssignmentSerializer', } class JSONAPIMeta(object): resource_name = 'contributions/applicant-transitions' included_resources = [ 'resource', 'resource.activity', ]
class ActionSerializer(serializers.HyperlinkedModelSerializer, ModelWithImageSerializerMixin): included_serializers = { 'plan': PlanSerializer, 'schedule': ActionScheduleSerializer, 'status': ActionStatusSerializer, 'categories': CategorySerializer, 'tasks': 'actions.api.ActionTaskSerializer', 'indicators': 'indicators.api.IndicatorSerializer', 'decision_level': ActionDecisionLevelSerializer, } tasks = ResourceRelatedField(queryset=ActionTask.objects, many=True) class Meta: model = Action exclude = ('order', )
class UpdateSerializer(BaseInternalModelSerializer): user = ResourceRelatedField(many=False, queryset=get_user_model().objects) included_serializers = { 'group': AnonGroupSerializer, 'page': PageSerializer, 'user': '******', 'files': FileSerializer, 'wrappers': 'proposals.api.app.serializers.WrapperSerializer' } group = ResourceRelatedField(many=False, queryset=Group.objects) page = ResourceRelatedField( pk_field=HashidSerializerCharField(source_field='groups.Page.id'), queryset=Page.objects.all(), many=False) organization = ResourceRelatedField(many=False, queryset=Organization.objects) files = ResourceRelatedField(many=True, queryset=File.objects, required=False) links = ResourceRelatedField(many=True, queryset=Link.objects, required=False) wrappers = ResourceRelatedField(many=True, queryset=Wrapper.objects, required=False) reports = ResourceRelatedField(many=True, queryset=Report.objects, required=False) document = serializers.JSONField(required=False) class Meta: model = Update fields = ('id', 'user', 'group', 'organization', 'page', 'document', 'title', 'published', 'reports', 'wrappers', 'files', 'links', 'created', 'modified') class JSONAPIMeta: included_resources = [ 'user', 'page', 'page.organization', 'group', 'files', 'wrappers', 'wrappers.bill', 'wrappers.bill.sponsor' ]
class CategorySerializer(serializers.ModelSerializer): included_serializers = { 'items': ItemSerializer } items = ResourceRelatedField( queryset=Item.objects, many=True, default=[] ) class Meta: model = Category fields = ('id', 'name', 'estimated', 'project', 'items', 'actual', 'created_at', 'updated_at') class JSONAPIMeta: included_resources = ['items']
class TermSerializer(HyperlinkedModelSerializer): """ (de-)serialize Term """ class Meta: model = Term fields = '__all__' synonyms = ResourceRelatedField(model=Synonym, many=True, read_only=True) # {json:api} 'included' support included_serializers = { 'synonyms': 'core.serializers.SynonymSerializer', } # if not specified, then '?include=synonyms' must be added to the URL class JSONAPIMeta: included_resources = ['synonyms']
class MenuSerializer(WebDjangoSerializer): """ The serializer for Menu Objects """ menu_item = ResourceRelatedField(many=True, queryset=MenuItem.objects, related_link_url_kwarg='pk', self_link_view_name='menu-relationships', required=False) included_serializers = { 'menu_item': 'libs.core.cms.api.serializers.MenuItemSerializer.MenuItemSerializer', } class Meta: model = Menu fields = '__all__'
class PublicHolidaySerializer(ModelSerializer): """Public holiday serializer.""" location = ResourceRelatedField(read_only=True) included_serializers = { 'location': 'timed.employment.serializers.LocationSerializer' } class Meta: """Meta information for the public holiday serializer.""" model = models.PublicHoliday fields = [ 'name', 'date', 'location', ]
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', ]
class OrganizationInviteSerializer(BaseInternalModelSerializer): organization = ResourceRelatedField( many=False, read_only=True, ) def validate_username(self, value): """ Check if email is currently in use :return: """ try: User.objects.get(username=value) raise serializers.ValidationError("Email Already In Use") except User.DoesNotExist: pass return value def validate(self, attrs): """ We don't allow the frontend to dictate the invite's organization. :param attrs: :return: """ if not self.context.get('request').organization: raise serializers.ValidationError(detail="Cannot create invites without an organization") attrs['organization'] = self.context.get('request').organization return attrs class Meta: model = OrganizationInvite fields = ( 'id', 'metadata', 'created', 'modified', 'organization', 'organization_name', 'email', 'status', )
class AssociationSerializer(serializers.ModelSerializer): """ Defines how the Association fields are serialized """ sales = ResourceRelatedField( queryset=Sale.objects, many=True, related_link_view_name='sale-list', related_link_url_kwarg='association_pk', self_link_view_name='association-relationships') included_serializers = {'sales': SaleSerializer} class Meta: model = Association fields = ('id', 'name', 'bank_account', 'sales', 'foundation_id') class JSONAPIMeta: included_resources = ['sales']
class BaseBankAccountSerializer(ModelSerializer): status = FSMField(read_only=True) connect_account = ResourceRelatedField(queryset=PayoutAccount.objects.all()) class Meta(object): model = BankAccount fields = ( 'id', 'connect_account', 'status' ) included_serializers = { 'connect_account': 'bluebottle.funding.serializers.PayoutAccountSerializer', } class JSONAPIMeta(object): resource_name = 'payout-accounts/external-accounts'
class DonationSerializer(BaseContributionSerializer): amount = MoneySerializer() user = ResourceRelatedField( queryset=Member.objects.all(), default=serializers.CurrentUserDefault(), allow_null=True, required=False ) included_serializers = { 'activity': 'bluebottle.funding.serializers.FundingListSerializer', 'user': '******', 'reward': 'bluebottle.funding.serializers.RewardSerializer', } validators = [ IsRelatedToActivity('reward'), DonationMemberValidator(), reward_amount_matches, ] class Meta(BaseContributionSerializer.Meta): model = Donation fields = BaseContributionSerializer.Meta.fields + ('amount', 'name', 'reward', 'anonymous',) class JSONAPIMeta(BaseContributionSerializer.JSONAPIMeta): resource_name = 'contributions/donations' included_resources = [ 'user', 'activity', 'reward', ] def get_fields(self): """ If the donation is anonymous, we do not return the user. """ fields = super(DonationSerializer, self).get_fields() if isinstance(self.instance, Donation) and self.instance.anonymous: del fields['user'] return fields
class DashboardSerializer(ModelSerializer): widgets = ResourceRelatedField( many=True, queryset=Widget.objects, related_link_url_kwarg='widget_pk' ) class Meta: model = Dashboard fields = ( 'id', 'name', 'owner', 'widgets' ) class JSONAPIMeta: resource_name = 'dashboards'
class TeamSerializer(serializers.ModelSerializer): included_serializers = {'memberships': MembershipSerializer} memberships = ResourceRelatedField(queryset=Membership.objects, many=True, default=[]) class Meta: model = Team fields = ('created_at', 'updated_at', 'id', 'memberships', 'name') class JSONAPIMeta: included_resources = ['memberships'] def create(self, validated_data): team = Team(creator=validated_data['user'], name=validated_data['name']) team.save() return team
class RelationshipSerializer(HyperlinkedModelSerializer): class Meta: model = Relationship fields = '__all__' status = serializers.SerializerMethodField() references = ResourceRelatedField(model=Relationship, many=True, read_only=True) def get_status(self, obj): return obj.get_status() included_serializers = { 'references': 'core.serializers.ReferenceSerializer' } class JSONAPIMeta: included_resources = ['references']
class ActivityBlockSerializer(ModelSerializer): """Activity block serializer.""" duration = DurationField(read_only=True) activity = ResourceRelatedField(queryset=models.Activity.objects.all()) included_serializers = { 'activity': 'timed.tracking.serializers.ActivitySerializer', } def validate(self, data): """Validate the activity block. Ensure that a user can only have one activity with an active block. """ if self.instance: user = self.instance.activity.user to_datetime = data.get('to_datetime', self.instance.to_datetime) else: user = data.get('activity').user to_datetime = data.get('to_datetime', None) blocks = models.ActivityBlock.objects.filter(activity__user=user) if ( blocks.filter(to_datetime__isnull=True) and to_datetime is None ): raise ValidationError('A user can only have one active activity') return data class Meta: """Meta information for the activity block serializer.""" model = models.ActivityBlock fields = [ 'activity', 'duration', 'from_datetime', 'to_datetime', ]
class RoomSerializer(serializers.HyperlinkedModelSerializer): related_serializers = { "site": "core.serializers.SiteSerializer", "installations": "core.serializers.RoomNodeInstallationSerializer", } site = ResourceRelatedField( queryset=Site.objects.all(), related_link_url_kwarg="room_pk", related_link_view_name="room-related-site", ) #: A Room contains zero or more node installations. installations = HyperlinkedRelatedField( many=True, read_only=False, allow_null=True, required=False, queryset=RoomNodeInstallation.objects.all(), related_link_url_kwarg="room_pk", related_link_view_name="room-related-installations", ) class Meta: model = Room fields = [ "name", "description", "size_sqm", "height_m", "max_occupancy", "site", "installations", "url", ] def get_owner(self): """Return the owner of the resource, once data is validated.""" site = self.validated_data["site"] owner = site.operator return owner
class ActivityBlockSerializer(ModelSerializer): """Activity block serializer.""" activity = ResourceRelatedField(queryset=models.Activity.objects.all()) included_serializers = { 'activity': 'timed.tracking.serializers.ActivitySerializer', } def validate(self, data): """Validate the activity block. Ensure that a user can only have one activity with an active block which doesn't end before it started. """ instance = self.instance from_time = data.get('from_time', instance and instance.from_time) to_time = data.get('to_time', instance and instance.to_time) user = instance and instance.activity.user or data.get('activity').user # validate that there is only one active activity blocks = models.ActivityBlock.objects.filter(activity__user=user) if blocks.filter(to_time__isnull=True) and to_time is None: raise ValidationError( _('A user can only have one active activity')) # validate that to is not before from if to_time is not None and to_time < from_time: raise ValidationError( _('An activity block may not end before it starts.')) return data class Meta: """Meta information for the activity block serializer.""" model = models.ActivityBlock fields = [ 'activity', 'from_time', 'to_time', ]
class PaymentMethodSerializer(serializers.ModelSerializer): """ Defines how the PaymentMethod fields are serialized """ sales = ResourceRelatedField( queryset=Sale.objects, many=True, related_link_view_name='sale-payment-list', related_link_url_kwarg='payment_pk', self_link_view_name='paymentmethod-relationships') included_serializers = {'sales': SalePSerializer} class Meta: model = PaymentMethod fields = ('id', 'name', 'api_url', 'sales') class JSONAPIMeta: included_resources = ['sales']
class PaymentSerializer(ModelSerializer): status = FSMField(read_only=True) donation = ResourceRelatedField(queryset=Donation.objects.all()) transitions = AvailableTransitionsField() included_serializers = { 'donation': 'bluebottle.funding.serializers.DonationSerializer', } class Meta(object): model = Payment fields = ('donation', 'status', ) meta_fields = ('transitions', 'created', 'updated', ) class JSONAPIMeta(object): included_resources = [ 'donation', ] resource_name = 'payments'
def get_ResourceRelatedField(parent, child, queryset=None, read_only=False, many=False, **kwargs): route_type = 'list' # if many else 'detail' params = { 'many': many, 'related_link_view_name': "%s-%s-%s" % (parent, child, route_type), 'related_link_url_kwarg': parent + "_pk", 'self_link_view_name': parent + '-relationships', **kwargs } if queryset is None or read_only is True: params['read_only'] = True else: params['queryset'] = queryset return ResourceRelatedField(**params)
class AssociationMemberSerializer(serializers.ModelSerializer): """ Defines how the AssociationMember fields are serialized """ association = ResourceRelatedField( queryset=Association.objects, related_link_view_name='association-list', related_link_url_kwarg='associationmember_pk', self_link_view_name='associationmember-relationships') included_serializers = { 'association': AssociationSerializer, } class Meta: model = AssociationMember fields = ('id', 'association', 'role', 'rights') class JSONAPIMeta: included_resources = ['association']
class BudgetLineSerializer(ModelSerializer): activity = ResourceRelatedField(queryset=Funding.objects.all()) amount = MoneySerializer() validators = [FundingCurrencyValidator()] included_serializers = { 'activity': 'bluebottle.funding.serializers.FundingSerializer', } class Meta(object): model = BudgetLine fields = ('activity', 'amount', 'description') class JSONAPIMeta(object): included_resources = [ 'activity', ] resource_name = 'activities/budget-lines'