class OrganizationSerializer(BaseInternalModelSerializer):
user_is_member = serializers.ReadOnlyField()
id = serializers.ReadOnlyField()
is_active = serializers.BooleanField(read_only=True)
avatar = RemoteFileField(required=False)
class Meta:
model = Organization
fields = (
'id',
'name',
'is_active',
'billing_email',
'billing_phone',
'billing_address_one',
'billing_name',
'billing_address_two',
'billing_city',
'billing_state',
'billing_zip_code',
'stripe_payment_tokens',
'plan_name',
'avatar',
'available_states',
'user_is_member',
'features',
'client_label',
'client_label_plural'
)
def create(self, validated_data):
org = Organization.objects.create(**validated_data)
org.is_active = True
org.save()
return org
class UserSerializer(serializers.ModelSerializer):
username = serializers.ReadOnlyField()
is_staff = serializers.ReadOnlyField()
user_groups = UserGroupSerializer(many=True, read_only=True)
gravatar = serializers.CharField(source='generate_gravatar',
read_only=True)
class Meta:
model = User
fields = ('id', 'username', 'first_name', 'last_name', 'is_staff',
'user_groups', 'locale', 'remote_avatar', 'gravatar')
class CardSerializer(serializers.ModelSerializer):
id = serializers.ReadOnlyField()
grammarCard = GrammarCardSerializer(read_only=True)
class Meta:
model = Card
fields = ('id', 'front', 'back', 'flip', 'grammarCard')
class KoylaSerializer(serializers.ModelSerializer):
id = serializers.ReadOnlyField()
grammarCard = GrammarCardSerializer(read_only=True)
class Meta:
model = Koyla
fields = ('id', 'word', 'la', 'comment', 'grammarCard')
class FloipListSerializer(serializers.HyperlinkedModelSerializer):
"""
FloipListSerializer class.
"""
url = serializers.HyperlinkedIdentityField(view_name='flow-results-detail',
lookup_field='uuid')
id = ReadOnlyUUIDField(source='uuid') # pylint: disable=C0103
name = serializers.ReadOnlyField(source='id_string')
created = serializers.ReadOnlyField(source='date_created')
modified = serializers.ReadOnlyField(source='date_modified')
class JSONAPIMeta: # pylint: disable=old-style-class,no-init,R0903
"""
JSON API metaclass.
"""
resource_name = 'packages'
class Meta:
model = XForm
fields = ('url', 'id', 'name', 'title', 'created', 'modified')
def test_extract_attributes():
fields = {
'id': serializers.Field(),
'username': serializers.Field(),
'deleted': serializers.ReadOnlyField(),
}
resource = {'id': 1, 'deleted': None, 'username': '******'}
expected = {'username': '******', 'deleted': None}
assert sorted(JSONRenderer.extract_attributes(
fields,
resource)) == sorted(expected), 'Regular fields should be extracted'
assert sorted(JSONRenderer.extract_attributes(fields, {})) == sorted(
{'username':
''}), 'Should not extract read_only fields on empty serializer'
def test_extract_attributes():
fields = {
"id": serializers.Field(),
"username": serializers.Field(),
"deleted": serializers.ReadOnlyField(),
}
resource = {"id": 1, "deleted": None, "username": "******"}
expected = {"username": "******", "deleted": None}
assert sorted(JSONRenderer.extract_attributes(
fields,
resource)) == sorted(expected), "Regular fields should be extracted"
assert sorted(JSONRenderer.extract_attributes(fields, {})) == sorted(
{"username":
""}), "Should not extract read_only fields on empty serializer"
class MembershipSerializer(serializers.ModelSerializer):
included_serializers = {
"organization": "core.serializers.OrganizationSerializer",
"user": "******",
}
user_name = serializers.ReadOnlyField(source="user.username")
organization_name = serializers.ReadOnlyField(source="organization.name")
organization = ResourceRelatedField(
allow_null=False,
required=True,
queryset=Organization.objects.all(),
related_link_view_name="membership-related",
)
user = ResourceRelatedField(
allow_null=False,
required=True,
queryset=User.objects.all(),
related_link_view_name="membership-related",
)
class Meta:
model = Membership
fields = (
"organization",
"user",
"user_name",
"organization_name",
"role",
"url",
)
def get_owner(self):
"""Return the owner of the resource, once data is validated."""
return self.validated_data["organization"]
class AnonOrganizationSerializer(BaseInternalModelSerializer):
avatar = RemoteFileField(required=False)
user_is_member = serializers.ReadOnlyField()
class Meta:
model = Organization
fields = (
'id',
'name',
'avatar',
'features',
'client_label',
'client_label_plural',
'user_is_member'
)
class OrderLineSerializer(serializers.ModelSerializer):
"""
Defines how the OrderLine fields are serialized
"""
order = serializers.ReadOnlyField(source='order.id')
item = ResourceRelatedField(queryset=Item.objects,
related_link_view_name='orderlineitem-list',
related_link_url_kwarg='orderline_pk',
self_link_view_name='orderline-relationships')
included_serializers = {
'item': ItemSerializer,
}
class Meta:
model = OrderLine
fields = ('id', 'order', 'item', 'quantity')
class JSONAPIMeta:
included_resources = ['item']
class SalePSerializer(serializers.ModelSerializer):
"""
Defines how the Sale fields are serialized, without the payment methods
"""
association = serializers.ReadOnlyField(source='association.name')
items = ResourceRelatedField(queryset=Item.objects,
many=True,
related_link_view_name='item-list',
related_link_url_kwarg='sale_pk',
self_link_view_name='sale-relationships')
included_serializers = {'items': ItemSerializer}
class Meta:
model = Sale
fields = ('id', 'name', 'description', 'creation_date', 'begin_date',
'end_date', 'max_payment_date', 'max_item_quantity',
'association', 'items')
class JSONAPIMeta:
included_resources = ['items']
class RelatedModelSerializer(serializers.ModelSerializer):
blog = serializers.ReadOnlyField(source="entry.blog")
class Meta:
model = Comment
fields = ("id", "blog")
class IntroSerializer(serializers.ModelSerializer):
id = serializers.ReadOnlyField()
class Meta:
model = Intro
fields = ('id', 'title', 'body')
class AlphabetSerializer(serializers.ModelSerializer):
id = serializers.ReadOnlyField()
class Meta:
model = Alphabet
fields = ('id', 'letter', 'name', 'example')
class FloipSerializer(serializers.HyperlinkedModelSerializer):
"""
FloipSerializer class.
"""
url = serializers.HyperlinkedIdentityField(view_name='floip-detail',
lookup_field='pk')
profile = serializers.SerializerMethodField()
created = serializers.ReadOnlyField(source='date_created')
modified = serializers.ReadOnlyField(source='date_modified')
# pylint: disable=invalid-name
flow_results_specification_version = serializers.SerializerMethodField()
resources = serializers.SerializerMethodField()
class JSONAPIMeta: # pylint: disable=old-style-class,no-init,R0903
"""
JSON API metaclass.
"""
resource_name = 'packages'
class Meta:
model = XForm
fields = ('url', 'id', 'id_string', 'title', 'profile', 'created',
'modified', 'flow_results_specification_version',
'resources')
def get_profile(self, value): # pylint: disable=no-self-use,W0613
"""
Returns the data-package profile.
"""
return 'data-package'
# pylint: disable=no-self-use,unused-argument
def get_flow_results_specification_version(self, value):
"""
Returns the flow results specification version.
"""
return '1.0.0-rc1'
def get_resources(self, value): # pylint: disable=no-self-use,W0613
"""
Returns empty dict, a dummy holder for the eventually generated data
package resources.
"""
return {}
def _process_request(self, request, update_instance=None):
data = deepcopy(request.data)
if 'profile' in data and data['profile'] == 'flow-results-package':
data['profile'] = 'data-package'
descriptor = BytesIO(json.dumps(data).encode('utf-8'))
descriptor.seek(0, os.SEEK_END)
floip_file = InMemoryUploadedFile(descriptor,
'floip_file',
request.data.get('name') + '.json',
'application/json',
descriptor.tell(),
charset=None)
kwargs = {
'user': request.user,
'post': None,
'files': {
'floip_file': floip_file
},
'owner': request.user,
}
if update_instance:
kwargs['id_string'] = update_instance.id_string
kwargs['project'] = update_instance.project
instance = do_publish_xlsform(**kwargs)
if isinstance(instance, XForm):
return instance
raise serializers.ValidationError(instance)
def create(self, validated_data):
request = self.context['request']
return self._process_request(request)
def update(self, instance, validated_data):
request = self.context['request']
return self._process_request(request, instance)
def to_representation(self, instance):
request = self.context['request']
data_id = str(UUID(instance.uuid))
data_url = request.build_absolute_uri(
reverse('flow-results-responses', kwargs={'uuid': data_id}))
package = survey_to_floip_package(json.loads(instance.json), data_id,
instance.date_created,
instance.date_modified, data_url)
data = package.descriptor
if data['profile'] != 'flow-results-package':
data['profile'] = 'flow-results-package'
return data
class GrammarCardSerializer(serializers.ModelSerializer):
id = serializers.ReadOnlyField()
class Meta:
model = GrammarCard
fields = ('id', 'title', 'body', 'comment', 'category')
class RelatedModelSerializer(serializers.ModelSerializer):
blog = serializers.ReadOnlyField(source='entry.blog')
class Meta:
model = Comment
fields = ('id', 'blog')
class HotelSerializer(serializers.ModelSerializer):
verbose_name = serializers.ReadOnlyField(source='__str__')
