def bundleItemCollection(modelResource, request, items):
item_list = []
for item in items:
bundle = ModelResource.build_bundle(modelResource, obj=item, request=request)
bundle = ModelResource.full_dehydrate(modelResource, bundle)
item_list.append(bundle)
return item_list;
def _handle_500(self, request, exception):
if settings.DEBUG == False:
settings.DEBUG = True
resp = ModelResource._handle_500(self, request, exception)
settings.DEBUG = False
return resp
else:
return ModelResource._handle_500(self, request, exception)
def dispatch_list(self, request, **kwargs):
self.method_check(request, allowed=['get', 'post'])
self.is_authenticated(request)
self.throttle_check(request)
if 'content_type' in kwargs and 'object_id' in kwargs and request.method=="POST":
data = json.loads(request.body)
if 'profile_id' in data:
profile = get_object_or_404(Profile, pk=data['profile_id'])
else:
profile=request.user.profile
objectprofilelink_item, created = ObjectProfileLink.objects.get_or_create(profile=profile,
content_type=ContentType.objects.get(model=kwargs['content_type']),
object_id=kwargs['object_id'],
level=data['level'],
detail=data['detail'],
isValidated=data['isValidated'])
bundle = self.build_bundle(obj=objectprofilelink_item, request=request)
bundle = self.full_dehydrate(bundle)
bundle = self.alter_detail_data_to_serialize(request, bundle)
return self.create_response(request,
bundle,
response_class=http.HttpCreated,
location=self.get_resource_uri(bundle))
return ModelResource.dispatch_list(self, request, **kwargs)
def dispatch_list(self, request, **kwargs):
""" Handle the dispatching of GFKs. """
self.method_check(request, allowed=["get", "post"])
self.is_authenticated(request)
self.throttle_check(request)
if "content_type" in kwargs and "object_id" in kwargs and request.method == "POST":
data = json.loads(request.body)
if "profile_id" in data:
profile = get_object_or_404(Profile, pk=data["profile_id"])
else:
profile = request.user.profile
objectprofilelink_item, created = ObjectProfileLink.objects.get_or_create( # NOQA
profile=profile,
content_type=ContentType.objects.get(model=kwargs["content_type"]),
object_id=kwargs["object_id"],
level=data["level"],
detail=data["detail"],
isValidated=data["isValidated"],
)
bundle = self.build_bundle(obj=objectprofilelink_item, request=request)
bundle = self.full_dehydrate(bundle)
bundle = self.alter_detail_data_to_serialize(request, bundle)
return self.create_response(
request, bundle, response_class=http.HttpCreated, location=self.get_resource_uri(bundle)
)
return ModelResource.dispatch_list(self, request, **kwargs)
def full_dehydrate(self, bundle, for_list=False):
bundle = ModelResource.full_dehydrate(self, bundle, for_list=for_list)
bundle.related_obj = self
if for_list is True:
fk = fields.ForeignKey(I4pProjectListResource, attribute="master", full=True)
bundle.data["project"] = fk.dehydrate(bundle)
return bundle
def dispatch_list(self, request, **kwargs):
self.method_check(request, allowed=['get', 'post'])
self.is_authenticated(request)
self.throttle_check(request)
if 'content_type' in kwargs and 'object_id' in kwargs and request.method=="POST":
data = json.loads(request.body)
if 'tag' in data:
tag_obj, created = Tag.objects.get_or_create(name=data['tag'], slug=slugify(data['tag']))
params = kwargs.copy()
del params['resource_name']
del params['api_name']
params['tag'] = tag_obj
params['content_type'] = ContentType.objects.get(model=kwargs['content_type'])
tagged_item, created = self._meta.queryset.model.objects.get_or_create(**params)
bundle = self.build_bundle(obj=tagged_item, request=request)
bundle = self.full_dehydrate(bundle)
bundle = self.alter_detail_data_to_serialize(request, bundle)
return self.create_response(request,
bundle,
response_class=http.HttpCreated,
location=self.get_resource_uri(bundle))
return ModelResource.dispatch_list(self, request, **kwargs)
def full_dehydrate(self, bundle, for_list=False):
bundle = ModelResource.full_dehydrate(self, bundle, for_list)
if bundle.obj.picture:
thumbnailer = get_thumbnailer(bundle.obj.picture)
thumbnail_options = {
'size': (ResizeThumbApi.width, ResizeThumbApi.height)
}
bundle.data["thumb"] = thumbnailer.get_thumbnail(
thumbnail_options).url
else:
bundle.data["thumb"] = None
if for_list is False:
bundle.data["tags"] = [
tag.name for tag in Tag.objects.get_for_object(bundle.obj)
]
if (bundle.obj.picture):
thumbnail_options = {
'size': (ResizeDisplay.width, ResizeDisplay.width)
}
bundle.data["image"] = thumbnailer.get_thumbnail(
thumbnail_options).url
else:
bundle.data["image"] = None
try:
bundle.data["article"] = Article.get_for_object(
bundle.obj).render()
except ArticleForObject.DoesNotExist:
bundle.data["article"] = None
return bundle
def obj_create(self, bundle, **kwargs):
self.is_valid(bundle)
if bundle.errors:
raise ImmediateHttpResponse(response=self.error_response(
bundle.request, bundle.errors[self._meta.resource_name]))
return ModelResource.obj_create(self, bundle, **kwargs)
def full_hydrate(self, bundle):
"""
Override to just call tastypie's full_hydrate.
django-tastypie-mongoengine does a lot of extra checks that make some
assumptions that break things in their full_hydrate method.
"""
return ModelResource.full_hydrate(self, bundle)
def apply_filters(self, request, applicable_filters):
if request.user.is_anonymous():
return ModelResource.apply_filters(self, request,
applicable_filters)
return self.get_object_list(request).filter(
**applicable_filters).exclude(
actor_object_id=MakerScienceProfile.objects.get(
parent__user=request.user).id)
def full_dehydrate(self, bundle, for_list=False):
bundle = ModelResource.full_dehydrate(self, bundle, for_list=for_list)
bundle.related_obj = self
if for_list is True:
fk = fields.ForeignKey(I4pProjectListResource,
attribute='master',
full=True)
bundle.data['project'] = fk.dehydrate(bundle)
return bundle
def dehydrate(self, bundle):
bundle = ModelResource.dehydrate(self, bundle)
bundle = ImageMixin.dehydrate(self, bundle)
if bundle.obj.activity == Spirit.ACTIVITY_WANDER:
if bundle.obj.health_current == 0:
bundle.data["experience_given"] = bundle.obj.get_ladder().xp_given
return bundle
def obj_create(self, bundle, **kwargs):
try:
return ModelResource.obj_create(self, bundle, **kwargs)
except IntegrityError:
# This has the negative side-effect of always making the server
# respond with (201) regardless of whether or not the object was
# just created. It would be better if it could return (200) if the
# object already existed.
allocation_id = simplejson.loads(bundle.request.body)['allocation_id']
fileset = models.Fileset.objects.get(allocation_id=allocation_id)
bundle.obj = fileset
return bundle
def api_field_from_django_field(cls, f, default=fields.CharField):
"""
Returns the field type that would likely be associated with each
Django type.
"""
result = default
internal_type = f.get_internal_type()
if internal_type in ('JSONField'):
return JSONApiField
else:
return ModelResource.api_field_from_django_field(f, default)
def api_field_from_django_field(cls, f, default=fields.CharField):
"""
Returns the field type that would likely be associated with each
Django type.
"""
result = default
internal_type = f.get_internal_type()
if internal_type in ('JSONField'):
return JSONApiField
else:
return ModelResource.api_field_from_django_field(f, default)
def obj_create(self, bundle, **kwargs):
try:
return ModelResource.obj_create(self, bundle, **kwargs)
except IntegrityError:
# This has the negative side-effect of always making the server
# respond with (201) regardless of whether or not the object was
# just created. It would be better if it could return (200) if the
# object already existed.
data = simplejson.loads(bundle.request.body)
result = models.Result.objects.get(
pk=resolve_primary_key_from_url(data['result']))
process = models.Process.objects.get(
pk=resolve_primary_key_from_url(data['process']))
process_step = models.ProcessStep.objects.get(process=process,
result=result, label=data['label'])
bundle.obj = process_step
return bundle
def obj_create(self, bundle, **kwargs):
try:
return ModelResource.obj_create(self, bundle, **kwargs)
except IntegrityError:
# This has the negative side-effect of always making the server
# respond with (201) regardless of whether or not the object was
# just created. It would be better if it could return (200) if the
# object already existed.
data = simplejson.loads(bundle.request.body)
tool = models.Tool.objects.get(
source_path=data['tool']['source_path'],
version=data['tool']['version'])
result = models.Result.objects.get(tool=tool,
test_name=data['test_name'],
lookup_hash=models.Result.calculate_lookup_hash(
data['inputs']))
bundle.obj = result
return bundle
def full_dehydrate(self, bundle, for_list=False):
bundle = ModelResource.full_dehydrate(self, bundle, for_list)
if bundle.obj.picture:
thumbnailer = get_thumbnailer(bundle.obj.picture)
thumbnail_options = {'size': (ResizeThumbApi.width, ResizeThumbApi.height)}
bundle.data["thumb"] = thumbnailer.get_thumbnail(thumbnail_options).url
else:
bundle.data["thumb"] = None
if for_list is False:
bundle.data["tags"] = [tag.name for tag in Tag.objects.get_for_object(bundle.obj)]
if(bundle.obj.picture):
thumbnail_options = {'size': (ResizeDisplay.width, ResizeDisplay.width)}
bundle.data["image"] = thumbnailer.get_thumbnail(thumbnail_options).url
else:
bundle.data["image"] = None
try:
bundle.data["article"] = Article.get_for_object(bundle.obj).render()
except ArticleForObject.DoesNotExist:
bundle.data["article"] = None
return bundle
def obj_get_list(self, bundle, **kwargs):
if bundle.request.GET.get("finder"):
if not bundle.request.location:
raise BadRequest(
"Finder cannot be invoked without a location header"
)
if not bundle.request.user.is_authenticated():
raise BadRequest(
"Finder is only available to authenticated users"
)
try:
return self._finder(bundle.request)
except ValidationError as e:
raise BadRequest(e.messages[0])
else:
return ModelResource.obj_get_list(self, bundle, **kwargs)
def dispatch_list(self, request, **kwargs):
self.method_check(request, allowed=['get', 'post'])
self.is_authenticated(request)
self.throttle_check(request)
if 'content_type' in kwargs and 'object_pk' in kwargs and request.method=="POST":
data = json.loads(request.body)
commented_item, created = Comment.objects.get_or_create(comment=data['comment_text'],
user=request.user,
user_name=request.user.username,
content_type=ContentType.objects.get(model=kwargs['content_type']),
object_pk=kwargs['object_pk'],
site_id=settings.SITE_ID,
submit_date=datetime.datetime.now())
bundle = self.build_bundle(obj=commented_item, request=request)
bundle = self.full_dehydrate(bundle)
bundle = self.alter_detail_data_to_serialize(request, bundle)
return self.create_response(request,
bundle,
response_class=http.HttpCreated,
location=self.get_resource_uri(bundle))
return ModelResource.dispatch_list(self, request, **kwargs)
def get_object_list(self, request):
''' Method to return the list of objects via GET method to the Resource (not concrete).
If the variable 'search_type' is present returns the appropriate bundles
which match the searching query. 'search_type' can have several values:
'name' - accompanied by 'q_str' variable containing the search string
returns all Bundles containing the q_str in their name.
'id' - accompanied by 'q_str' variable containing the search string
returns all Bundles containing a record that contains the q_str in their name.
'type' - accompanied by 'q_str' variable containing the search string
returns all Bundles containing a literal attribute with type prov:type
and value containing q_str.
'time' - accompanied by 'start' and/or 'end' variable containing the times
returns all Bundles with within the time frame [strat:end]
'any' - accompanied by 'q_str' variable containing the search string
returns all Bundles containing anything matching q_str.
'''
search_type = request.GET.get('search_type', None)
if not search_type:
return ModelResource.get_object_list(self, request)
try:
if search_type == 'name':
result = search_name(request.GET.get('q_str', None))
elif search_type == 'id':
result = search_id(request.GET.get('q_str', None))
elif search_type == 'type':
result = search_literal(request.GET.get('literal', None) + 'prov#type', request.GET.get('q_str', None))
elif search_type == 'time':
result = search_timeframe(request.GET.get('start', None), request.GET.get('end', None))
elif search_type == 'any':
result = search_any_text_field(request.GET.get('q_str', None))
else:
raise ImmediateHttpResponse(HttpBadRequest())
return result
except:
raise ImmediateHttpResponse(HttpBadRequest())
def test_model_resource_correct_association(self):
api_field = ModelResource.api_field_from_django_field(models.DecimalField())
self.assertEqual(api_field, DecimalField)
def full_dehydrate(self, bundle, for_list=False):
if len(bundle.obj.all()) > 0:
bundle.obj = bundle.obj.all()[0]
return ModelResource.full_dehydrate(self, bundle, for_list=for_list)
def detail_uri_kwargs(self, bundle_or_obj):
kwargs = ModelResource.detail_uri_kwargs(self, bundle_or_obj)
kwargs["resource_name"] = I4pProjectTranslationResource.Meta.resource_name
return kwargs
def detail_uri_kwargs(self, bundle_or_obj):
kwargs = ModelResource.detail_uri_kwargs(self, bundle_or_obj)
kwargs[
"resource_name"] = I4pProjectTranslationResource.Meta.resource_name
return kwargs
def apply_filters(self, request, applicable_filters):
if request.user.is_anonymous():
return ModelResource.apply_filters(self, request, applicable_filters)
return self.get_object_list(request).filter(**applicable_filters).exclude(actor_object_id=MakerScienceProfile.objects.get(parent__user=request.user).id)
def wrapper(request, *args, **kwargs):
return ModelResource.wrap_view(self, view)(request, *args,
**kwargs)
def full_dehydrate(self, bundle, for_list=False):
if len(bundle.obj.all()) > 0:
bundle.obj = bundle.obj.all()[0]
return ModelResource.full_dehydrate(self, bundle, for_list=for_list)
def api_field_from_django_field(cls, f, default=fields.CharField):
# TODO: extensions
r = ModelResource.api_field_from_django_field(f, default=default)
return r
def test_model_resource_correct_association(self):
api_field = ModelResource.api_field_from_django_field(
models.DecimalField())
self.assertEqual(api_field, DecimalField)
def api_field_from_django_field(cls, f, **kwargs):
internal_type = f.get_internal_type()
if internal_type == "BigIntegerField":
return fields.IntegerField
return ModelResource.api_field_from_django_field(f, **kwargs)
def dispatch_detail(self, request, **kwargs):
if "language_code" in kwargs:
translation.activate(kwargs["language_code"])
return ModelResource.dispatch_detail(self, request, **kwargs)
def build_filters(self, filters=None):
if 'tags__contains' in filters:
filters['tags__contains'] = filters['tags__contains'].split(',')
return ModelResource.build_filters(self, filters)
def dispatch_detail(self, request, **kwargs):
if "language_code" in kwargs:
translation.activate(kwargs["language_code"])
return ModelResource.dispatch_detail(self, request, **kwargs)
