class VipRequestPortV3Serializer(DynamicFieldsModelSerializer): id = serializers.Field() options = serializers.SerializerMethodField('get_options') pools = serializers.SerializerMethodField('get_pools') def get_pools(self, obj): return self.extends_serializer(obj, 'pools') def get_options(self, obj): options = obj.options opt = {'l4_protocol': None, 'l7_protocol': None} for option in options: if option.optionvip.tipo_opcao == 'l4_protocol': opt['l4_protocol'] = option elif option.optionvip.tipo_opcao == 'l7_protocol': opt['l7_protocol'] = option return self.extends_serializer(opt, 'options') class Meta: VipRequestPort = get_model('api_vip_request', 'VipRequestPort') model = VipRequestPort fields = ( 'id', 'port', 'options', 'pools', 'identifier', ) default_fields = ( 'id', 'port', 'options', 'pools', ) def get_serializers(self): envvip_slz = get_app('api_environment_vip', module_label='serializers') if not self.mapping: self.mapping = { 'pools': { 'serializer': VipRequestPortPoolV3Serializer, 'kwargs': { 'many': True }, 'obj': 'pools', }, 'pools__details': { 'serializer': VipRequestPortPoolV3Serializer, 'kwargs': { 'many': True, 'kind': 'details' }, 'obj': 'pools' }, 'options': { 'keys': ( 'l4_protocol', 'l7_protocol', ), 'kwargs': {}, 'obj': 'optionvip_id' }, 'options__details': { 'keys': ( 'l4_protocol', 'l7_protocol', ), 'serializer': envvip_slz.OptionVipV3Serializer, 'kwargs': { 'kind': 'details' }, 'obj': 'optionvip', }, } return self.mapping
class CallrequestSerializer(serializers.HyperlinkedModelSerializer): """ **Create**: CURL Usage:: curl -u username:password --dump-header - -H "Content-Type:application/json" -X POST --data '{"request_uuid": "2342jtdsf-00123", "call_time": "2011-10-20 12:21:22", "phone_number": "8792749823", "content_type":"/rest-api/content_type/49/", "object_id":1, "timeout": "30000", "callerid": "650784355", "call_type": "1"}' http://localhost:8000/rest-api/callrequest/ Response:: HTTP/1.0 201 CREATED Date: Fri, 23 Sep 2011 06:08:34 GMT Server: WSGIServer/0.1 Python/2.7.1+ Vary: Accept-Language, Cookie Content-Type: text/html; charset=utf-8 Location: http://localhost:8000/api/app/callrequest/1/ Content-Language: en-us **Read**: CURL Usage:: curl -u username:password -H 'Accept: application/json' http://localhost:8000/rest-api/callrequest/ curl -u username:password -H 'Accept: application/json' http://localhost:8000/rest-api/callrequest/%callreq_id%/ Response:: { "meta":{ "limit":20, "next":null, "offset":0, "previous":null, "total_count":1 }, "objects":[ { "call_time":"2011-10-20T12:21:22", "call_type":1, "callerid":"650784355", "created_date":"2011-10-14T07:33:41", "extra_data":"", "extra_dial_string":"", "hangup_cause":"", "id":"1", "last_attempt_time":null, "num_attempt":0, "phone_number":"8792749823", "request_uuid":"2342jtdsf-00123", "resource_uri":"/api/v1/callrequest/1/", "result":"", "status":1, "timelimit":3600, "timeout":30000, "updated_date":"2011-10-14T07:33:41", "user":{ "first_name":"", "id":"1", "last_login":"******", "last_name":"", "resource_uri":"/api/v1/user/1/", "username":"******" }, } ] } **Update**: CURL Usage:: curl -u username:password --dump-header - -H "Content-Type: application/json" -X PUT --data '{"content_type":"/rest-api/content_type/49/", "object_id":1, "status": "5"}' http://localhost:8000/rest-api/callrequest/%callrequest_id%/ Response:: HTTP/1.0 204 NO CONTENT Date: Fri, 23 Sep 2011 06:46:12 GMT Server: WSGIServer/0.1 Python/2.7.1+ Vary: Accept-Language, Cookie Content-Length: 0 Content-Type: text/html; charset=utf-8 Content-Language: en-us """ user = serializers.Field(source='user') class Meta: model = Callrequest def get_fields(self, *args, **kwargs): """filter content_type field""" fields = super(CallrequestSerializer, self).get_fields(*args, **kwargs) request = self.context['request'] if request.method != 'GET': fields[ 'aleg_gateway'].queryset = request.user.userprofile.userprofile_gateway.all( ) if self.object and self.object: fields['content_type'].queryset = ContentType.objects.filter( model__in=["survey"]) else: fields['content_type'].queryset = ContentType.objects.filter( model__in=["survey_template"]) return fields
class RelativeUrlPaginationSerializer(BasePaginationSerializer): count = serializers.Field(source='paginator.count') next = RelativeNextPageField('*') previous = RelativePreviousPageField('*')
class PaginationMetadataSerializer(serializers.Serializer): length = serializers.Field(source='paginator.count') next = pagination.NextPageField(source='*') previous = pagination.PreviousPageField(source='*') page = serializers.Field(source='number') num_pages = serializers.Field(source='paginator.num_pages')
class CustomPaginationSerializer(pagination.BasePaginationSerializer): links = LinksSerializer(source='*') # Takes the page object as the source total_results = serializers.Field(source='paginator.count') results_field = 'objects'
class CustomPaginationSerializer(pagination.BasePaginationSerializer): next = pagination.NextPageField(source='*') prev = pagination.PreviousPageField(source='*') total_page = serializers.Field(source="paginator.num_pages") total_results = serializers.Field(source='paginator.count')
class ClientListSerializer(serializers.ModelSerializer): full_name = serializers.Field(source="get_full_name") class Meta: model = User fields = ('id', 'email', 'full_name', 'img')
class QueueSerializer(serializers.HyperlinkedModelSerializer): """ **Create**: CURL Usage:: curl -u username:password --dump-header - -H "Content-Type:application/json" -X POST --data '{"name": "queue name"}' http://localhost:8000/rest-api/queue/ Response:: HTTP/1.0 201 CREATED Date: Fri, 14 Jun 2013 09:52:27 GMT Server: WSGIServer/0.1 Python/2.7.3 Vary: Accept, Accept-Language, Cookie Content-Type: application/json; charset=utf-8 Content-Language: en-us Location: http://localhost:8000/rest-api/queue/1/ Allow: GET, POST, HEAD, OPTIONS **Read**: CURL Usage:: curl -u username:password -H 'Accept: application/json' http://localhost:8000/rest-api/queue/ Response:: { "count": 1, "next": null, "previous": null, "results": [ { "manager": "manager", "url": "http://127.0.0.1:8000/rest-api/queue/1/", "name": "Sample queue", "strategy": 5, "moh_sound": "", "record_template": "", "time_base_score": "queue", "tier_rules_apply": false, "tier_rule_wait_second": 300, "tier_rule_wait_multiply_level": true, "tier_rule_no_agent_no_wait": false, "discard_abandoned_after": 14400, "abandoned_resume_allowed": true, "max_wait_time": 0, "max_wait_time_with_no_agent": 120, "max_wait_time_with_no_agent_time_reached": 5, "created_date": "2013-10-23T12:34:20.157Z", "updated_date": "2013-10-23T12:34:20.157Z" } ] } **Update**: CURL Usage:: curl -u username:password --dump-header - -H "Content-Type: application/json" -X PUT --data '{"name": "change name"}' http://localhost:8000/rest-api/queue/%dqueue-id%/ Response:: HTTP/1.0 202 NO CONTENT Date: Fri, 23 Sep 2011 06:46:12 GMT Server: WSGIServer/0.1 Python/2.7.1+ Vary: Accept-Language, Cookie Content-Length: 0 Content-Type: text/html; charset=utf-8 Content-Language: en-us """ manager = serializers.Field(source='manager') class Meta: model = Queue
class EmbeddedContactSerializer(ContactSerializer): identity = serializers.Field(required=False, write_only=True) class Meta: fields = ('identity', 'context')
class PassageSerializer(serializers.ModelSerializer): owner = serializers.Field(source='user.username') class Meta: model = Passage fields = ('id', 'owner', 'user', 'date_created', 'passage_data')
class UserSerializers(serializers.ModelSerializer): users = serializers.Field('username', read_only=True) class Meta: model = Users fields = ('username ', )
class DetailPaginationSerializer(pagination.PaginationSerializer): per_page = serializers.Field(source='paginator.per_page') page_count = serializers.Field(source='paginator.num_pages')
def __init__(self, hybrid, contents=None, depth=None, *args, **kwargs): """ Initializes the serializer, mapping field types :param hybrid: Hybrid object to serialize :type hybrid: any (ovs.dal.hybrids.X.X) :param contents: Contents to serialize. Without contents, only the GUID is serialized When contents is given, all non-dynamic properties are serialized Further options are: - _dynamics: Include all dynamic properties - _relations: Include foreign keys and lists of primary keys of linked objects - _relations_contents: Apply the contents to the relations. The relation contents can be a bool or a new contents item - If the relations_contents=re-use: the current contents are also applied to the relation object - If the relations_contents=contents list: That item is subjected to the same rules as other contents - _relation_contents_RELATION_NAME: Apply the contents the the given relation. Same rules as _relation_contents apply here _ _relations_depth: Depth of relational serialization. Defaults to 1 when relation_contents were specified. Specifying a form of _relations_contents change the depth to 1 (if depth was 0) as the relation is to be serialized Specifying it 2 with _relations_contents given will serialize the relations of the fetched relation. This causes a chain of serializations - dynamic_property_1,dynamic_property_2 (results in static properties plus 2 dynamic properties) Properties can also be excluded by prefixing the field with '-': - contents=_dynamic,-dynamic_property_2,_relations (static properties, all dynamic properties except for dynamic_property_2 plus all relations) Relation serialization can be done by asking for it: - contents=_relations,_relations_contents=re-use All relational serialization can only be used to get data. This data will be not be set-able when deserializing :type contents: list or none :param depth: Current depth of serializing, used to serialize relations :type depth: int Kwarg parameters: :param allow_passwords: Allow the attr 'password' to be serialized :type allow_passwords: bool Parent parameters: :param instance: Instance of the object to use for updating :type instance: an :param data: Initialization data (Will be applied to the instance if an instance is given) :type data: list[dict] or dict :param many: Indicate that the given instance is to be iterated for serialization :type many: bool """ if not isinstance(contents, ContentOptions): contents = ContentOptions(contents) allow_passwords = kwargs.pop('allow_passwords', False) super(FullSerializer, self).__init__(*args, **kwargs) self.hybrid = hybrid for prop in self.hybrid._properties: if 'password' not in prop.name or allow_passwords: self.fields[prop.name] = FullSerializer._map_type_to_field( prop.property_type) for dynamic in self.hybrid._dynamics: if contents.has_content is False or ( ('_dynamics' in contents or dynamic.name in contents) and '-{0}'.format(dynamic.name) not in contents): self.fields[dynamic.name] = serializers.Field() for relation in self.hybrid._relations: if contents.has_content is False or ( ('_relations' in contents or relation.name in contents) and '-{0}'.format(relation.name) not in contents): self.fields['{0}_guid'.format( relation.name)] = serializers.CharField(required=False) foreign_relations = RelationMapper.load_foreign_relations( hybrid ) # To many side of things, items pointing towards this object if foreign_relations is not None: for key, info in foreign_relations.iteritems(): if contents.has_content is False or ( ('_relations' in contents or key in contents) and '-{0}'.format(key) not in contents): if info['list'] is True: self.fields['%s_guids' % key] = serializers.Field() else: self.fields['%s_guid' % key] = serializers.Field() # Check is a relation needs to be serialized foreign_relations = RelationMapper.load_foreign_relations( hybrid ) # To many side of things, items pointing towards this object if contents.has_content is False or (foreign_relations is None and len( hybrid._relations) == 0) or depth == 0: return # Foreign relations is a dict, relations is a relation object, need to differentiate relation_contents = contents.get_option('_relations_contents') relation_contents_options = copy.deepcopy( contents) if relation_contents == 're-use' else ContentOptions( relation_contents) relations_data = { 'foreign': foreign_relations or {}, 'own': hybrid._relations } for relation_type, relations in relations_data.iteritems(): for relation in relations: relation_key = relation.name if relation_type == 'own' else relation relation_hybrid = relation.foreign_type if relation_type == 'own' else Descriptor( ).load(relations[relation]['class']).get_object() # Possible extra content supplied for a relation relation_content = contents.get_option( '_relation_contents_{0}'.format(relation_key)) if relation_content is None and relation_contents == 're-use': relation_content_options = relation_contents_options else: relation_content_options = ContentOptions(relation_content) # Use the depth given by the contents when it's the first item to serialize relation_depth = contents.get_option( '_relations_depth', 1 if relation_content_options.has_content else 0) if depth is None else depth if relation_depth is None: # Can be None when no value is give to _relations_depth relation_depth = 0 if relation_depth == 0: continue # @Todo prevent the same one-to-one relations from being serialized multiple times? Not sure if helpful though self.fields[relation_key] = FullSerializer( relation_hybrid, contents=relation_content_options, depth=relation_depth - 1)
class FullSerializer(serializers.Serializer): """ Serializes the persistent and dynamic stack of a hybrid object """ guid = serializers.Field() # Always include the GUID class Meta(object): """ Meta class. Holds some information about the serializer - fields: Fields which included by default (can be edited by using the 'fields' attr in the serializer - read_only_fields: Indicates which fields are read only (can be edited by using the 'read_only_fields' attr in the serializer """ fields = ('guid', ) read_only_fields = ('guid', ) def __init__(self, hybrid, contents=None, depth=None, *args, **kwargs): """ Initializes the serializer, mapping field types :param hybrid: Hybrid object to serialize :type hybrid: any (ovs.dal.hybrids.X.X) :param contents: Contents to serialize. Without contents, only the GUID is serialized When contents is given, all non-dynamic properties are serialized Further options are: - _dynamics: Include all dynamic properties - _relations: Include foreign keys and lists of primary keys of linked objects - _relations_contents: Apply the contents to the relations. The relation contents can be a bool or a new contents item - If the relations_contents=re-use: the current contents are also applied to the relation object - If the relations_contents=contents list: That item is subjected to the same rules as other contents - _relation_contents_RELATION_NAME: Apply the contents the the given relation. Same rules as _relation_contents apply here _ _relations_depth: Depth of relational serialization. Defaults to 1 when relation_contents were specified. Specifying a form of _relations_contents change the depth to 1 (if depth was 0) as the relation is to be serialized Specifying it 2 with _relations_contents given will serialize the relations of the fetched relation. This causes a chain of serializations - dynamic_property_1,dynamic_property_2 (results in static properties plus 2 dynamic properties) Properties can also be excluded by prefixing the field with '-': - contents=_dynamic,-dynamic_property_2,_relations (static properties, all dynamic properties except for dynamic_property_2 plus all relations) Relation serialization can be done by asking for it: - contents=_relations,_relations_contents=re-use All relational serialization can only be used to get data. This data will be not be set-able when deserializing :type contents: list or none :param depth: Current depth of serializing, used to serialize relations :type depth: int Kwarg parameters: :param allow_passwords: Allow the attr 'password' to be serialized :type allow_passwords: bool Parent parameters: :param instance: Instance of the object to use for updating :type instance: an :param data: Initialization data (Will be applied to the instance if an instance is given) :type data: list[dict] or dict :param many: Indicate that the given instance is to be iterated for serialization :type many: bool """ if not isinstance(contents, ContentOptions): contents = ContentOptions(contents) allow_passwords = kwargs.pop('allow_passwords', False) super(FullSerializer, self).__init__(*args, **kwargs) self.hybrid = hybrid for prop in self.hybrid._properties: if 'password' not in prop.name or allow_passwords: self.fields[prop.name] = FullSerializer._map_type_to_field( prop.property_type) for dynamic in self.hybrid._dynamics: if contents.has_content is False or ( ('_dynamics' in contents or dynamic.name in contents) and '-{0}'.format(dynamic.name) not in contents): self.fields[dynamic.name] = serializers.Field() for relation in self.hybrid._relations: if contents.has_content is False or ( ('_relations' in contents or relation.name in contents) and '-{0}'.format(relation.name) not in contents): self.fields['{0}_guid'.format( relation.name)] = serializers.CharField(required=False) foreign_relations = RelationMapper.load_foreign_relations( hybrid ) # To many side of things, items pointing towards this object if foreign_relations is not None: for key, info in foreign_relations.iteritems(): if contents.has_content is False or ( ('_relations' in contents or key in contents) and '-{0}'.format(key) not in contents): if info['list'] is True: self.fields['%s_guids' % key] = serializers.Field() else: self.fields['%s_guid' % key] = serializers.Field() # Check is a relation needs to be serialized foreign_relations = RelationMapper.load_foreign_relations( hybrid ) # To many side of things, items pointing towards this object if contents.has_content is False or (foreign_relations is None and len( hybrid._relations) == 0) or depth == 0: return # Foreign relations is a dict, relations is a relation object, need to differentiate relation_contents = contents.get_option('_relations_contents') relation_contents_options = copy.deepcopy( contents) if relation_contents == 're-use' else ContentOptions( relation_contents) relations_data = { 'foreign': foreign_relations or {}, 'own': hybrid._relations } for relation_type, relations in relations_data.iteritems(): for relation in relations: relation_key = relation.name if relation_type == 'own' else relation relation_hybrid = relation.foreign_type if relation_type == 'own' else Descriptor( ).load(relations[relation]['class']).get_object() # Possible extra content supplied for a relation relation_content = contents.get_option( '_relation_contents_{0}'.format(relation_key)) if relation_content is None and relation_contents == 're-use': relation_content_options = relation_contents_options else: relation_content_options = ContentOptions(relation_content) # Use the depth given by the contents when it's the first item to serialize relation_depth = contents.get_option( '_relations_depth', 1 if relation_content_options.has_content else 0) if depth is None else depth if relation_depth is None: # Can be None when no value is give to _relations_depth relation_depth = 0 if relation_depth == 0: continue # @Todo prevent the same one-to-one relations from being serialized multiple times? Not sure if helpful though self.fields[relation_key] = FullSerializer( relation_hybrid, contents=relation_content_options, depth=relation_depth - 1) def get_identity(self, data): """ This hook makes sure the guid is returned as primary key By default the serializer class will use the id key on the incoming data to determine the canonical identity of an object """ return data.get('guid', None) def restore_object(self, attrs, instance=None): """ Provides deserializing functionality for persistent properties Required if we want our serializer to support deserialization into fully fledged object instances. If we don't define this method, then deserializing data will simply return a dictionary of items. """ if instance is not None: for prop in self.hybrid._properties: setattr(instance, prop.name, attrs.get(prop.name, getattr(instance, prop.name))) for relation in self.hybrid._relations: guid_key = '{0}_guid'.format(relation.name) if guid_key in attrs and attrs[guid_key] != getattr( instance, guid_key): setattr( instance, relation.name, None if attrs[guid_key] is None else relation.foreign_type(attrs[guid_key])) return instance return self.hybrid(data=attrs) @staticmethod def _map_type_to_field(field_type): """ Maps the given field type to a serializer field """ if isinstance(field_type, list): field_type = type(field_type[0]) if field_type is str: return serializers.CharField(required=False) if field_type is int: return serializers.IntegerField(required=False) if field_type is bool: return serializers.BooleanField(required=False) if field_type is dict: return serializers.WritableField(required=False) return serializers.Field() def deserialize(self): _ = self.errors # Trigger deserialization return self.object
class FullSerializer(serializers.Serializer): """ Serializes the persistent and dynamic stack of a hybrid object """ def __init__(self, hybrid, contents=None, *args, **kwargs): """ Initializes the serializer, mapping field types """ allow_passwords = False if 'allow_passwords' in kwargs: allow_passwords = kwargs['allow_passwords'] del kwargs['allow_passwords'] super(FullSerializer, self).__init__(*args, **kwargs) self.hybrid = hybrid for prop in self.hybrid._properties: if not 'password' in prop.name or allow_passwords: self.fields[prop.name] = FullSerializer._map_type_to_field(prop.property_type) for dynamic in self.hybrid._dynamics: if contents is None or (('_dynamics' in contents or dynamic.name in contents) and '-{0}'.format(dynamic.name) not in contents): self.fields[dynamic.name] = serializers.Field() for relation in self.hybrid._relations: if contents is None or (('_relations' in contents or relation.name in contents) and '-{0}'.format(relation.name) not in contents): self.fields['{0}_guid'.format(relation.name)] = serializers.CharField(required=False) relations = RelationMapper.load_foreign_relations(hybrid) if relations is not None: for key, info in relations.iteritems(): if contents is None or (('_relations' in contents or key in contents) and '-{0}'.format(key) not in contents): if info['list'] is True: self.fields['%s_guids' % key] = serializers.Field() else: self.fields['%s_guid' % key] = serializers.Field() guid = serializers.Field() def get_identity(self, data): """ This hook makes sure the guid is returned as primary key """ return data.get('guid', None) def restore_object(self, attrs, instance=None): """ Provides deserializing functionality for persistent properties """ if instance is not None: for prop in self.hybrid._properties: setattr(instance, prop.name, attrs.get(prop.name, getattr(instance, prop.name))) for relation in self.hybrid._relations: guid_key = '{0}_guid'.format(relation.name) if guid_key in attrs and attrs[guid_key] != getattr(instance, guid_key): setattr(instance, relation.name, None if attrs[guid_key] is None else relation.foreign_type(attrs[guid_key])) return instance return self.hybrid(data=attrs) @staticmethod def _map_type_to_field(field_type): """ Maps the given field type to a serializer field """ if isinstance(field_type, list): field_type = type(field_type[0]) if field_type is str: return serializers.CharField(required=False) if field_type is int: return serializers.IntegerField(required=False) if field_type is bool: return serializers.BooleanField(required=False) return serializers.Field() class Meta: """ Meta class """ fields = ('guid',) read_only_fields = ('guid',)
class NewsSerializer(ImagableModelSerializer, serializers.ModelSerializer): """ News serializer - API endpoint for news Backbone application. """ id = serializers.Field(source='pk') title = serializers.CharField(max_length=64) slug = serializers.SlugField(required=False) link = serializers.Field(source='get_absolute_url') content = serializers.Field(source='get_entry_introtext') date_created = serializers.DateTimeField(required=False) date_edited = serializers.DateTimeField(required=False) username = serializers.Field(source='creator.username') user_id = serializers.Field(source='creator.pk') user_full_name = serializers.Field(source='creator.get_full_name') avatar = serializers.Field(source='creator.profile.avatar.url') creator_url = serializers.Field(source='creator.profile.get_absolute_url') location = serializers.PrimaryKeyRelatedField(read_only=True) category = serializers.RelatedField() category_url = serializers.SerializerMethodField('category_search_url') edited = serializers.BooleanField() tags = serializers.SerializerMethodField('get_tags') comment_count = serializers.SerializerMethodField('get_comment_count') comment_meta = serializers.SerializerMethodField('get_comment_meta') class Meta: model = News fields = ( 'id', 'title', 'slug', 'link', 'content', 'date_created', 'date_edited', 'username', 'user_id', 'avatar', 'location', 'category', 'category_url', 'edited', 'tags', 'comment_count', 'user_full_name', 'creator_url', 'comment_meta', 'image', ) def get_tags(self, obj): tags = [] for tag in obj.tags.all(): tags.append({ 'name': tag.name, 'url': reverse('locations:tag_search', kwargs={ 'slug': obj.location.slug, 'tag': tag.slug }) }) return tags def get_comment_meta(self, obj): return { 'content-type': ContentType.objects.get_for_model(News).pk, 'content-label': 'blog', } def get_comment_count(self, obj): pk = obj.pk content_type = ContentType.objects.get_for_model(obj) comments = CustomComment.objects.filter(content_type=content_type) return len(comments.filter(object_pk=pk)) def category_search_url(self, obj): if obj.category is not None: return reverse('locations:category_search', kwargs={ 'slug': obj.location.slug, 'app': 'blog', 'model': 'news', 'category': obj.category.pk }) return u""
class FollowerListSerializer(serializers.ModelSerializer): user_self = serializers.Field(source='to_json_self') class Meta: model = SocialFriendShip fields = ('id', 'user_self', 'user_obj', 'type')
class MyActionsSerializer(serializers.Serializer): """ Serializer for user activity stream. """ id = serializers.Field(source='pk') verb = serializers.Field() timestamp = serializers.SerializerMethodField('get_timestamp') actor = serializers.SerializerMethodField('get_actor_data') object = serializers.SerializerMethodField('get_action_object') object_ct = serializers.SerializerMethodField('get_verbose_name') target = serializers.SerializerMethodField('get_action_target') target_ct = serializers.Field(source='target_content_type.model') description = serializers.SerializerMethodField('get_action_description') def get_timestamp(self, obj): return obj.timestamp.isoformat() def get_verbose_name(self, obj): try: ct = obj.action_object_content_type target = ct.get_object_for_this_type( pk=obj.action_object_object_id) return target._meta.verbose_name except Exception: return u'' def get_object_url(self, obj): try: ct = obj.action_object_content_type target = ct.get_object_for_this_type( pk=obj.action_object_object_id) return target.get_absolute_url() except Exception: return u'' def serialize_selected_object(self, content_type, instance): """ Factory method to get serialized data for passed objects. It use's basic serializers if possible. """ if content_type.model == 'location': serializer = LocationBasicSerializer(instance) return serializer.data elif content_type.model == 'news': serializer = NewsBasicSerializer(instance) return serializer.data elif content_type.model == 'idea': serializer = IdeaBasicSerializer(instance) return serializer.data elif content_type.model == 'poll': serializer = PollBasicSerializer(instance) return serializer.data elif content_type.model == 'locationgalleryitem': serializer = GalleryItemSerializer(instance) return serializer.data elif content_type.model == 'discussion': serializer = DiscussionSerializer(instance) serializer.data['name'] = serializer.data['question'] return serializer.data elif content_type.model == 'socialproject': serializer = ProjectActionSerializer(instance) return serializer.data elif content_type.model == 'taskgroup': serializer = TaskGroupActionSerializer(instance) return serializer.data elif content_type.model == 'task': serializer = TaskActionSerializer(instance) return serializer.data else: data = { 'id': instance.pk, 'url': self.get_object_url(instance), } return data def get_action_description(self, obj): try: ct = obj.action_object_content_type target = ct.get_object_for_this_type( pk=obj.action_object_object_id) if obj.verb == 'commented': return '{} <a href="{}">{}</a>'.format( truncatehtml(obj.data['comment'], 140), obj.data['comment_url'], _("More")) elif obj.verb == 'voted on': if obj.data['vote']: return '<div class="vote-{}"><a href="{}">{}</a></div>' \ .format('up', target.get_absolute_url(), _("Voted yes")) else: return '<div class="vote-{}"><a href="{}">{}</a></div>' \ .format('down', target.get_absolute_url(), _("Voted no")) elif ct.model == 'idea': return truncatehtml(target.description, 140) elif ct.model == 'location': return truncatehtml(target.description, 140) elif ct.model == 'news': return truncatehtml(target.content, 140) elif ct.model == 'poll': return truncatehtml(target.question, 140) elif ct.model == 'discussion': return truncatehtml(target.intro, 140) elif ct.model == 'entry': return truncatehtml(target.content, 140) elif ct.model == 'locationgalleryitem': return '<a href="' + target.get_absolute_url() + '">' + \ '<img src="' + target.get_thumbnail((256,256)) + '" /></a>' elif ct.model == 'socialproject': return truncatehtml(target.description, 140) elif ct.model == 'taskgroup': return truncatehtml(target.description, 140) elif ct.model == 'task': return truncatehtml(target.description, 140) else: return u'' except Exception: return u'' def get_action_object(self, obj): try: ct = obj.action_object_content_type target = ct.get_object_for_this_type( pk=obj.action_object_object_id) return self.serialize_selected_object(ct, target) except Exception: return {} def get_action_target(self, obj): try: ct = obj.target_content_type target = ct.get_object_for_this_type(pk=obj.target_object_id) return self.serialize_selected_object(ct, target) except Exception: return {} def get_actor_data(self, obj): """ WARNING: we assume that every actor is user instance!!!. """ user = User.objects.get(pk=obj.actor_object_id) serializer = UserSerializer(user) return serializer.data
class UserListSerializer(serializers.ModelSerializer): img = serializers.ImageField(allow_empty_file=True, required=False) full_name = serializers.Field(source="get_full_name") class Meta: model = Professional fields = ('id', "full_name", "img",)
class DiscussionSerializer(ImagableModelSerializer, serializers.ModelSerializer): """ Basic serializer for discussions. """ id = serializers.Field(source='pk') question = serializers.CharField() intro = serializers.CharField() location = serializers.PrimaryKeyRelatedField() url = serializers.Field(source='get_absolute_url') creator_id = serializers.Field(source='creator.pk') creator_username = serializers.Field(source='creator.username') creator_fullname = serializers.Field(source='creator.get_full_name') creator_url = serializers.Field(source='creator.profile.get_absolute_url') creator_avatar = serializers.Field(source='creator.profile.avatar.url') date_created = serializers.DateTimeField(required=False) date_edited = serializers.DateTimeField(required=False) status = serializers.BooleanField() category_name = serializers.Field(source='category.name') category_url = serializers.SerializerMethodField('category_search_url') tags = serializers.SerializerMethodField('get_tags') answers = serializers.SerializerMethodField('get_answer_count') class Meta: model = Discussion fields = ( 'id', 'question', 'intro', 'url', 'creator_id', 'answers', 'creator_fullname', 'creator_url', 'creator_avatar', 'category_name', 'date_created', 'date_edited', 'status', 'category_url', 'tags', 'creator_username', 'location', 'image', ) def get_tags(self, obj): tags = [] for tag in obj.tags.all(): tags.append({ 'name': tag.name, 'url': reverse('locations:tag_search', kwargs={ 'slug': obj.location.slug, 'tag': tag.slug }) }) return tags def category_search_url(self, obj): if obj.category is not None: return reverse('locations:category_search', kwargs={ 'slug': obj.location.slug, 'app': 'topics', 'model': 'discussion', 'category': obj.category.pk }) return u"" def get_answer_count(self, obj): return obj.entry_set.count()
class CreditcardSerializer(serializers.ModelSerializer): creditcard = serializers.Field(source='stripe_get_creditcard') class Meta: model = User fields = ('id', 'creditcard',)
class IdeaSerializer(serializers.ModelSerializer): """ Idea serializer. """ id = serializers.Field(source='pk') name = serializers.CharField() url = serializers.Field(source='get_absolute_url') description = serializers.CharField() creator_id = serializers.Field(source='creator.pk') creator_url = serializers.Field(source='creator.profile.get_absolute_url') creator_username = serializers.Field(source='creator.username') creator_fullname = serializers.Field(source='creator.get_full_name') creator_avatar = serializers.Field(source='creator.profile.avatar.url') date_created = serializers.DateTimeField(required=False) date_edited = serializers.DateTimeField(required=False) category_name = serializers.SerializerMethodField('get_category_name') category_url = serializers.SerializerMethodField('category_search_url') total_comments = serializers.Field(source='get_comment_count') total_votes = serializers.Field(source='get_votes') edited = serializers.BooleanField() tags = serializers.SerializerMethodField('get_tags') comment_meta = serializers.SerializerMethodField('get_comment_meta') image = serializers.Field(source='image_url') class Meta: model = Idea fields = ('id', 'name', 'description', 'creator_id', 'creator_username', 'creator_fullname', 'creator_avatar', 'date_created', 'date_edited', 'edited', 'tags', 'category_name', 'category_url', 'total_comments', 'total_votes', 'url', 'creator_url', 'comment_meta', 'image') def get_comment_meta(self, obj): return { 'content-type': ContentType.objects.get_for_model(Idea).pk, 'content-label': 'ideas', } def get_tags(self, obj): tags = [] for tag in obj.tags.all(): tags.append({ 'name': tag.name, 'url': reverse('locations:tag_search', kwargs={ 'slug': obj.location.slug, 'tag': tag.slug }) }) return tags def category_search_url(self, obj): if obj.category: return reverse('locations:category_search', kwargs={ 'slug': obj.location.slug, 'app': 'topics', 'model': 'discussion', 'category': obj.category.pk }) return r'' def get_category_name(self, obj): if obj.category: return obj.category.name return u''
class SlugSerializer(serializers.ModelSerializer): slug = serializers.Field() # read only class Meta: model = SlugBasedModel exclude = ('id', )
class EnvironmentVipV3Serializer(DynamicFieldsModelSerializer): """Serilizes EnvironmentVip Model.""" name = serializers.Field(source='name') optionsvip = serializers.SerializerMethodField('get_optionsvip') environments = serializers.SerializerMethodField('get_environments') def get_optionsvip(self, obj): return self.extends_serializer(obj, 'optionsvip') def get_environments(self, obj): return self.extends_serializer(obj, 'environments') class Meta: EnvironmentVip = get_model('ambiente', 'EnvironmentVip') model = EnvironmentVip fields = ( 'id', 'finalidade_txt', 'cliente_txt', 'ambiente_p44_txt', 'description', 'name', 'conf', 'optionsvip', 'environments', ) default_fields = ( 'id', 'finalidade_txt', 'cliente_txt', 'ambiente_p44_txt', 'description', ) details_fields = ( 'id', 'finalidade_txt', 'cliente_txt', 'ambiente_p44_txt', 'description', 'name', 'conf', ) basic_fields = ( 'id', 'name', ) def get_serializers(self): """Returns the mapping of serializers.""" if not self.mapping: self.mapping = { 'optionsvip': { 'serializer': OptionVipEnvironmentVipV3Serializer, 'kwargs': { 'many': True, 'fields': ('option', ) }, 'obj': 'optionsvip', }, 'environments': { 'serializer': EnvironmentEnvironmentVipV3Serializer, 'kwargs': { 'many': True, 'fields': ('environment', ) }, 'obj': 'environments', }, 'optionsvip__details': { 'serializer': OptionVipEnvironmentVipV3Serializer, 'kwargs': { 'many': True, 'kind': 'details', 'fields': ('option', ) }, 'obj': 'optionsvip', }, 'environments__details': { 'serializer': EnvironmentEnvironmentVipV3Serializer, 'kwargs': { 'many': True, 'kind': 'details', 'fields': ('environment', ) }, 'obj': 'environments', }, }
class IndicatorSerializer(ModelSerializer): creator_path = serializers.Field(source='creator_path') class Meta: model = Indicator
class ReviewersESAppSerializer(ESAppSerializer): latest_version = serializers.Field(source='es_data.latest_version') is_escalated = serializers.BooleanField() class Meta(ESAppSerializer.Meta): fields = SEARCH_FIELDS + ['latest_version', 'is_escalated']
class UserProfileSerializer(serializers.HyperlinkedModelSerializer): username = serializers.WritableField(source='user.username') email = serializers.WritableField(source='user.email') website = serializers.WritableField(source='home_page', required=False) gravatar = serializers.Field(source='gravatar') password = serializers.WritableField( source='user.password', widget=widgets.PasswordInput(), required=False) user = serializers.HyperlinkedRelatedField( view_name='user-detail', lookup_field='username', read_only=True) class Meta: model = UserProfile fields = ('url', 'username', 'name', 'password', 'email', 'city', 'country', 'organization', 'website', 'twitter', 'gravatar', 'require_auth', 'user') lookup_field = 'user' def to_native(self, obj): """ Serialize objects -> primitives. """ ret = super(UserProfileSerializer, self).to_native(obj) if 'password' in ret: del ret['password'] return ret def restore_object(self, attrs, instance=None): def _get_first_last_names(name): name_split = name.split() first_name = name_split[0] last_name = u'' if len(name_split) > 1: last_name = u' '.join(name_split[1:]) return first_name, last_name params = copy.deepcopy(attrs) username = attrs.get('user.username', None) password = attrs.get('user.password', None) name = attrs.get('name', None) email = attrs.get('user.email', None) if username: params['username'] = username if email: params['email'] = email if password: params.update({'password1': password, 'password2': password}) if instance: form = UserProfileForm(params, instance=instance) # form.is_valid affects instance object for partial updates [PATCH] # so only use it for full updates [PUT], i.e shallow copy effect if not self.partial and form.is_valid(): instance = form.save() # get user if email: instance.user.email = form.cleaned_data['email'] if name: first_name, last_name = _get_first_last_names(name) instance.user.first_name = first_name instance.user.last_name = last_name if email or name: instance.user.save() return super( UserProfileSerializer, self).restore_object(attrs, instance) #return instance # TODO: updates form = RegistrationFormUserProfile(params) # does not require captcha form.REGISTRATION_REQUIRE_CAPTCHA = False if form.is_valid(): first_name, last_name = _get_first_last_names(name) new_user = User(username=username, first_name=first_name, last_name=last_name, email=email) new_user.set_password(password) new_user.save() created_by = self.context['request'].user profile = UserProfile( user=new_user, name=attrs.get('name', u''), created_by=created_by, city=attrs.get('city', u''), country=attrs.get('country', u''), organization=attrs.get('organization', u''), home_page=attrs.get('home_page', u''), twitter=attrs.get('twitter', u'')) return profile else: self.errors.update(form.errors) return attrs
class InstallationStepSerializer(serializers.ModelSerializer): version = RequiredPackageVersionSerializer() progress = serializers.Field(source='get_progress') class Meta: model = PackageInstallationStep fields = ('id', 'version', 'previous_version', 'action', 'status', 'progress', 'log', 'created', 'modified','order')
class WMSLayerSerializer(serializers.HyperlinkedModelSerializer): url = serializers.HyperlinkedIdentityField(view_name='layer-detail') styles = JSONField('styles', '_params') format = JSONField('format', '_params') height = JSONField('height', '_params') width = JSONField('width', '_params') tiled = JSONField('tiled', '_params') transparent = JSONField('transparent', '_params') opacity = serializers.SerializerMethodField('get_opacity') type = serializers.SerializerMethodField('get_type') options = serializers.SerializerMethodField('get_options') legend_url = serializers.SerializerMethodField('get_legend_url') wms_url = serializers.Field('url') def get_wms_url(self, obj): return obj.url def get_opacity(self, obj): options = obj.options if isinstance(options, basestring): try: options = json.loads(options) except ValueError: options = {} return getattr(options, 'opacity', None) def get_options(self, obj): if isinstance(obj.options, basestring): try: return json.loads(obj.options) except ValueError: return {} def get_legend_url(self, obj): # Our raster server does not yet support legends. # Return None if show_legend is disabled. if not obj.show_legend: return None if obj.legend_url: # use the overridden custom legend URL return obj.legend_url else: # automagically build GeoServer compatible legend URL return ('{0}' '?REQUEST=GetLegendGraphic' '&VERSION=1.0.0' '&FORMAT=image/png' '&WIDTH=20&HEIGHT=20' '&LAYER={1}').format(obj.url, obj.layer_name) def get_type(self, obj): return 'wms' class Meta: model = WMSSource fields = ('layer_name', 'display_name', 'url', 'description', 'metadata', 'legend_url', 'enable_search', 'styles', 'format', 'height', 'width', 'tiled', 'transparent', 'wms_url', 'opacity', 'type', 'options')
class EntrySerializer(serializers.ModelSerializer): created_on = serializers.Field(source='get_utc_created_on') class Meta: model = Entry fields = ('data', 'created_on')