class MovieSerializer(serializers.ModelSerializer): id = serializers.IntegerField() name = serializers.CharField(max_length=50) score = serializers.IntegerField() author_id = serializers.IntegerField() class Meta: model = Movie fields = '__all__'
class VideoSerializer(serializers.Serializer): dependency_count = serializers.SerializerMethodField() duration = serializers.IntegerField() license_name = serializers.SerializerMethodField() license_url = serializers.SerializerMethodField() name = serializers.CharField(max_length=100) url = serializers.URLField() stream_url = serializers.URLField() image_url = serializers.URLField() provider_name = serializers.CharField(max_length=100) tags = serializers.SerializerMethodField() def get_dependency_count(self, obj): data = self.context.get(obj.id) if data: return data.get('dep_count', 0) return 0 def get_license_name(self, obj): value = obj.license_name if value is None or len(value) == 0: return None return value def get_license_url(self, obj): value = obj.license_url if value is None or len(value) == 0: return None return value def get_tags(self, obj): sorted_categories = sorted( obj.categories, key=lambda cat: obj.categories.get(cat, 'weight', default=0)) return ','.join([cat.name for cat in sorted_categories])
def __init__(self, *args, **kwargs): # super hates my additional kwargs sparse = kwargs.pop('sparse', False) version_serializer = kwargs.pop('version_serializer', False) super(BaseShareSerializer, self).__init__(*args, **kwargs) if sparse: # clear the fields if they asked for sparse self.fields.clear() else: # remove hidden fields excluded_fields = ['change', 'sources'] for field_name in tuple(self.fields.keys()): if 'version' in field_name or field_name in excluded_fields: self.fields.pop(field_name) # version specific fields if version_serializer: self.fields.update({ 'action': serializers.CharField(max_length=10), 'persistent_id': serializers.IntegerField() }) # add fields with improper names self.fields.update({ 'type': fields.TypeField(), })
class ExamSerializer(serializers.ModelSerializer): test_assignment_id = serializers.IntegerField() questions = serializers.SerializerMethodField() results = serializers.SerializerMethodField() class Meta: model = Exam fields = [ 'id', 'test_assignment_id', 'user', 'results', 'questions', ] read_only_fields = ['user', 'progress'] def get_results(self, obj): return obj.test_results() def get_questions(self, obj): # todo serialize many questions serializer = QuestionSerializer(obj.test_assignment.questions.all(), many=True) return serializer.data def create(self, validated_data): from afi_backend.exams.api.serializers import QuestionSerializer # Create Exam using test_assignment_id test_assignment = TestAssignment.objects.get( id=validated_data['test_assignment_id']) exam = Exam.objects.create(user=self.context['request'].user, test_assignment=test_assignment) return exam
class AuthorSerializer(serializers.ModelSerializer): id = serializers.IntegerField() name = serializers.CharField(max_length=50) email = serializers.CharField(max_length=30) class Meta: model = Author fields = '__all__'
class KeywordedResponseSerializer(serializers.ModelSerializer): class Meta: model = KeywordedResponse fields = '__all__' id = serializers.IntegerField(read_only=True) keyword = serializers.CharField(read_only=True) response = serializers.CharField(read_only=True)
class IgnoreNumberSerializer(serializers.ModelSerializer): class Meta: model = IgnoreNumber fields = '__all__' id = serializers.IntegerField(read_only=True) number = serializers.CharField(read_only=True) note = serializers.CharField(read_only=True)
class NewMemberNoticeSerializer(serializers.ModelSerializer): class Meta: model = NewMemberNotice fields = '__all__' id = serializers.IntegerField(read_only=True) title = serializers.CharField(read_only=True) response = serializers.CharField(read_only=True)
class WriteonlyTestSerializer(serializers.ModelSerializer): '''Serializer for testing the absence of write_only fields''' comments = serializers.ResourceRelatedField( many=True, write_only=True, queryset=Comment.objects.all()) rating = serializers.IntegerField(write_only=True) class Meta: model = Entry fields = ('comments', 'rating')
class OrganismRetriveSerializer(OrganismSerializer): count = serializers.IntegerField(required=False) class Meta: model = m_models.Organism exclude = ( 'id', 'ancestors', )
class TokenProxySerializer(serializers.ModelSerializer): username = serializers.CharField(write_only=True, required=False) password = serializers.CharField(write_only=True, required=False) municipality = serializers.IntegerField(required=False) token = serializers.SerializerMethodField() def get_token(self, obj): client = HousingStatClient() token_resp = client.get_token(username=obj.username, password=obj.password) if token_resp["success"] is True: return token_resp["token"] raise ValidationError({ token_resp["status_code"]: { "source": "external", "reason": token_resp["reason"], } }) def create(self, validated_data): user = self.context["request"].user username = validated_data.get("username") password = validated_data.get("password") municipality = validated_data.get("municipality") if username and password and municipality: user_creds, _ = models.HousingStatCreds.objects.update_or_create( owner=user.username, defaults={ "username": username, "password": password, "municipality": municipality, }, ) else: user_creds = models.HousingStatCreds.objects.filter( owner=user.username) user_creds.update(**validated_data) user_creds = user_creds.first() if not user_creds: raise ValidationError({ 400: { "source": "internal", "reason": f'No housing stat credentials found for user "{user.username}"', } }) return user_creds class Meta: model = models.HousingStatCreds fields = ("username", "password", "token", "municipality")
class ExamProgressSerializer(serializers.Serializer): answer_id = serializers.IntegerField(source='chosen_aswers.id', read_only=True) chosen_answers = AnswerSerializer(read_only=True, many=True) class Meta: model = Progress fields = [ 'answer_id', 'chosen_answers', ]
class UserSerializer(serializers.ModelSerializer): id = serializers.IntegerField(read_only=True) first_name = serializers.CharField(read_only=True) last_name = serializers.CharField(read_only=True) class Meta: model = User fields = [ "id", "first_name", "last_name", "available_from", "available_to", "facebook_link", "interests" ] read_only_fields = ["id", "first_name", "last_name", "facebook_link"]
class KeggOrthologRetrieveSerializer(m_serializers.DynamicDocumentSerializer, serializers.HyperlinkedModelSerializer): url = serializers.HyperlinkedIdentityField( view_name='emgapi_v1:kegg-orthologs-detail', lookup_field='accession', ) count = serializers.IntegerField(required=True) class Meta: model = m_models.KeggOrtholog fields = '__all__'
class GoTermRetriveSerializer(m_serializers.DynamicDocumentSerializer, serializers.HyperlinkedModelSerializer): url = serializers.HyperlinkedIdentityField( view_name='emgapi_v1:goterms-detail', lookup_field='accession', ) count = serializers.IntegerField(required=False) class Meta: model = m_models.GoTerm fields = '__all__'
class EntrySerializer(serializers.Serializer): blog = serializers.IntegerField() comments = CommentSerializer(many=True, required=False) comment = CommentSerializer(required=False) headline = serializers.CharField(allow_null=True, required=True) body_text = serializers.CharField() def validate(self, attrs): body_text = attrs['body_text'] if len(body_text) < 5: raise serializers.ValidationError({'body_text': { 'title': 'Too Short title', 'detail': 'Too short'} })
def __new__(cls, name, bases, attrs): new_class = super().__new__(cls, name, bases, attrs) new_class._declared_fields["id"] = serializers.IntegerField( read_only=True) for fieldname, field in json_api_model._meta.fields.items(): if (isinstance(field, fields.Attribute) and not isinstance(field, fields.Relationship) and (only_fields is None or fieldname in only_fields)): new_class._declared_fields[fieldname] = MAPPING.get( field.__class__, serializers.ReadOnlyField, )(read_only=True) return new_class
class EntrySerializer(serializers.Serializer): blog = serializers.IntegerField() comments = CommentSerializer(many=True, required=False) comment = CommentSerializer(required=False) headline = serializers.CharField(allow_null=True, required=True) body_text = serializers.CharField() def validate(self, attrs): body_text = attrs["body_text"] if len(body_text) < 5: raise serializers.ValidationError( {"body_text": {"title": "Too Short title", "detail": "Too short"}} )
class AntiSmashGeneClusterRetrieveSerializer( m_serializers.DynamicDocumentSerializer, serializers.HyperlinkedModelSerializer): url = serializers.HyperlinkedIdentityField( view_name='emgapi_v1:antismash-gene-clusters-detail', lookup_field='accession', ) count = serializers.IntegerField(required=True) class Meta: model = m_models.AntiSmashGeneCluster fields = '__all__'
class HistoryVideoSerializer(serializers.Serializer): count = serializers.SerializerMethodField() date = serializers.SerializerMethodField() duration = serializers.IntegerField() url = serializers.URLField() image_url = serializers.URLField() license_name = serializers.SerializerMethodField() license_url = serializers.SerializerMethodField() name = serializers.CharField(max_length=100) progress = serializers.SerializerMethodField() provider_name = serializers.CharField(max_length=100) stream_url = serializers.URLField() tags = serializers.SerializerMethodField() def get_date(self, obj): data = self.context.get(obj.id) if data: return data[0] return '1970-01-01' def get_count(self, obj): data = self.context.get(obj.id) if data: return data[1] return 1 def get_progress(self, obj): data = self.context.get(obj.id) if data: return data[2] return 1 def get_license_name(self, obj): value = obj.license_name if value is None or len(value) == 0: return None return value def get_license_url(self, obj): value = obj.license_url if value is None or len(value) == 0: return None return value def get_tags(self, obj): sorted_categories = sorted( obj.categories, key=lambda cat: obj.categories.get(cat, 'weight', default=0)) return ','.join([cat.name for cat in sorted_categories])
class CourseLectureSerializer(serializers.ModelSerializer): included_serializers = { 'lecturer': events_serializers.LecturerSerializer, } part = serializers.CharField(source='part.name') part_id = serializers.IntegerField(source='part.id') tests = TestAssignmentSerializer(many=True, read_only=True) class Meta: model = CourseLecture fields = [ 'course', 'description', 'lecturer', 'name', 'part', 'part_id', 'vimeo_video_id', 'tests', ]
class CartOrderItemSerializer(serializers.ModelSerializer): item_type = serializers.CharField() object_id = serializers.IntegerField() customer_email = serializers.EmailField() class Meta: model = OrderItem fields = ['item_type', 'object_id', 'customer_email'] def create(self, validated_data): content_type = ContentType.objects.get( model=validated_data['item_type']) user = User.objects.get(email=validated_data['customer_email']) order_item = OrderItem.objects.create( customer=user, content_type=content_type, object_id=validated_data['object_id']) return order_item
class FlowResultsResponseSerializer(serializers.Serializer): """ FlowResultsResponseSerializer for handling publishing of Flow Results Response package. """ id = serializers.CharField() # pylint: disable=invalid-name responses = serializers.ListField() duplicates = serializers.IntegerField(read_only=True) class JSONAPIMeta: # pylint: disable=old-style-class,no-init,R0903 """ JSON API metaclass. """ resource_name = 'responses' def create(self, validated_data): duplicates = 0 request = self.context['request'] responses = validated_data['responses'] uuid = UUID(validated_data['id']) xform = get_object_or_404(XForm, Q(uuid=str(uuid)) | Q(uuid=uuid.hex), deleted_at__isnull=True) for submission in parse_responses(responses): xml_file = BytesIO( dict2xform(submission, xform.id_string, 'data').encode('utf-8')) error, _instance = safe_create_instance(request.user.username, xml_file, [], None, request) if error and error.status_code != 202: raise serializers.ValidationError(error) if error and error.status_code == 202: duplicates += 1 return FlowResultsResponse(xform.uuid, responses, duplicates) def update(self, instance, validated_data): pass
class ChangedFieldSerializer(serializers.Serializer): title = serializers.CharField(max_length=200, required=False) priority = serializers.IntegerField(min_value=1, max_value=5, required=False) resolution = serializers.CharField(required=False) due_date = serializers.DateTimeField(required=False, allow_null=True) assigned_to = serializers.PrimaryKeyRelatedField( required=False, allow_null=True, queryset=Person.objects.all( ) # TODO restrict this queryset to something more sensible ) signaled_by = serializers.PrimaryKeyRelatedField( required=False, allow_null=True, queryset=Person.objects.all()) organization = serializers.PrimaryKeyRelatedField( required=False, allow_null=True, queryset=Organization.objects.all()) department = serializers.PrimaryKeyRelatedField( required=False, allow_null=True, queryset=Team.objects.all())
class GenericForeignKeySerializer(ContentTypeFieldSerializer): """ Serializer class that provides fields and methods for dealing with generic foreign keys """ target_id = serializers.IntegerField(source='target_object_id', required=False) def validate(self, attrs): """ Validate target id """ if self.instance is not None: # we are doing an update target_id = attrs.get('target_object_id', self.instance.target_object_id) target_model_contenttype = attrs.get( 'target_content_type', self.instance.target_content_type) else: # we are creating a new object target_id = attrs.get('target_object_id') target_model_contenttype = attrs.get('target_content_type') # Target_id is not required as such this may be none # If target_id is none there is no need to validate it if target_id is not None: target_model_class = target_model_contenttype.model_class() try: target_model_class.objects.get(pk=target_id) except target_model_class.DoesNotExist: raise serializers.ValidationError( {'target_id': TARGET_DOES_NOT_EXIST}) return attrs return attrs
class ItemSerializer(serializers.ModelSerializer): sale = get_ResourceRelatedField('items', 'sales', queryset=Sale.objects) group = get_ResourceRelatedField('items', 'itemgroups', queryset=ItemGroup.objects) usertype = get_ResourceRelatedField('items', 'usertypes', queryset=UserType.objects) fields = get_ResourceRelatedField('items', 'fields', queryset=Field.objects, many=True, required=False) quantity_left = serializers.IntegerField(read_only=True) included_serializers = { 'itemfields': 'sales.serializers.ItemFieldSerializer', 'sale': 'sales.serializers.SaleSerializer', 'itemgroup': ItemGroupSerializer, 'usertype': UserTypeSerializer, } class Meta: model = Item fields = '__all__' # DEBUG # fields = ('id', 'name', 'description', 'remaining_quantity', # 'initial_quantity','sale_id', 'itemspecifications') class JSONAPIMeta: # included_resources = ['itemgroup', 'sale', 'usertype'] pass
class DummySerializer(serializers.Serializer): body = serializers.CharField() id = serializers.IntegerField()
class CustomModelSerializer(serializers.Serializer): body = serializers.CharField() id = serializers.IntegerField()
class ProjectSerializer(serializers.Serializer): id = serializers.IntegerField() name = serializers.CharField()
class RoomNodeInstallationSerializer(serializers.HyperlinkedModelSerializer): included_serializers = { "node": "core.serializers.NodeSerializer", "room": "core.serializers.RoomSerializer", # "timeseries": "core.serializers.TimeseriesSerializer", } node = ResourceRelatedField( queryset=Node.objects.all(), related_link_url_kwarg="installation_pk", related_link_view_name="installation-related-node", ) room = ResourceRelatedField( queryset=Room.objects.all(), related_link_view_name="installation-related" ) to_timestamp_s = serializers.IntegerField(required=False) # Image of the installation (optional). Handle upload in a separate serializer. image = serializers.ImageField(required=False, read_only=True) # Additional fields to merge the node installation with its samples. timeseries = serializers.ListField(child=SimpleSampleSerializer(), read_only=True) query_timestamp_s = serializers.IntegerField(read_only=True) sample_count = serializers.IntegerField(read_only=True) url = serializers.HyperlinkedIdentityField(view_name="installation-detail") class Meta: model = RoomNodeInstallation fields = [ "room", "node", "timeseries", "query_timestamp_s", "from_timestamp_s", "to_timestamp_s", "sample_count", "description", "image", "is_public", "url", ] def __init__(self, *args, **kwargs): # Don't pass the "include_timeseries" arg up to the superclass include_timeseries = kwargs.pop("include_timeseries", None) # Instantiate the superclass normally super().__init__(*args, **kwargs) if not include_timeseries: self.fields.pop("timeseries") def get_owner(self): """Return the owner of the resource, once data is validated.""" room = self.validated_data["room"] site = room.site owner = site.operator return owner def validate(self, attrs): """ Ensure that the node is owned by the same organization as the room. """ logger.debug( "For a new or updated installation, validate that node and room belong to the same owner." ) try: room = attrs["room"] node = attrs["node"] except KeyError: raise serializers.ValidationError( "Both the Room reference and the node reference must be provided." ) if room.site.operator != node.owner: raise serializers.ValidationError( "In an installation, Node and room must belong to the same owner." ) return attrs