def get(request, user_id=None):
# Single user
if user_id:
u = get_object(LocastUser, id=user_id)
content = api_serialize(u)
return APIResponseOK(content=content, total=1)
# Multiple users
else:
q = QueryTranslator(LocastUser, ruleset)
query = request.GET.copy()
objs = total = pg = None
try:
objs = q.filter(query)
objs, total, pg = paginate(objs, request.GET)
except InvalidParameterException, e:
raise APIBadRequest(e.message)
user_arr = []
for m in objs:
user_arr.append(api_serialize(m, request))
return APIResponseOK(content=user_arr, total=total, pg=pg)
def get(request, postcard_id=None, coll_id=None, format='.json'):
# single postcard
if postcard_id:
postcard = get_object(models.Postcard, id=postcard_id)
if not postcard.allowed_access(request.user):
raise exceptions.APIForbidden
postcard_dict = api_serialize(postcard, request)
return APIResponseOK(content=postcard_dict, total=1)
# multiple postcards
else:
base_query = models.Postcard.get_privacy_q(request) & \
Q(content_state=4)
q = qstranslate.QueryTranslator(models.Postcard, ruleset, base_query)
query = request.GET.copy()
objs = total = pg = None
try:
objs = q.filter(query)
objs, total, pg = paginate(objs, request.GET)
except qstranslate.InvalidParameterException, e:
raise exceptions.APIBadRequest(e.message)
postcard_arr = []
for p in objs:
postcard_arr.append(api_serialize(p, request))
return APIResponseOK(content=postcard_arr, total=total, pg=pg)
def post_media_content(request, cast_id, media_id):
get_object(models.Cast, cast_id)
media = get_object(models.Media, media_id)
if not media.author == request.user:
raise exceptions.APIForbidden
content_type = get_param(request.META, 'CONTENT_TYPE')
mime_type = content_type.split(';')[0]
# Form upload
if mime_type == 'multipart/form-data':
# multipart/form-data; boundary=----pluploadboundaryp15s131vjl18tdnlk1sj11min19p42
file = get_param(request.FILES, 'file')
if not file:
#TODO: perhaps if there is no file, and there is an error, delete the original?
raise exceptions.APIBadRequest('Error uploading file!')
media.content.file.save(file.name, file, save=True)
else:
media.content.create_file_from_data(request.body, mime_type)
# media is the generic holder, media.content is the specific
# content model (ImageMedia, VideoMedia etc.).
media.content.content_state = models.Media.STATE_COMPLETE
media.content.save()
return APIResponseOK(content=api_serialize(media, request))
def photo_from_post(request, postcard_id, photo = None):
data = {}
if photo:
data = api_serialize(photo)
data.update(get_json(request.raw_post_data))
data['postcard'] = postcard_id
location = None
if 'location' in data:
location = data['location']
if not photo:
data['author'] = request.user.id
else:
data['author'] = photo.author.id
# Modified and created cannot be set
if 'modified' in data: del data['modified']
if 'created' in data: del data['created']
try:
photo = form_validate(forms.PhotoAPIForm, data, instance = photo)
# If the error is a UUID conflict, return the uri to the client
except exceptions.APIBadRequest, e:
error = simplejson.loads(e.message)
if 'uuid' in error:
# uuid errors almost always indicate that there's a conflict. find it
conflicting = models.Photo.objects.get(uuid = data['uuid'])
if conflicting:
error['uri'] = conflicting.get_api_uri()
raise exceptions.APIConflict(simplejson.dumps(error))
else:
raise e
def _api_serialize(self, request=None):
return dict(
user=self.user.username,
time=unicode(self.time),
action=self.action,
object_type = ContentType.objects.get_for_model(self.content_object).model,
object=api_serialize(self.content_object, request=None))
def _api_serialize(self, request=None):
return dict(
user=self.user.username,
time=unicode(self.time),
action=self.action,
object_type = ContentType.objects.get_for_model(self.content_object).model,
object=api_serialize(self.content_object, request=None))
def get_media_content(request, cast_id, media_id):
media = get_object(models.Media, media_id)
cast = check_cast_media(media_id, cast_id)
if not cast.allowed_access(request.user):
raise exceptions.APIForbidden
media_dict = api_serialize(media, request)
return APIResponseOK(content=media_dict, total=1)
def get_media_content(request, cast_id, media_id):
media = get_object(models.Media, media_id)
cast = check_cast_media(media_id, cast_id)
if not cast.allowed_access(request.user):
raise exceptions.APIForbidden
media_dict = api_serialize(media, request)
return APIResponseOK(content=media_dict, total=1)
def get_photo(request, postcard_id, photo_id = None):
if photo_id:
photo = get_object(models.Photo, photo_id)
check_postcard_photo(postcard_id, photo_id)
return APIResponseOK(content=api_serialize(photo.contentmodel))
else:
postcard = get_object(models.Postcard, postcard_id)
if not postcard.allowed_access(request.user):
raise exceptions.APIForbidden
photo_dicts = []
for p in postcard.postcardcontent_set.all():
photo_dicts.append(api_serialize(p, request))
return APIResponseOK(content=photo_dicts)
def cast_from_post(request, cast = None):
data = {}
# this allows PUT operations to only send the data they
# are interested in updating
if cast:
data = api_serialize(cast)
data.update(get_json(request.body))
if not cast:
data['author'] = request.user.id
else:
data['author'] = cast.author.id
# Tags won't validate correctly, so store them to set later
tags = None
if 'tags' in data:
tags = data['tags']
del data['tags']
# Location needs to be set manually
location = None
if 'location' in data:
location = data['location']
# check to make sure its within
boundary = models.Boundary.objects.get_default_boundary()
if boundary and (not Point(location[0], location[1]).within(boundary.bounds)):
raise exceptions.APIBadRequest('{"location":"outside default boundary"}')
del data['location']
# Modified and created cannot be set
if 'modified' in data: del data['modified']
if 'created' in data: del data['created']
# Maps privacy names to values
if 'privacy' in data:
data['privacy'] = models.Cast.get_privacy_value(data['privacy'])
cast = form_validate(forms.CastAPIForm, data, instance = cast)
if not tags == None:
# Clear all tags
if tags == "":
cast.tags.all().delete()
cast.set_tags(tags)
if location:
cast.set_location(location[0], location[1])
cast.save()
return cast
def _api_serialize(self, request):
d = Syncable._api_serialize(self, request)
author = api_serialize(self.author)
d['author'] = author
if request:
d['is_author'] = self.is_author(request.user)
d['allowed_edit'] = self.allowed_edit(request.user)
return d
def get_media(request, cast_id):
cast = get_object(models.Cast, cast_id)
if not cast.allowed_access(request.user):
raise exceptions.APIForbidden
media_dicts = []
for m in cast.media_set.all():
media_dicts.append(api_serialize(m, request))
return APIResponseOK(content=media_dicts)
def get_media(request, cast_id):
cast = get_object(models.Cast, cast_id)
if not cast.allowed_access(request.user):
raise exceptions.APIForbidden
media_dicts = []
for m in cast.media_set.all():
media_dicts.append(api_serialize(m, request))
return APIResponseOK(content=media_dicts)
def _api_serialize(self, request):
d = Syncable._api_serialize(self, request)
author = api_serialize(self.author)
d['author'] = author
if request:
d['is_author'] = self.is_author(request.user)
d['allowed_edit'] = self.allowed_edit(request.user)
return d
def put(request, cast_id, coll_id=None):
if coll_id: check_collection(cast_id, coll_id)
cast = get_object(models.Cast, cast_id)
if not cast.allowed_edit(request.user):
raise exceptions.APIForbidden
cast = cast_from_post(request, cast)
cast.save()
return APIResponseOK(content=api_serialize(cast, request))
def put(request, cast_id, coll_id=None):
if coll_id: check_collection(cast_id, coll_id)
cast = get_object(models.Cast, cast_id)
if not cast.allowed_edit(request.user):
raise exceptions.APIForbidden
cast = cast_from_post(request, cast)
cast.save()
return APIResponseOK(content=api_serialize(cast, request))
def post_photo(request, postcard_id, photo_id = None):
postcard = get_object(models.Postcard, id = postcard_id)
if not postcard.allowed_edit(request.user):
raise exceptions.APIForbidden
# If there is a photo_id, posting raw photo data to a photo
if photo_id:
photo = get_object(models.Photo, id = photo_id)
check_postcard_photo(postcard_id, photo_id)
if not photo.is_author(request.user):
raise exceptions.APIForbidden
content_type = get_param(request.META, 'CONTENT_TYPE')
mime_type = content_type.split(';')[0]
if not mime_type:
raise exceptions.APIBadRequest('Invalid file type!')
try:
photo.create_file_from_data(request.raw_post_data, mime_type)
except LocastContent.InvalidMimeType:
raise exceptions.APIBadRequest('Invalid file type!')
try:
import Image
i = Image.open(photo.file.path)
i.load()
except IOError:
raise exceptions.APIBadRequest('Corrupted image!')
return APIResponseOK(content=api_serialize(photo.contentmodel))
# If there is not, posting a new photo object
else:
photo = photo_from_post(request, postcard_id)
photo.save()
return APIResponseCreated(content=api_serialize(photo.contentmodel, request), location=photo.get_api_uri())
def _api_serialize(self, request):
d = {}
author = api_serialize(self.author)
d['author'] = author
d['created'] = datetostr(self.created)
d['modified'] = datetostr(self.modified)
if request:
d['is_author'] = self.is_author(request.user)
d['allowed_edit'] = self.allowed_edit(request.user)
return d
def put(request, postcard_id = None):
if not postcard_id:
pass
postcard = get_object(models.Postcard, postcard_id)
if not postcard.is_author(request.user):
raise exceptions.APIForbidden
postcard = postcard_from_post(request, postcard)
postcard.save()
return APIResponseOK(content=api_serialize(postcard, request))
def _api_serialize(self, request):
d = {}
author = api_serialize(self.author)
d['author'] = author
d['created'] = datetostr(self.created)
d['modified'] = datetostr(self.modified)
if request:
d['is_author'] = self.is_author(request.user)
d['allowed_edit'] = self.allowed_edit(request.user)
return d
def get(request, coll_id = None):
if coll_id:
collection = get_object(Collection, id=coll_id)
collection_dict = api_serialize(collection, request)
return APIResponseOK(content=collection_dict, total=1)
else:
query = request.GET.copy()
q = QueryTranslator(Collection, ruleset)
try:
objs = q.filter(query)
except InvalidParameterException, e:
raise APIBadRequest(e)
objs, total, pg = paginate(objs, query)
collection_arr = []
for i in objs:
collection_arr.append(api_serialize(i, request))
return APIResponseOK(content=collection_arr, total=total, pg=pg)
def get(request, coll_id=None):
if coll_id:
collection = get_object(Collection, id=coll_id)
collection_dict = api_serialize(collection, request)
return APIResponseOK(content=collection_dict, total=1)
else:
query = request.GET.copy()
q = QueryTranslator(Collection, ruleset)
try:
objs = q.filter(query)
except InvalidParameterException, e:
raise APIBadRequest(e)
objs, total, pg = paginate(objs, query)
collection_arr = []
for i in objs:
collection_arr.append(api_serialize(i, request))
return APIResponseOK(content=collection_arr, total=total, pg=pg)
def put_photo(request, postcard_id, photo_id = None):
if not photo_id:
return HttpResponseNotAllowed(['GET', 'POST', 'HEAD'])
photo = get_object(models.Photo, photo_id)
check_postcard_photo(postcard_id, photo_id)
if not photo.allowed_edit(request.user):
raise exceptions.APIForbidden
photo = photo_from_post(request, postcard_id, photo)
photo.save()
return APIResponseOK(content=api_serialize(photo, request))
def traveler_js(request):
boundary_obj = Boundary.objects.get_default_boundary()
boundary = 'null';
mp_list = []
# The default one should go first
for mp in MapPlace.objects.order_by('-default'):
mp_list.append(api_serialize(mp))
map_place_json = json.dumps(mp_list)
if boundary_obj:
boundary = boundary_obj.bounds.geojson
return render_to_response('traveler.django.js', locals(),
context_instance = RequestContext(request), mimetype='text/javascript')
def post(request, cast_id=None, coll_id=None):
if cast_id:
raise exceptions.APIBadRequest('Attempting to post with a cast id specified')
coll = None
if coll_id:
coll = get_object(models.Collection, coll_id)
cast = cast_from_post(request)
if coll:
coll.related_casts.add(cast)
cast.save()
models.UserActivity.objects.create_activity(request.user, cast, 'created')
return APIResponseCreated(content=api_serialize(cast, request), location=cast.get_api_uri())
def post(request, cast_id=None, coll_id=None):
if cast_id:
raise exceptions.APIBadRequest('Attempting to post with a cast id specified')
coll = None
if coll_id:
coll = get_object(models.Collection, coll_id)
cast = cast_from_post(request)
if coll:
coll.related_casts.add(cast)
cast.save()
models.UserActivity.objects.create_activity(request.user, cast, 'created')
return APIResponseCreated(content=api_serialize(cast, request), location=cast.get_api_uri())
def post_media(request, cast_id):
data = get_json(request.body)
cast = get_object(models.Cast, cast_id)
if not cast.allowed_edit(request.user):
raise exceptions.APIForbidden
if 'content_type' in data:
content_type = data['content_type']
del data['content_type']
else:
raise exceptions.APIBadRequest('missing "content_type"')
data['language'] = translation.get_language()
data['author'] = request.user.id
form_model = None
if content_type == 'videomedia':
form_model = forms.VideoMediaForm
elif content_type == 'imagemedia':
form_model = forms.ImageMediaForm
elif content_type == 'linkedmedia':
form_model = forms.LinkedMediaForm
media = form_validate(form_model, data)
cast.media_set.add(media)
models.UserActivity.objects.create_activity(request.user, media, 'created')
# this is needed as for some odd reason, it doesn't return an object with author, modified, etc.
# TODO investigate why this is needed, perhaps it can be fixed by using media.content
media = get_object(models.Media, media.id)
return APIResponseCreated(content=api_serialize(media, request), location=media.get_api_uri())
def post_media(request, cast_id):
data = get_json(request.body)
cast = get_object(models.Cast, cast_id)
if not cast.allowed_edit(request.user):
raise exceptions.APIForbidden
if 'content_type' in data:
content_type = data['content_type']
del data['content_type']
else:
raise exceptions.APIBadRequest('missing "content_type"')
data['language'] = translation.get_language()
data['author'] = request.user.id
form_model = None
if content_type == 'videomedia':
form_model = forms.VideoMediaForm
elif content_type == 'imagemedia':
form_model = forms.ImageMediaForm
elif content_type == 'linkedmedia':
form_model = forms.LinkedMediaForm
media = form_validate(form_model, data)
cast.media_set.add(media)
models.UserActivity.objects.create_activity(request.user, media, 'created')
# this is needed as for some odd reason, it doesn't return an object with author, modified, etc.
# TODO investigate why this is needed, perhaps it can be fixed by using media.content
media = get_object(models.Media, media.id)
return APIResponseCreated(content=api_serialize(media, request), location=media.get_api_uri())
def get_me(request):
return APIResponseOK(content=api_serialize(request.user))
def _api_serialize(self, request):
d = Authorable._api_serialize(self, request)
d['author'] = api_serialize(self.author)
d['content'] = self.body
return d
def _api_serialize(self, request):
d = Authorable._api_serialize(self, request)
d["author"] = api_serialize(self.author)
d["content"] = self.body
return d
def _api_serialize(self, request):
d = Authorable._api_serialize(self, request)
d['author'] = api_serialize(self.author)
d['content'] = self.body
return d
def post(request):
postcard = postcard_from_post(request)
postcard.save()
# models.UserActivity.objects.create_activity(request.user, cast, 'created')
return APIResponseCreated(content=api_serialize(postcard, request), location=postcard.get_api_uri())
def get(request, cast_id=None, coll_id=None, format='.json'):
# single cast
if cast_id:
if coll_id: check_collection(cast_id, coll_id)
cast = get_object(models.Cast, id=cast_id)
if not cast.allowed_access(request.user):
raise exceptions.APIForbidden
if format == '.json':
cast_dict = api_serialize(cast, request)
return APIResponseOK(content=cast_dict, total=1)
if format == '.html':
is_flagged = cast.is_flagged_by(request.user)
is_favorited = cast.is_favorited_by(request.user)
allowed_edit = cast.allowed_edit(request.user)
content = render_to_string('ajax/cast_frontpage.django.html', locals(), context_instance = RequestContext(request))
resp = HttpResponse(content=content)
return resp
else:
raise exceptions.APIBadRequest('Invalid response format')
# multiple casts
else:
base_query = models.Cast.get_privacy_q(request)
if coll_id:
get_object(models.Collection, id=coll_id)
base_query = base_query & Q(collection=coll_id)
q = qstranslate.QueryTranslator(models.Cast, ruleset, base_query)
query = request.GET.copy()
# Need to do some magic to order by popularity, so remove from
# the query that will be sent to qstranslate
popularity_order = False
if 'orderby' in query and query['orderby'] == 'popularity':
popularity_order = True
del query['orderby']
objs = total = pg = None
try:
objs = q.filter(query)
# popularity magic!
if popularity_order:
objs = objs.annotate(popularity=Count('favorited_by')).order_by('-popularity')
objs, total, pg = paginate(objs, request.GET)
except qstranslate.InvalidParameterException, e:
raise exceptions.APIBadRequest(e.message)
cast_arr = []
for c in objs:
cast_arr.append(api_serialize(c, request))
return APIResponseOK(content=cast_arr, total=total, pg=pg)
def update_facebook_likes(request):
p_id = int(request.POST.get('id', None))
postcard = get_object(models.Postcard, id=p_id)
postcard.update_facebook_likes()
return APIResponseOK(content=api_serialize(postcard))
def cast_from_post(request, cast = None):
data = {}
# this allows PUT operations to only send the data they
# are interested in updating
if cast:
data = api_serialize(cast)
data.update(get_json(request.body))
if not cast:
data['author'] = request.user.id
else:
data['author'] = cast.author.id
# Tags won't validate correctly, so store them to set later
tags = None
if 'tags' in data:
tags = data['tags']
del data['tags']
# Location needs to be set manually
location = None
if 'location' in data:
location = data['location']
# check to make sure its within
boundary = models.Boundary.objects.get_default_boundary()
if boundary and (not Point(location[0], location[1]).within(boundary.bounds)):
raise exceptions.APIBadRequest('{"location":"outside default boundary"}')
del data['location']
# Modified and created cannot be set
if 'modified' in data: del data['modified']
if 'created' in data: del data['created']
if 'favorite' in data:
if data['favorite'] == True:
cast.favorite(request.user);
else:
cast.unfavorite(request.user);
del data['favorite']
# Maps privacy names to values
if 'privacy' in data:
data['privacy'] = models.Cast.get_privacy_value(data['privacy'])
cast = form_validate(forms.CastAPIForm, data, instance = cast)
if not tags == None:
# Clear all tags
if tags == "":
cast.tags.all().delete()
cast.set_tags(tags)
if location:
cast.set_location(location[0], location[1])
cast.save()
return cast
def get(request, cast_id=None, coll_id=None, format='.json'):
# single cast
if cast_id:
if coll_id: check_collection(cast_id, coll_id)
cast = get_object(models.Cast, id=cast_id)
if not cast.allowed_access(request.user):
raise exceptions.APIForbidden
if format == '.json':
cast_dict = api_serialize(cast, request)
return APIResponseOK(content=cast_dict, total=1)
if format == '.html':
is_flagged = cast.is_flagged_by(request.user)
is_favorited = cast.is_favorited_by(request.user)
allowed_edit = cast.allowed_edit(request.user)
content = render_to_string('ajax/cast_frontpage.django.html', locals(), context_instance = RequestContext(request))
resp = HttpResponse(content=content)
return resp
else:
raise exceptions.APIBadRequest('Invalid response format')
# multiple casts
else:
base_query = models.Cast.get_privacy_q(request)
if coll_id:
get_object(models.Collection, id=coll_id)
base_query = base_query & Q(collection=coll_id)
q = qstranslate.QueryTranslator(models.Cast, ruleset, base_query)
query = request.GET.copy()
# Need to do some magic to order by popularity, so remove from
# the query that will be sent to qstranslate
popularity_order = False
if 'orderby' in query and query['orderby'] == 'popularity':
popularity_order = True
del query['orderby']
objs = total = pg = None
try:
objs = q.filter(query)
# popularity magic!
if popularity_order:
objs = objs.annotate(popularity=Count('favorited_by')).order_by('-popularity')
objs, total, pg = paginate(objs, request.GET)
except qstranslate.InvalidParameterException, e:
raise exceptions.APIBadRequest(e.message)
cast_arr = []
for c in objs:
cast_arr.append(api_serialize(c, request))
return APIResponseOK(content=cast_arr, total=total, pg=pg)
