def test_dehydrate(self): note = Note.objects.get(pk=1) bundle = Bundle(obj=note) field_1 = ListField(default=[1, 2, 3]) self.assertEqual(field_1.dehydrate(bundle), [1, 2, 3]) field_2 = ListField(default=['abc']) self.assertEqual(field_2.dehydrate(bundle), ['abc'])
class TaskResource(ModelResource): pcap_file = Base64FileField("pcap_file", use_in=is_post) user = ForeignKey(UserResource, 'user', full=True) results = ListField(attribute='results', null=True, blank=True, default=None) def obj_create(self, bundle, **kwargs): return super(TaskResource, self).obj_create(bundle, user=bundle.request.user) def alter_list_data_to_serialize(self, request, data): for item in data['objects']: item.data['filename'] = os.path.basename( Task.objects.get(pk=item.data['id']).pcap_file.name) return data class Meta: queryset = Task.objects.all().order_by('-id') resource_name = 'task' allowed_methods = ['get', 'post'] authentication = MultiAuthentication(BasicAuthentication(), ApiKeyAuthentication(), SessionAuthentication()) authorization = CertegoDjangoAuthorization() filtering = { 'submitted_on': ALL, 'user': ALL, 'status': ALL, } ordering = ['id', 'submitted_on', 'status']
class ResultResource(PresentationMediumResource): # Returns the results of the DbEntity query query = ListField(attribute='query', null=False) class Meta(PresentationMediumResource.Meta): resource_name = 'result' always_return_data = True queryset = Result.objects.all()
class BackendResource(ModelResource): dc = fields.ForeignKey(DcResource, 'dc', full=True) director = fields.ForeignKey(DirectorResource, 'director') tags = ListField() class Meta: queryset = Backend.objects.all() resource_name = 'backend' serializer = PrettyJSONSerializer() authorization = Authorization() authentication = ApiKeyAuthentication() validation = ModelCleanedDataFormValidation( form_class=BackendModelForm) filtering = { 'dc': ALL_WITH_RELATIONS, 'director': ALL_WITH_RELATIONS, 'address': ['exact'], 'port': ['exact'] } def dehydrate(self, bundle): status = BackendStatus.objects.filter(address=bundle.data['address'], port=bundle.data['port']) if len(status) > 0: bundle.data['status'] = status[0].status else: bundle.data['status'] = "Unknown" return bundle def build_filters(self, filters=None): if filters is None: filters = {} orm_filters = super(BackendResource, self).build_filters(filters) if 'tag' in filters: orm_filters['tags__name__in'] = filters['tag'].split(',') return orm_filters def dehydrate_tags(self, bundle): return map(str, bundle.obj.tags.all()) def hydrate_tags(self, bundle): if isinstance(bundle.data.get('tags'), list): bundle.data['tags'] = ','.join(bundle.data['tags']) elif bundle.data.get('tags') is None: bundle.data['tags'] = '' return bundle def save_m2m(self, bundle): tags = bundle.data.get('tags', []) bundle.obj.tags.set(*tags) return super(BackendResource, self).save_m2m(bundle)
class StyleAttributeResource(FootprintResource): style_value_contexts = ListField(attribute='style_value_contexts', null=True, blank=True, default=lambda:{}) def full_hydrate(self, bundle): """ Sets the style value contexts :param bundle: :return: """ if hasattr(bundle.obj, 'style_value_contexts'): bundle = super(StyleAttributeResource, self).full_hydrate(bundle) bundle.obj.style_value_contexts = bundle.data['style_value_contexts'] return bundle class Meta(FootprintResource.Meta): always_return_data = True queryset = StyleAttribute.objects.all()
class TaggableResource(BaseResource): """docstring for TaggableResource""" tags = ListField() def dehydrate_tags(self, bundle): return map(str, bundle.obj.tags.all()) def save_m2m(self, bundle): tags = bundle.data.get('tags', []) bundle.obj.tags.set(*tags) return super(TaggableResource, self).save_m2m(bundle) def build_filters(self, filters=None, ignore_bad_filters=True): if filters is None: filters = {} orm_filters = super(TaggableResource, self).build_filters(filters) if 'tag' in filters: orm_filters['tags__name__in'] = filters['tag'].split(',') return orm_filters
class TaggedResource(ModelResource): tags = ListField() class Meta: queryset = Model.objects.all() def build_filters(self, filters=None): if filters is None: filters = {} orm_filters = super(TaggedResource, self).build_filters(filters) if 'tag' in filters: orm_filters['tags__name__in'] = filters['tag'].split(',') return orm_filters def dehydrate_tags(self, bundle): return map(str, bundle.obj.tags.all()) def save_m2m(self, bundle): tags = bundle.data.get('tags', []) bundle.obj.tags.set(*tags) return super(TaggedResource, self).save_m2m(bundle)
class PrivateSniptResource(ModelResource): user = fields.ForeignKey(PrivateUserResource, "user", full=True) last_user_saved = fields.ForeignKey( PrivateUserResource, "last_user_saved", null=True, full=False ) tags_list = ListField() tags = fields.ToManyField(PublicTagResource, "tags", related_name="tag", full=True) class Meta: queryset = Snipt.objects.all().order_by("-created") resource_name = "snipt" fields = [ "id", "title", "slug", "lexer", "code", "description", "line_count", "stylized", "key", "public", "secure", "blog_post", "created", "modified", "publish_date", "meta", ] include_absolute_url = True detail_allowed_methods = ["get", "patch", "put", "delete"] list_allowed_methods = ["get", "post"] authentication = ApiKeyAuthentication() authorization = PrivateSniptAuthorization() validation = SniptValidation() ordering = ["created", "modified"] always_return_data = True max_limit = 200 cache = SimpleCache() def dehydrate(self, bundle): bundle.data["embed_url"] = bundle.obj.get_embed_url() bundle.data["raw_url"] = bundle.obj.get_raw_url() bundle.data["tags_list"] = edit_string_for_tags(bundle.obj.tags.all()) bundle.data["full_absolute_url"] = bundle.obj.get_full_absolute_url() bundle.data["description_rendered"] = linebreaksbr( urlize(bundle.obj.description) ) bundle.data["views"] = bundle.obj.views bundle.data["favs"] = bundle.obj.favs() if bundle.data["publish_date"]: bundle.data["publish_date"] = date( bundle.data["publish_date"], "M d, Y \\a\\t h:i A" ) log_entries = bundle.obj.sniptlogentry_set.all() bundle_log_entries = [] for entry in log_entries: bundle_log_entries.append( { "created": entry.created, "user": entry.user, "code": entry.code, "diff": entry.diff, } ) bundle.data["log_entries"] = bundle_log_entries return bundle def obj_create(self, bundle, **kwargs): bundle.data["last_user_saved"] = bundle.request.user bundle.data["tags_list"] = bundle.data.get("tags") bundle.data["tags"] = [] if "intended_user" in bundle.data: bundle.data["user"] = User.objects.get( username=bundle.data["intended_user"] ) else: bundle.data["user"] = bundle.request.user if "blog_post" in bundle.data: bundle = self._clean_publish_date(bundle) return super(PrivateSniptResource, self).obj_create(bundle, **kwargs) def obj_update(self, bundle, **kwargs): instance = Snipt.objects.get(pk=bundle.data["id"]) if instance.user.profile.is_a_team: user = instance.user else: user = bundle.request.user bundle.data["created"] = None bundle.data["last_user_saved"] = bundle.request.user bundle.data["modified"] = None bundle.data["user"] = user if type(bundle.data["tags"]) == str or type(bundle.data["tags"]) == unicode: bundle.data["tags_list"] = bundle.data["tags"] else: bundle.data["tags_list"] = "" bundle.data["tags"] = "" if "blog_post" in bundle.data: bundle = self._clean_publish_date(bundle) return super(PrivateSniptResource, self).obj_update(bundle, **kwargs) def _clean_publish_date(self, bundle): if bundle.data["blog_post"] and "publish_date" not in bundle.data: bundle.data["publish_date"] = datetime.datetime.now() elif bundle.data["publish_date"] == "": bundle.data["publish_date"] = datetime.datetime.now() elif bundle.data["blog_post"]: c = pdt.Constants() p = pdt.Calendar(c) publish_date, result = p.parse(bundle.data["publish_date"]) if result != 0: publish_date = time.strftime("%Y-%m-%d %H:%M:%S", publish_date) else: publish_date = datetime.datetime.now() bundle.data["publish_date"] = publish_date elif not bundle.data["blog_post"]: bundle.data["publish_date"] = None return bundle def build_filters(self, filters=None, **kwargs): if filters is None: filters = {} orm_filters = super(PrivateSniptResource, self).build_filters(filters) if "tag" in filters: tag = Tag.objects.get(pk=filters["tag"]) tagged_items = tag.taggit_taggeditem_items.all() orm_filters["pk__in"] = [i.object_id for i in tagged_items] # if "q" in filters: # user = User.objects.get(username=filters["username"]) # sqs = SearchQuerySet().filter(author=user, content=filters["q"]) # orm_filters["pk__in"] = [i.pk for i in sqs] return orm_filters def save_m2m(self, bundle): tags = bundle.data.get("tags_list", []) if tags != "": bundle.obj.tags.set(*parse_tags(tags)) else: bundle.obj.tags.set()
class PrivateSniptResource(ModelResource): user = fields.ForeignKey(PrivateUserResource, 'user', full=True) last_user_saved = fields.ForeignKey(PrivateUserResource, 'last_user_saved', null=True, full=False) tags_list = ListField() tags = fields.ToManyField(PublicTagResource, 'tags', related_name='tag', full=True) class Meta: queryset = Snipt.objects.all().order_by('-created') resource_name = 'snipt' fields = [ 'id', 'title', 'slug', 'lexer', 'code', 'description', 'line_count', 'stylized', 'key', 'public', 'blog_post', 'created', 'modified', 'publish_date', 'meta' ] include_absolute_url = True detail_allowed_methods = ['get', 'patch', 'put', 'delete'] list_allowed_methods = ['get', 'post'] authentication = ApiKeyAuthentication() authorization = PrivateSniptAuthorization() validation = SniptValidation() ordering = ['created', 'modified'] always_return_data = True max_limit = 200 cache = SimpleCache() def dehydrate(self, bundle): bundle.data['embed_url'] = bundle.obj.get_embed_url() bundle.data['raw_url'] = bundle.obj.get_raw_url() bundle.data['tags_list'] = edit_string_for_tags(bundle.obj.tags.all()) bundle.data['full_absolute_url'] = bundle.obj.get_full_absolute_url() bundle.data['description_rendered'] = \ linebreaksbr(urlize(bundle.obj.description)) bundle.data['views'] = bundle.obj.views bundle.data['favs'] = bundle.obj.favs() if bundle.data['publish_date']: bundle.data['publish_date'] = \ date(bundle.data['publish_date'], 'M d, Y \\a\\t h:i A') log_entries = bundle.obj.sniptlogentry_set.all() bundle_log_entries = [] for entry in log_entries: bundle_log_entries.append({ 'created': entry.created, 'user': entry.user, 'code': entry.code, 'diff': entry.diff }) bundle.data['log_entries'] = bundle_log_entries return bundle def obj_create(self, bundle, **kwargs): bundle.data['last_user_saved'] = bundle.request.user bundle.data['tags_list'] = bundle.data.get('tags') bundle.data['tags'] = [] if 'intended_user' in bundle.data: bundle.data['user'] = \ User.objects.get(username=bundle.data['intended_user']) else: bundle.data['user'] = bundle.request.user if 'blog_post' in bundle.data: bundle = self._clean_publish_date(bundle) return super(PrivateSniptResource, self) \ .obj_create(bundle, **kwargs) def obj_update(self, bundle, **kwargs): instance = Snipt.objects.get(pk=bundle.data['id']) if (instance.user.profile.is_a_team): user = instance.user else: user = bundle.request.user bundle.data['created'] = None bundle.data['last_user_saved'] = bundle.request.user bundle.data['modified'] = None bundle.data['user'] = user if type(bundle.data['tags']) == str or type( bundle.data['tags']) == unicode: bundle.data['tags_list'] = bundle.data['tags'] else: bundle.data['tags_list'] = '' bundle.data['tags'] = '' if 'blog_post' in bundle.data: bundle = self._clean_publish_date(bundle) return super(PrivateSniptResource, self) \ .obj_update(bundle, **kwargs) def _clean_publish_date(self, bundle): if bundle.data['blog_post'] and 'publish_date' not in bundle.data: bundle.data['publish_date'] = datetime.datetime.now() elif bundle.data['publish_date'] == '': bundle.data['publish_date'] = datetime.datetime.now() elif bundle.data['blog_post']: c = pdt.Constants() p = pdt.Calendar(c) publish_date, result = p.parse(bundle.data['publish_date']) if result != 0: publish_date = time.strftime("%Y-%m-%d %H:%M:%S", publish_date) else: publish_date = datetime.datetime.now() bundle.data['publish_date'] = publish_date elif not bundle.data['blog_post']: bundle.data['publish_date'] = None return bundle def build_filters(self, filters=None): if filters is None: filters = {} orm_filters = super(PrivateSniptResource, self).build_filters(filters) if 'tag' in filters: tag = Tag.objects.get(pk=filters['tag']) tagged_items = tag.taggit_taggeditem_items.all() orm_filters['pk__in'] = [i.object_id for i in tagged_items] if 'q' in filters: user = User.objects.get(username=filters['username']) sqs = SearchQuerySet().filter(author=user, content=filters['q']) orm_filters['pk__in'] = [i.pk for i in sqs] return orm_filters def save_m2m(self, bundle): tags = bundle.data.get('tags_list', []) if tags != '': bundle.obj.tags.set(*parse_tags(tags)) else: bundle.obj.tags.set()
class IntersectionsResource(Resource): airspaces_id = ListField( attribute='airspaces_id' ) # list of IDs of airspace intersected. Could be omitted. intersections = ListField( attribute='intersections') # contains Intersection objects indexes = ListField(attribute='indexes') # could be removed ? interpolated = ListField( attribute='interpolated') # interpolated version of path sent by user relief_profile = ListField( attribute='relief_profile' ) # relief along path, using interpolated version. class Meta: resource_name = 'intersections' object_class = IntersectionBundle authentication = Authentication() authorization = Authorization() allowed_methods = ['get'] include_resource_uri = False def base_urls(self): return [ url(r"^(?P<resource_name>%s)/path%s$" % (self._meta.resource_name, trailing_slash()), self.wrap_view('get_path'), name="api_get_path"), url(r"^(?P<resource_name>%s)/gpx/(?P<gpxid>.*)%s$" % (self._meta.resource_name, trailing_slash()), self.wrap_view('get_gpx'), name="api_get_gpx"), ] def get_path(self, request, **kwargs): self.method_check(request, allowed=['get']) self.is_authenticated(request) self.throttle_check(request) q = request.GET.get('q', '').strip().split(',') coords = [] for p in q: mq = re.match('(?P<lat>-?[\d\.]+) (?P<lon>-?[\d\.]+)', p) coords.append([float(mq.group('lat')), float(mq.group('lon'))]) h = request.GET.get('h', None) try: h = float(h) except: h = None path = LineString(coords) indexes, interpolated = interpolate_linestring(path) relief_profile = get_relief_profile_along_track(interpolated) ib = get_space_intersect_path(LineString(interpolated), h) ib.indexes = indexes ib.interpolated = interpolated ib.relief_profile = relief_profile bundle = self.build_bundle(obj=ib, request=request) bundle = self.full_dehydrate(bundle) self.log_throttled_access(request) return self.create_response(request, bundle) def get_gpx(self, request, **kwargs): try: filename = kwargs.get('gpxid', None) dfilename = os.path.join("uploads", filename) track_geos = loadFromGpx(str(dfilename)) relief_profile = get_relief_profile_along_track(track_geos) except: raise ImmediateHttpResponse(response=HttpNotFound()) ib = get_space_intersect_path(track_geos) ib.indexes = [track_geos.project(Point(x)) for x in track_geos] ib.interpolated = [] ib.relief_profile = relief_profile bundle = self.build_bundle(obj=ib, request=request) bundle = self.full_dehydrate(bundle) bundle.data['success'] = True bundle.data['trackURL'] = '/static/' + filename self.log_throttled_access(request) return self.create_response(request, bundle) def dehydrate_intersections(self, bundle): return [x.as_dict() for x in bundle.obj.intersections]
class UploadedLayerResource(ModelResource): """ API for accessing UploadedData. """ geonode_layer = DictField(attribute='layer_data', readonly=True, null=True) configuration_options = DictField(attribute='configuration_options', null=True) fields = ListField(attribute='fields') status = CharField(attribute='status', readonly=True, null=True) file_type = CharField(attribute='file_type', readonly=True) file_name = CharField(attribute='file_name', readonly=True) layer_name = CharField(attribute='layer_name', readonly=True) class Meta: queryset = UploadLayer.objects.all() resource_name = 'data-layers' allowed_methods = ['get'] filtering = {'id': ALL} authentication = SessionAuthentication() def get_object_list(self, request): """ Filters the list view by the current user. """ return super(UploadedLayerResource, self).get_object_list(request).filter(upload__user=request.user.id) def clean_configuration_options(self, request, obj, configuration_options): return configuration_options def import_layer(self, request, pk=None, **kwargs): """Imports a layer """ self.method_check(request, allowed=['post']) bundle = Bundle(request=request) try: obj = self.obj_get(bundle, pk=pk) except UploadLayer.DoesNotExist: raise ImmediateHttpResponse(response=http.HttpNotFound()) configuration_options = request.POST.get('configurationOptions') if 'application/json' in request.META.get('CONTENT_TYPE', ''): configuration_options = json.loads(request.body) if isinstance(configuration_options, list) and len(configuration_options) == 1: configuration_options = configuration_options[0] if isinstance(configuration_options, dict): self.clean_configuration_options(request, obj, configuration_options) obj.configuration_options = configuration_options obj.save() if not configuration_options: raise ImmediateHttpResponse(response=http.HttpBadRequest('Configuration options missing.')) uploaded_file = obj.upload_file configuration_options.update({'upload_layer_id': pk}) import_result = import_object.delay(uploaded_file.id, configuration_options=configuration_options) task_id = getattr(import_result, 'id', None) # The task id will be useless if no backend is configured or a non-persistent backend is used. return self.create_response(request, {'task': task_id}) def prepend_urls(self): return [url(r"^(?P<resource_name>{0})/(?P<pk>\w[\w/-]*)/configure{1}$".format(self._meta.resource_name, trailing_slash()), self.wrap_view('import_layer'), name="importer_configure"), ]
class BackendResource(ModelResource): dc = fields.ForeignKey(DcResource, 'dc', full=True) director = fields.ForeignKey(DirectorResource, 'director') tags = ListField() class Meta: queryset = Backend.objects\ .select_related('director__time_profile', 'dc')\ .prefetch_related('tags')\ .extra(select={ 'status': "SELECT status from monitor_backendstatus" " WHERE monitor_backendstatus.address=manager_backend.address" " AND monitor_backendstatus.port=manager_backend.port" " LIMIT 1" })\ .all() resource_name = 'backend' serializer = PrettyJSONSerializer() authorization = DjangoAuthorization() authentication = VaasMultiAuthentication(ApiKeyAuthentication()) validation = ModelCleanedDataFormValidation( form_class=BackendModelForm) always_return_data = True filtering = { 'dc': ALL_WITH_RELATIONS, 'director': ALL_WITH_RELATIONS, 'address': ['exact'], 'port': ['exact'] } def dehydrate(self, bundle): bundle.data['status'] = "Unknown" if hasattr(bundle.obj, "status") and bundle.obj.status: bundle.data['status'] = bundle.obj.status bundle.data['time_profile'] = { 'max_connections': bundle.obj.director.time_profile.max_connections, 'connect_timeout': bundle.obj.director.time_profile.connect_timeout, 'first_byte_timeout': bundle.obj.director.time_profile.first_byte_timeout, 'between_bytes_timeout': bundle.obj.director.time_profile.between_bytes_timeout } return bundle def build_filters(self, filters=None, ignore_bad_filters=False): if filters is None: filters = {} orm_filters = super(BackendResource, self).build_filters( filters, ignore_bad_filters=ignore_bad_filters) if 'tag' in filters: orm_filters['tags__name__in'] = filters['tag'].split(',') return orm_filters def dehydrate_tags(self, bundle): return list(map(str, bundle.obj.tags.all())) def hydrate_tags(self, bundle): if isinstance(bundle.data.get('tags'), list): bundle.data['tags'] = ','.join(bundle.data['tags']) elif bundle.data.get('tags') is None: bundle.data['tags'] = '' return bundle def save_m2m(self, bundle): tags = bundle.data.get('tags', []) bundle.obj.tags.set(*tags) return super(BackendResource, self).save_m2m(bundle)
class PublisherSetResource(ProtectedModelResource): targetvalues_ids = ListField(use_in='detail', default=[]) targetvalues = ToManyField(PublishersResource, 'targetvalues', full=True, use_in='detail', readonly=True, default=[]) class Meta: resource_name = 'sets' list_allowed_methods = ('get', 'post') details_allowed_methods = ('get', 'put') always_return_data = True queryset = PublisherSet.objects.all() authorization = Auth('owner') fields = ('id', 'name', 'inventory', 'is_network', 'blacklist') validation = SetValidation() filtering = {'inventory': ALL} def dehydrate_targetvalues_ids(self, bundle): ids = [] for pub_id in bundle.obj.target_values.values('id'): ids.append(pub_id['id']) return ids def dehydrate_targetvalues(self, bundle): if bundle.obj.is_network: return self._dehydrate_networks(bundle) return self._dehydrate_publishers(bundle) def _dehydrate_publishers(self, bundle): publishers = [] for publisher in bundle.obj.targetvalues: publishers.append({ 'id': publisher.pk, 'inventory': publisher.inventory, 'name': publisher.name, 'network': publisher.network, 'publisher_id': '{0}-{1}'.format(publisher.network_id, publisher.publisher_id), 'sizes': publisher.sizes, 'positions': publisher.positions, 'segments': publisher.segments }) return publishers def _dehydrate_networks(self, bundle): networks = [] for network in bundle.obj.targetvalues: network_dict = { 'id': network.pk, 'network': network.network, 'network_id': network.network_id, 'inventory': network.inventory } networks.append(network_dict) return networks def hydrate_m2m(self, bundle): if self.is_valid(bundle): target_values = TargetValue.objects.representants().filter( id__in=bundle.data.get('targetvalues_ids', [])) bundle.obj.target_values = target_values def hydrate(self, bundle): bundle.obj.owner = bundle.request.user.account return bundle
class CreativeResource(ProtectedModelResource): class Meta: resource_name = 'creative' allowed_methods = ('get', 'post', 'get', 'put', 'delete') always_return_data = True filtering = { 'destination': ( 'exact', 'startswith', ), } queryset = Creative.objects_visible.all() authorization = Auth('owner') fields = ('name', 'width', 'height', 'api_data', 'destination') validation = CreativeValidation() id = IntegerField('id', readonly=True) size = ListField('size', readonly=True) type = CharField(readonly=True) status = CharField('appnexus_status', readonly=True) api_data = CharField('api_data') vast_url = CharField('vast_url', readonly=True, null=True) to_audit = BooleanField('to_audit', readonly=True, null=True) fb_title = CharField('title', null=True) fb_body = CharField('body', null=True) fb_message = CharField('message', null=True) fb_domain = CharField('domain', null=True) fb_brand_page = IntegerField('brand_id', null=True) def prepend_urls(self): return [ url(r"^{0}/audit/(?P<creative_id>[\d]+)$".format( self._meta.resource_name, ), self.wrap_view('manual_audit'), name="creative_manual_audit"), ] def manual_audit(self, request, creative_id, **kwargs): """ Manual audit api view. :param request: request object :param int creative_id: creative which we want to send to audit Returns detail response. """ creative = Creative.objects.get(id=creative_id) creative.to_audit = True creative.save() return self.get_detail(request, pk=creative_id) def dehydrate_destination(self, bundle): return bundle.obj.get_destination_display() def dehydrate(self, bundle): creative = bundle.obj # get type based on class name bundle.data['type'] = creative.type bundle.data['status'] = creative.state.status bundle.data['is_auditable'] = creative.is_auditable if creative.is_facebook_destination(verify_is_newsfeed=True): bundle.data[ 'fb_brand_page_access'] = creative.brand.appnexus_access_status if creative.type == 'Video': bundle.data['liverail_status'] = creative.liverail_status else: bundle.data['liverail_status'] = '' # If facebook creative was added to strategy, # Add information about strategy and campaign if creative.is_facebook_destination(): # For facebook creatives there is only one advert advert = creative.advert_set.filter( is_deleted=False, strategy__is_deleted=False, strategy__campaign__is_deleted=False).first() if advert: strategy = advert.strategy campaign = strategy.campaign bundle.data['strategy'] = strategy.name bundle.data['campaign'] = campaign.name return bundle def hydrate_destination(self, bundle): bundle.data['destination'] = DESTINATION[bundle.data['destination']] return bundle def hydrate_fb_brand_page(self, bundle): """ Clear creative brand page if it is not facebook newsfeed. """ if bundle.data['destination'] != 'facebook_newsfeed': bundle.data['fb_brand_page'] = None return bundle def hydrate(self, bundle): # A bug in Tastypie: on update, hydrate is called 2 times, # once with obj.id == None and method == 'PUT' # We should create an object only if method is POST if not bundle.obj.id and bundle.request.method == 'POST': bundle.obj = creative_factory(bundle.data['type'], owner=bundle.request.user.account) return bundle
class PresentationMediumResource(FootprintResource): """ The through class between Presentation and Medium, a list of which are loaded by a PresentationResource instance to give the user access to the corresponding Medium and also the important db_entity method, which returns the selected DbEntity interest of the PresentationMedium's db_entity_key """ # The db_entity--We don't expose the DbEntityInterest to the client db_entity = fields.ToOneField(DbEntityResource, attribute='db_entity', null=False) # Return the full Medium medium = fields.ToOneField(MediumResource, attribute='medium', null=False, full=True) # The configuration of items not directly related to the Medium, such as graph labels. These are usually also # editable by the user. configuration = PickledDictField(attribute='configuration', null=True, blank=True, default=lambda: {}) visible_attributes = ListField(attribute='visible_attributes', null=True, blank=True) creator = fields.ToOneField(UserResource, 'creator', full=True, null=True, readonly=True) updater = fields.ToOneField(UserResource, 'updater', full=True, null=True, readonly=True) def dehydrate_medium_context(self, bundle): # Remove data that isn't needed by the API return remove_keys(['attributes']) def hydrate(self, bundle): """ Set the user who created the Layer :param bundle: :return: """ if not bundle.obj.id: bundle.obj.creator = self.resolve_user(bundle.request.GET) bundle.obj.updater = self.resolve_user(bundle.request.GET) return super(PresentationMediumResource, self).hydrate(bundle) def full_hydrate(self, bundle): super(PresentationMediumResource, self).full_hydrate(bundle) if not bundle.data.get( 'id' ) and bundle.obj.db_entity_interest.db_entity.origin_instance: # If cloning, copy the medium_context.attributes config_entity = bundle.obj.db_entity_interest.config_entity origin_db_entity = bundle.obj.db_entity_interest.db_entity.origin_instance presentation_medium = PresentationMedium.objects.get( presentation__config_entity=config_entity, db_entity_key=origin_db_entity.key) bundle.data['medium']['attributes'] = presentation_medium.medium[ 'attributes'] return bundle class Meta(FootprintResource.Meta): resource_name = 'presentation_medium' always_return_data = True queryset = PresentationMedium.objects.all() excludes = ['rendered_medium']
class UploadedLayerResource(ModelResource): """ API for accessing UploadedData. """ geonode_layer = DictField(attribute='layer_data', readonly=True, null=True) configuration_options = DictField(attribute='configuration_options', null=True) fields = ListField(attribute='fields') status = CharField(attribute='status', readonly=True, null=True) class Meta: queryset = UploadLayer.objects.all() resource_name = 'data-layers' allowed_methods = ['get'] filtering = {'id': ALL} authentication = SessionAuthentication() def get_object_list(self, request): """ Filters the list view by the current user. """ return super( UploadedLayerResource, self).get_object_list(request).filter(upload__user=request.user.id) def import_layer(self, request, **kwargs): """ Imports a layer """ self.method_check(request, allowed=['post']) b = Bundle() b.request = request try: obj = self.obj_get(b, pk=kwargs.get('pk')) except UploadLayer.DoesNotExist: raise ImmediateHttpResponse(response=http.HttpNotFound()) configuration_options = request.POST.get('configurationOptions') if 'application/json' in request.META.get('CONTENT_TYPE', ''): configuration_options = json.loads(request.body) if isinstance(configuration_options, dict): obj.configuration_options = configuration_options obj.save() configuration_options = [configuration_options] if not configuration_options: raise ImmediateHttpResponse( response=http.HttpBadRequest('Configuration options missing.')) uploaded_file = obj.upload.uploadfile_set.first() import_result = import_object.delay( uploaded_file.id, configuration_options=configuration_options) # query the db again for this object since it may have been updated during the import obj = self.obj_get(b, pk=kwargs.get('pk')) obj.task_id = import_result.id obj.save() return self.create_response(request, {'task': obj.task_id}) def prepend_urls(self): return [ url(r"^(?P<resource_name>{0})/(?P<pk>\w[\w/-]*)/configure{1}$". format(self._meta.resource_name, trailing_slash()), self.wrap_view('import_layer'), name="importer_configure"), ]
def dynamic_resource_subclass(self, layer_selection=None, db_entity=None, feature_class=None, config_entity=None, metadata=None, params=None, **kwargs): """ Creates the dynamic Feature Resource class by passing in a layer_selection, db_entity, or feature_class :param layer_selection: Required if db_entity or metadata aren't present :param db_entity: Required if layer_selection or metadata aren't present :param metadata: Required along with config_entity if layer_selection or db_entity aren't present :param kwargs: :return: """ feature_class_configuration = None if layer_selection: # Coming in relative to a LayerSelection, which puts us in the context of the LayerSelection's # feature query for this Feature subclass layer = layer_selection.layer # If we pass in a ConfigEntity it means we want to scope the Feature class to its scope. # The ConfigEntity defaults to that of the Layer, but we can override it to be a lower # scope to make sure that we have access to lower DbEntities of performing joins config_entity = config_entity.subclassed if config_entity else layer.config_entity.subclassed logger.debug( "Resolving FeatureResource subclass for layer_selection: {0}, config_entity: {1}" .format(layer_selection.unique_id, config_entity.id)) # Resolve the dynamic Feature class with the given config_entity so that we can access all DbEntities # of the ConfigEntity for joins feature_class = config_entity.db_entity_feature_class( layer.db_entity.key) elif db_entity: # Coming in relative to a DbEntity, meaning we don't care about a particular LayerSelection's # feature query for this Feature subclass config_entity = db_entity.config_entity logger.debug( "Resolving FeatureResource subclass for db_entity: {0}, config_entity: {1}" .format(db_entity.id, config_entity.id)) # Resolve the dynamic Feature class with the given config_entity so that we can access all DbEntities # of the ConfigEntity for joins feature_class = config_entity.db_entity_feature_class( db_entity.key) elif metadata: # Coming in with metadata, meaning this is and uploaded or ArcGis table with no DbEntity yet # We need to construct a FeatureClass from the metadata logger.debug( "Resolving FeatureResource subclass for metadata: {0}, config_entity: {1}" .format(metadata, config_entity.id)) feature_class_creator = FeatureClassCreator(config_entity) feature_class_configuration = feature_class_creator.feature_class_configuration_from_metadata( metadata['schema']) feature_class = FeatureClassCreator( config_entity, feature_class_configuration).dynamic_model_class() if not feature_class_configuration: # If we didn't already ensure all dynamic model classes have been created # This only need to run once to get all dynamic feature subclasses into memory, # in case they are needed by an association, join, or something similar feature_class_creator = FeatureClassCreator.from_dynamic_model_class( feature_class) feature_class_creator.ensure_dynamic_models() logger.debug("Resolving resource for Feature subclass: {0}".format( feature_class)) # Resolve the FeatureResource subclass based on the given Feature subclass # If self is already a subclass, just return self # Else, return a preconfigured subclass or one dynamically created. The latter will probably be the only way in the future. # If not already subclassed is_singleton_feature = issubclass(self.__class__, SingletonFeatureResourceMixin) is_template_feature = self.__class__ == TemplateFeatureResource if self.__class__ in [ FeatureResource, TemplateFeatureResource, FeatureCategoryAttributeResource, FeatureQuantitativeAttributeResource ]: if is_singleton_feature or params.get('is_feature_attribute'): queryset = feature_class.objects.none() elif kwargs.get('method', None) == 'PATCH': # It's possible to PATCH with an active join query. # But we don't want to use a join query when patching queryset = feature_class.objects.all() else: # Get the queryset stored by the layer_selection or an empty query if we don't have a layer_selection queryset = layer_selection.selected_features_or_values if\ layer_selection else \ feature_class.objects.none() if layer_selection and not (is_singleton_feature or kwargs.get( 'query_may_be_empty')) and queryset.count() == 0: raise Exception( "Unexpected empty queryset for layer_selection features: %s" % queryset.query) is_values_queryset = isinstance(queryset, ValuesQuerySet) #returns queryset ordered by the table id queryset = queryset.order_by('id') if is_values_queryset: join_feature_class = layer_selection.create_join_feature_class( ) if is_values_queryset else feature_class logger.info("Created join_feature_class: %s" % join_feature_class) # Force the queryset to our new class so that Tastypie can map the dict results to it queryset.model = join_feature_class return self.__class__.resolve_resource_class( join_feature_class, queryset=queryset, base_resource_class=self.join_feature_resource_class( join_feature_class), additional_fields_dict=dict( # Pass these to the feature resource to help it resolve # field mappings and add related fields (just need for join_feature_class) # Use the layer_selection if it exists since it might have filtered or extra query fields result_field_lookup=(layer_selection or db_entity).result_field_lookup if not metadata else {}, related_field_lookup=( layer_selection or db_entity).related_field_lookup if not metadata else {}, # We use these in the FeatureResource to create a unique id for each join Feature join_model_attributes=layer_selection and layer_selection.result_map.join_model_attributes), is_join_query=True, limit_fields=layer_selection.result_map['result_fields']) else: abstract_feature_resource_class = self.__class__ resource_class = abstract_feature_resource_class.resolve_resource_class( feature_class, queryset=queryset, # Give FeatureResource a reference to the layer_selection additional_fields_dict=merge( dict( # Pass this to the feature resource to help it resolve field mappings result_field_lookup=(layer_selection or db_entity). result_field_lookup if not metadata else {}), dict( # Not sure why it doesn't work to just stick this on the TemplateFeatureResource feature_fields=ListField( attribute='feature_fields', null=True, blank=True, readonly=True), feature_field_title_lookup=PickledDictField( attribute='feature_field_title_lookup', null=True, blank=True, readonly=True), ) if is_template_feature else dict()), for_template=is_template_feature) return resource_class return self