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'
