class PartyResource(BaseResource): ''' Party API TBD: create a party app ''' knesset_id = fields.IntegerField('knesset_id', null=True) class Meta(BaseResource.Meta): queryset = Party.objects.all() allowed_methods = ['get'] excludes = ['end_date', 'start_date'] include_absolute_url = True def get_object_list(self, request): knesset = request.GET.get('knesset', 'current') if knesset == 'current': return super(PartyResource, self).get_object_list(request).filter( knesset=Knesset.objects.current_knesset()) elif knesset == 'all': return super(PartyResource, self).get_object_list(request) else: return super(PartyResource, self).get_object_list(request).filter( knesset=Knesset.objects.current_knesset())
class TagResource(ModelResource): count = fields.IntegerField(readonly=True) modules = fields.ToManyField( 'learning_modules.api.resources.ModuleTagResource', 'moduletag_set', related_name='tag', full=True) class Meta: queryset = Tag.objects.filter( modules__isnull=False).distinct().order_by("name") resource_name = 'tag' allowed_methods = ['get'] fields = ['id', 'name'] authentication = ApiKeyAuthentication() authorization = Authorization() always_return_data = True include_resource_uri = False serializer = TagJSONSerializer() def dehydrate(self, bundle): return bundle def dehydrate_count(self, bundle): count = Module.objects.filter(tag__id=bundle.obj.id).count() return count def tag_detail(self, request, **kwargs): self.is_authenticated(request) self.throttle_check(request) name = kwargs.pop('name', None) modules = Module.objects.filter(tag__name=name) for m in modules: obj = ModuleResource().build_bundle(obj=m, request=request) response = HttpResponse(name + str(modules), content_type='') return response
class TypeFilteredResource(ModelResource): """ Common resource used to apply faceting to categories, keywords, and regions based on the type passed as query parameter in the form type:layer/map/document""" count = fields.IntegerField() type_filter = None title_filter = None def build_filters(self, filters={}): orm_filters = super(TypeFilteredResource, self).build_filters(filters) if 'type' in filters and filters['type'] in FILTER_TYPES.keys(): self.type_filter = FILTER_TYPES[filters['type']] else: self.type_filter = None if 'title__icontains' in filters: self.title_filter = filters['title__icontains'] return orm_filters
class CollLayerResource(ModelResource): """Light layer api for collections""" tms_url = fields.CharField() djmp_id = fields.IntegerField() typename = fields.CharField() storeType = fields.CharField() bbox_x0 = fields.FloatField() bbox_x1 = fields.FloatField() bbox_y0 = fields.FloatField() bbox_y1 = fields.FloatField() def dehydrate_tms_url(self, bundle): return bundle.obj.layer.link_set.get(name='Tiles').url # def dehydrate_djmp_id(self, bundle): # return Tileset.objects.get(layer_name=bundle.obj.layer.typename).pk def dehydrate_typename(self, bundle): return bundle.obj.layer.typename def dehydrate_storeType(self, bundle): return bundle.obj.layer.storeType def dehydrate_bbox_x0(self, bundle): return bundle.obj.layer.bbox_x0 def dehydrate_bbox_x1(self, bundle): return bundle.obj.layer.bbox_x1 def dehydrate_bbox_y0(self, bundle): return bundle.obj.layer.bbox_y0 def dehydrate_bbox_y1(self, bundle): return bundle.obj.layer.bbox_y1 class Meta: queryset = MapSetLayer.objects.order_by('-layer__storeType') resource_name = 'colllayers'
class TopicCategoryResource(TypeFilteredResource): """Category api""" layers_count = fields.IntegerField(default=0) def dehydrate_layers_count(self, bundle): request = bundle.request obj_with_perms = get_objects_for_user( request.user, 'base.view_resourcebase').filter(polymorphic_ctype__model='layer') filter_set = bundle.obj.resourcebase_set.filter( id__in=obj_with_perms.values('id')) if not settings.SKIP_PERMS_FILTER: filter_set = get_visible_resources( filter_set, request.user if request else None, admin_approval_required=settings.ADMIN_MODERATE_UPLOADS, unpublished_not_visible=settings.RESOURCE_PUBLISHING, private_groups_not_visibile=settings.GROUP_PRIVATE_RESOURCES) return filter_set.distinct().count() def serialize(self, request, data, format, options=None): if options is None: options = {} options['count_type'] = 'category' return super(TopicCategoryResource, self).serialize(request, data, format, options) class Meta: queryset = TopicCategory.objects.all() resource_name = 'categories' allowed_methods = ['get'] filtering = { 'identifier': ALL, } serializer = CountJSONSerializer() authorization = ApiLockdownAuthorization()
class SyncTaskResource(GCloudModelResource): id = fields.IntegerField(attribute='id', readonly=True) creator_name = fields.CharField(attribute='creator_name', readonly=True) status_display = fields.CharField(attribute='status_display', readonly=True) class Meta: queryset = SyncTask.objects.all() resource_name = 'sync_task' authorization = SuperAuthorization() always_return_data = True serializer = AppSerializer() filtering = { "id": ALL, "creator": ALL, "create_method": ALL, "start_time": ALL, "finish_time": ALL, "status": ALL, } q_fields = ["id", "pipeline_template__name"] limit = 0 def obj_create(self, bundle, **kwargs): model = bundle.obj.__class__ if model.objects.filter(status=RUNNING).exists(): raise BadRequest( 'There is already a running sync task, please wait for it to complete and try again' ) if not CachePackageSource.objects.all().exists(): raise BadRequest( 'No cache package found, please add cache package in Backend Manage' ) if len(PackageSourceResource.get_all_source_objects()) <= 1: raise BadRequest( 'No original packages found, please add original packages in Backend Manage' ) return super(SyncTaskResource, self).obj_create(bundle, **kwargs)
class ReceiptResource(MongoDBResource): id = fields.CharField(attribute='_id') migros_id = fields.CharField(attribute='migros_id') timestamp = fields.IntegerField(attribute='timestamp') items = fields.ListField(attribute='items') co2 = fields.FloatField(attribute='co2') class Meta: queryset = Receipt.objects.all() allowed_methods = ('get') resource_name = 'receipt' filtering = {} collection = 'receipts' def get_collection(self): return Receipt._get_collection() def get_list(self, request, **kwargs): if 'client_id' not in request.GET: raise Exception('No receipt_id specified') client_id = request.GET['client_id'] until = request.GET.get('until', int(time.time())) since = request.GET.get('since', until - 100 * 86400) return HttpResponse(json.dumps([self._convert_document_to_dict(rec) for rec in Receipt.objects.filter(client_id=client_id, timestamp__gte=since, timestamp__lte=until)]), content_type='application/json') def _convert_document_to_dict(self, document): result = {} for field in document._fields.keys(): if field == '_id' or field == 'id': continue if document[field]: result[field] = document[field] return result
class TodoListResource(ModelResource): created_by = fields.ForeignKey(UserResource, 'created_by') shared_with = fields.ManyToManyField(UserResource, 'shared_with') open_todos = fields.IntegerField() class Meta: queryset = TodoList.objects.all() resource_name = 'todolist' always_return_data = True authorization = Authorization() filtering = { 'created_by': ALL_WITH_RELATIONS, 'shared_with': ALL_WITH_RELATIONS, } def prepend_urls(self): return [ url( r"^(?P<resource_name>%s)/mytodolists%s$" % (self._meta.resource_name, trailing_slash()), self.wrap_view('get_all')), ] def get_all(self, request, **kwargs): self.method_check(request, allowed=['get']) result = [] for x in TodoList.objects.filter( Q(created_by=request.user.id) | Q(shared_with__id=request.user.id)): bundle = self.build_bundle(obj=x, request=request) bundle = self.full_dehydrate(bundle, for_list=True) data_dict = self._meta.serializer.to_simple(bundle, None) result.append(data_dict) return self.create_response(request, result) def dehydrate_open_todos(self, bundle): # print bundle.obj, type(bundle.obj), bundle.obj.id return Todo.objects.filter(todolist=bundle.obj.id, done=False).count()
class KafkaResource(resources.Resource): """! @brief A read-only, singleton resource that will return connection details to this Productstatus server's Kafka brokers and topic. """ id = fields.CharField(attribute='id', readonly=True) brokers = fields.ListField(attribute='brokers', readonly=True) topic = fields.CharField(attribute='topic', readonly=True) ssl = fields.BooleanField(attribute='ssl', readonly=True) ssl_verify = fields.BooleanField(attribute='ssl_verify', readonly=True) heartbeat_interval = fields.IntegerField(attribute='heartbeat_interval', readonly=True) class Meta: allowed_methods = ['get'] resource_name = 'kafka' object_class = KafkaConfiguration authentication = authentication.Authentication() serializer = Serializer() def detail_uri_kwargs(self, bundle_or_obj): return {'pk': settings.KAFKA_SINGLETON_PK} def get_object_list(self, *args, **kwargs): return [self.obj_get(pk=settings.KAFKA_SINGLETON_PK)] def obj_get_list(self, bundle, **kwargs): return self.get_object_list() def obj_get(self, *args, **kwargs): if kwargs['pk'] != settings.KAFKA_SINGLETON_PK: raise tastypie.exceptions.NotFound( 'The Kafka resource is only available as "%s"' % settings.KAFKA_SINGLETON_PK) return KafkaObject() def rollback(self, *args, **kwargs): pass
class PackageResource(ModelResource): releases = fields.ToManyField("packages.api.ReleaseResource", "releases") downloads = fields.IntegerField("downloads") latest = fields.ToOneField("packages.api.InlineReleaseResource", "latest", full=True) class Meta: allowed_methods = ["get"] cache = SimpleCache() fields = ["created", "downloads_synced_on", "downloads", "name"] filtering = { "name": ALL, "created": ALL, "downloads_synced_on": ALL, } include_absolute_url = True ordering = ["created", "downloads_synced_on"] queryset = Package.objects.all() resource_name = "package" def override_urls(self): return [ url(r"^(?P<resource_name>%s)/(?P<name>[^/]+)%s$" % (self._meta.resource_name, trailing_slash()), self.wrap_view("dispatch_detail"), name="api_dispatch_detail"), ] def get_resource_uri(self, bundle_or_obj): kwargs = { "resource_name": self._meta.resource_name, } if isinstance(bundle_or_obj, Bundle): kwargs["name"] = bundle_or_obj.obj.name else: kwargs["name"] = bundle_or_obj.name if self._meta.api_name is not None: kwargs["api_name"] = self._meta.api_name return self._build_reverse_url("api_dispatch_detail", kwargs=kwargs)
class WfpProfileResource(ProfileResource): """ WFP Profile API """ wfpdocs_count = fields.IntegerField(default=0) def dehydrate_wfpdocs_count(self, bundle): obj_with_perms = get_objects_for_user(bundle.request.user, 'base.view_resourcebase').instance_of(WFPDocument) return bundle.obj.resourcebase_set.filter(id__in=obj_with_perms.values('id')).distinct().count() class Meta: queryset = get_user_model().objects.exclude(username='******') resource_name = 'wfp-profiles' authorization = GeoNodeAuthorization() allowed_methods = ['get'] ordering = ['username', 'date_joined'] excludes = ['is_staff', 'password', 'is_superuser', 'is_active', 'last_login'] filtering = { 'username': ALL, } serializer = CountJSONSerializer()
class CaptureJobResource(DefaultResource): guid = fields.CharField(attribute='link_id') status = fields.CharField(attribute='status') attempt = fields.IntegerField(attribute='attempt') step_count = fields.FloatField(attribute='step_count') step_description = fields.CharField(attribute='step_description', blank=True, null=True) capture_start_time = fields.DateTimeField(attribute='capture_start_time', blank=True, null=True) capture_end_time = fields.DateTimeField(attribute='capture_end_time', blank=True, null=True) # calculated fields queue_position = fields.DateTimeField(attribute='queue_position') class Meta(DefaultResource.Meta): resource_name = 'capture_jobs' queryset = CaptureJob.objects.all() detail_uri_name = 'link_id' def prepend_urls(self): """ URLs should match on CaptureJob.link_id as well as CaptureJob.id. """ return [ url(r"^(?P<resource_name>%s)/(?P<link_id>[\w\d-]+)/?$" % self._meta.resource_name, self.wrap_view('dispatch_detail'), name="api_dispatch_detail"), ]
class GameResource(ModelResource): num_players = fields.IntegerField(attribute='num_players',readonly=True) comma_players = fields.CharField(attribute='comma_players',readonly=True) class Meta: queryset=Game.objects.all() ### # POST/PUT # new Player (+User) # new Game # make move # add/remove player to game? # delete player/game/etc? # new colors? # new BoardSetup # GET # players # game # boardsetup # gameplayers # ###
class SprintResource(ModelResource): project = user = fields.ToOneField(_ProjectResource, 'project', full=True) start_date_f = fields.CharField(attribute='start_date_f', readonly=True) end_date_f = fields.CharField(attribute='end_date_f', readonly=True) num_discussions = fields.IntegerField(attribute='num_discussions', readonly=True) num_tasks = fields.CharField(attribute='num_tasks', readonly=True) num_tasks_completed = fields.CharField(attribute='num_tasks_completed', readonly=True) class Meta: allowed_methods = ['get'] queryset = Sprint.objects.all() authentication = SessionAuthentication() serializer = DateSerializer() fields = ('id', 'name', 'start_date_f', 'end_date_f', 'num_discussions', 'num_tasks', 'num_tasks_completed') filtering = {'project': ALL_WITH_RELATIONS} #todo authorization #todo darle formato a las fechas http://django-tastypie.readthedocs.org/en/latest/serialization.html#format-datetime
class PlaylistProgressDetailResource(CoachReportBaseResource): kind = fields.CharField(attribute='kind') status = fields.CharField(attribute='status') title = fields.CharField(attribute='title') score = fields.IntegerField(attribute='score') path = fields.CharField(attribute='path') class Meta: resource_name = "playlist_progress_detail" object_class = PlaylistProgressDetail def get_object_list(self, request): user_id = request.GET.get("user_id") playlist_id = request.GET.get("playlist_id") language = request.language result = PlaylistProgressDetail.user_progress_detail( user_id=user_id, playlist_id=playlist_id, language=language) if not result: raise NotFound( "User playlist progress details with user ID '%s' and playlist ID '%s' were not found." % (user_id, playlist_id)) return result
class LocationResource(MongoDBResource): id = fields.CharField(attribute="_id") analysis_id = fields.CharField(attribute="analysis_id") url_id = fields.CharField(attribute="url_id") content_id = fields.CharField(attribute="content_id") content_type = fields.CharField(attribute="content_type", null=True) mime_type = fields.CharField(attribute="mime_type", null=True) flags = fields.DictField(attribute="flags", null=True) md5 = fields.CharField(attribute="md5", null=True) sha256 = fields.CharField(attribute="sha256", null=True) size = fields.IntegerField(attribute="size", null=True) class Meta: resource_name = 'location' authentication = MultiAuthentication(SessionAuthentication(), ApiKeyAuthentication()) authorization = OwnAndSharedObjectsOnlyNonRelAuthorization() allowed_methods = ['get'] object_class = Document collection = "locations" detail_uri_name = "_id" filtering = { 'analysis_id': ['exact'], }
class TypeFilteredResource(ModelResource): """ Common resource used to apply faceting to categories and keywords based on the type passed as query parameter in the form type:layer/map/document""" count = fields.IntegerField() type_filter = None def dehydrate_count(self, bundle): raise Exception('dehydrate_count not implemented in the child class') def build_filters(self, filters={}): orm_filters = super(TypeFilteredResource, self).build_filters(filters) if 'type' in filters and filters['type'] in FILTER_TYPES.keys(): self.type_filter = FILTER_TYPES[filters['type']] else: self.type_filter = None return orm_filters def filter_security(self, obj, user): """ Used to check whether the item should be included in the counts or not""" return user.has_perm(perms[obj.class_name]['view'], obj)
class OrganizationResource(DefaultResource): id = fields.IntegerField(attribute='id') name = fields.CharField(attribute='name') registrar = fields.CharField(attribute='registrar__name') default_to_private = fields.BooleanField(attribute='default_to_private', null=True, blank=True) shared_folder = fields.ForeignKey('api.resources.FolderResource', 'shared_folder', null=True, blank=True, full=True) class Meta(DefaultResource.Meta): resource_name = 'organizations' queryset = Organization.objects.select_related('registrar', 'shared_folder') ordering = ['name', 'registrar'] class Nested: folders = fields.ToManyField('api.resources.FolderResource', 'folders', null=True)
class BookResourceV3(ModelResource): gutenberg_id = fields.IntegerField("gutenberg_id") # author = fields.CharField("author") authors = fields.ManyToManyField('hedonometer.api.GutAuthorResource', 'authors', full=True) class Meta: queryset = GutenbergBook.objects.all() resource_name = "gutenbergv3" # excludes = ["happs","id","filename",] include_resource_uri = False max_limit = None limit = 5000 filtering = { "title": ALL_WITH_RELATIONS, "authors": ALL_WITH_RELATIONS, "length": ALL_WITH_RELATIONS, "exclude": ALL_WITH_RELATIONS, "downloads": ALL_WITH_RELATIONS, "numUniqWords": ALL_WITH_RELATIONS, "lang_code_id": ALL_WITH_RELATIONS, }
class NodeSetListResource(ModelResource): study = fields.ToOneField(StudyResource, 'study') assay = fields.ToOneField(AssayResource, 'assay') node_count = fields.IntegerField(attribute='node_count',readonly=True) is_implicit = fields.BooleanField(attribute='is_implicit') class Meta: # create node count attribute on the fly - node_count field has to be defined on resource queryset = NodeSet.objects.all().order_by( '-is_current', 'name') detail_resource_name = 'nodeset' # NG: introduced to get correct resource ids resource_name = 'nodesetlist' detail_uri_name = 'uuid' # for using UUIDs instead of pk in URIs authentication = SessionAuthentication() authorization = GuardianAuthorization() fields = [ 'is_current', 'name', 'summary', 'assay', 'study', 'uuid' ] allowed_methods = ["get" ] filtering = { "study": ALL_WITH_RELATIONS, "assay": ALL_WITH_RELATIONS } ordering = [ 'is_current', 'name', 'node_count' ]; def dehydrate(self, bundle): # replace resource URI to point to the nodeset resource instead of the nodesetlist resource bundle.data['resource_uri'] = bundle.data['resource_uri'].replace( self._meta.resource_name, self._meta.detail_resource_name ) return bundle
class RegionResource(CORSResource, MarketplaceResource): name = fields.CharField('name') slug = fields.CharField('slug') id = fields.IntegerField('id') default_currency = fields.CharField('default_currency') default_language = fields.CharField('default_language') has_payments = fields.BooleanField('has_payments') ratingsbodies = fields.ListField('ratingsbodies') class Meta(MarketplaceResource.Meta): detail_allowed_methods = ['get'] list_allowed_methods = ['get'] resource_name = 'region' slug_lookup = 'slug' def dehydrate_ratingsbodies(self, bundle): return [rb.name for rb in bundle.obj.ratingsbodies] def obj_get_list(self, request=None, **kwargs): return REGIONS_DICT.values() def obj_get(self, request=None, **kwargs): return REGIONS_DICT.get(kwargs['pk'], None)
class BaseModelResource(ModelResource): id = fields.IntegerField('id') def create_response(self, request, data, response_class=HttpResponse, **response_kwargs): ''' Extracts the common 'which-format/serialize/return-response' cycle. Mostly a useful shortcut/hook. ''' desired_format = self.determine_format(request) serialized = self.serialize(request, data, desired_format) return response_class(content=serialized, content_type=build_content_type(desired_format), **response_kwargs) class Meta: abstract = True limit = 100 include_resource_uri = False allowed_methods = ['get'] fields = [ 'id', ] throttle = CacheThrottle(throttle_at=10, timeframe=60) authentication = MultiAuthentication(ApiKeyAuthentication(), SessionAuthentication()) def _handle_500(self, request, exception): data = {'error_message': str(exception)} return self.error_response(request, data, response_class=http.HttpApplicationError)
class LanguageMapResource(Resource): label = fields.CharField(attribute='label') language = fields.CharField(attribute='language') isocode = fields.CharField(attribute='isocode') latitude = fields.FloatField(attribute='latitude') longitude = fields.FloatField(attribute='longitude') url = fields.CharField(attribute='url') count = fields.IntegerField(attribute='count') def determine_format(self, request): return 'application/json' class Meta: limit = 0 # show all include_resource_uri = False allowed_methods = ['get'] cache = SimpleCache(timeout=60 * 24, public=True) default_format = 'application/json' def obj_get_list(self, bundle, **kwargs): # Filtering disabled for brevity... return self.get_object_list(bundle.request) def get_object_list(self, request): results = [] for L in Language.objects.annotate(count=Count('lexicon')).all(): if L.count > 0: results.append({ 'isocode': L.isocode, 'language': L.language, 'label': L.language, 'url': reverse( 'language-detail', kwargs={'language': L.slug} ), 'count': L.count, }) return prepare_map_data(results)
class FlaggedContentResource(LoggedMixin, resources.ModelResource): video = fields.ToOneField(VideoResource, attribute='video_content', null=True, full=True, readonly=True) positionupdate = fields.ToOneField(PositionUpdateResource, attribute='positionupdate_content', null=True, full=True, readonly=True) runnertag = fields.ToOneField(RunnerTagResource, attribute='runnertag_content', null=True, full=True, readonly=True), user_id = fields.IntegerField(attribute="user_id", null=True, blank=True, readonly=True) class Meta: queryset = ContentFlag.objects.order_by("-flag_date") resource_name = 'flaggedcontent' fields = ['id', 'flag_date', 'content_type', 'content_id', 'reason'] allowed_methods = ['get', 'post'] authentication = LoggedMultiAuthentication(AnonymousAuthentication()) authorization = FlaggedContentAuthorization() ordering = ["flag_date"] def hydrate(self, bundle): if bundle.request.user.is_anonymous(): bundle.obj.user = None else: bundle.obj.user = bundle.request.user return bundle
class LOResource(Resource): pk = fields.IntegerField(attribute='pk') title = fields.CharField(attribute='title', default="") description = fields.CharField(attribute='description', default="") class Meta: resource_name = 'lo' object_class = LO authorization = Authorization() offset = 100 limit = 100 def detail_uri_kwargs(self, bundle_or_obj): kwargs = {} # print bundle_or_obj.request.META['HTTP_HOST'] if isinstance(bundle_or_obj, Bundle): kwargs['pk'] = bundle_or_obj.obj.pk else: if bundle_or_obj is not None: kwargs['pk'] = bundle_or_obj.pk kwargs['resource_name'] = self._meta.resource_name if self._meta.api_name is not None: kwargs['api_name'] = self._meta.api_name return kwargs def get_object_list(self, request): return DATA def obj_get_list(self, bundle, **kwargs): return self.get_object_list(bundle.request) def obj_get(self, bundle, **kwargs): all_obj = DATA obj = filter(lambda x: int(x.pk) == int(kwargs['pk']), all_obj) if obj != []: return obj[0]
class TagResource(USSModelResource): """ It will be used for getting contacts of given parents And updating the contact details """ count = fields.IntegerField(attribute="count", null=True) class Meta: resource_name = 'tags' queryset = Tag.objects.all() authorization = Authorization() def get_object_list(self, request): user_id = request.user.id if not user_id: raise ImmediateHttpResponse(HttpBadRequest("Please login first")) this_user_tags = super(TagResource, self).get_object_list(request).filter(user_id=user_id) return this_user_tags def alter_list_data_to_serialize(self, request, data): user_id = request.user.id if not user_id: raise ImmediateHttpResponse(HttpBadRequest("Please login first")) tags = Tag.objects.raw("""SELECT tag.id, count(*) as count from uss_tag as tag JOIN uss_urldesc_tags as urldesc_tags on tag.id =urldesc_tags.tag_id where tag.user_id=%s group by tag.id""", [user_id]) tag_map = {} for tag in tags: tag_map[tag.id] = tag.count objects = data['objects'] for obj in objects: obj.data["count"] = tag_map.get(obj.data["id"], 0) return data
class VictimResource(ModelResource): # foreign keys incident = fields.ForeignKey(IncidentResource, 'incident') incident_id = fields.IntegerField(attribute='incident_id') method = fields.ForeignKey(MethodResource, 'method', blank=True, null=True, full=True) race = fields.ForeignKey(RaceResource, 'race', blank=True, null=True, full=True) # normalize names name = fields.CharField(attribute='get_display_name', blank=True, null=True) class Meta: allowed_methods = ('get', ) queryset = (Victim.objects.public().select_related( 'incident', 'race', 'method').filter(incident__point__isnull=False)) excludes = Victim.NAME_FIELDS + ('display_name', 'public', 'residence_address') filtering = { 'age': ALL, 'incident': ALL_WITH_RELATIONS, 'name': ALL, 'race': ALL_WITH_RELATIONS }
class CategoryResource(Resource): category_list = fields.ListField(attribute='category_list') category_count = fields.IntegerField(attribute='category_count') class Meta: resource_name = 'category' object_class = BaseJsonModel fields = ['category_list', 'category_count'] allowed_methods = ['get'] include_resource_uri = False serializer = Serializer(formats=['json', 'jsonp']) def get_object_list(self, request=None, **kwargs): tmp = Product.objects.values_list('category',flat=True) category_list = sorted(list(set(tmp))) category_count = len(category_list) result = BaseJsonModel() result.category_list = category_list result.category_count = category_count return [result] def obj_get_list(self, bundle, **kwargs): return self.get_object_list(bundle.request)
class SiteComponentsResource(ChemblModelResource): domain = fields.ForeignKey( 'chembl_webservices.resources.binding_site.ComponentDomainsResource', 'domain', full=True, null=True, blank=True) component_id = fields.IntegerField('component__pk', null=True, blank=True) class Meta(ChemblResourceMeta): excludes = ['site_residues'] queryset = SiteComponents.objects.all() resource_name = 'site_component' collection_name = 'site_components' serializer = ChEMBLApiSerializer(resource_name, {collection_name: resource_name}) filtering = { 'component_id': NUMBER_FILTERS, 'sitecomp_id': NUMBER_FILTERS, 'domain': ALL_WITH_RELATIONS, } ordering = filtering.keys()
class ReportResource(BaseResource): study = fields.ToOneField("kindred.api.project.StudyResource", "study") owner = fields.ToOneField("kindred.api.users.UserResource", "owner") query = JSONField(attribute="query", blank=True, null=True) order_by = SpaceListField(attribute="order_by") list_columns = SpaceListField(attribute="list_columns") group_by = SpaceListField(attribute="group_by") count = fields.IntegerField(readonly=True, use_in="detail") result = fields.ListField(readonly=True, use_in="detail") class Meta(BaseResource.Meta): queryset = reports.Report.objects.all() ordering = ["id"] filtering = { "study": tastypie.constants.ALL, "owner": tastypie.constants.ALL, } def dehydrate_count(self, bundle): qs = bundle.obj.get_qs() return qs.count() def dehydrate_result(self, bundle): return bundle.obj.get_groups()