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()
