def post(self, request, *args, **kwargs):
json = YpSerialiser()
form = forms.ReviewsForm(request.POST)
if form.is_valid():
review = form.save(commit=False)
review.author = PointsModels.Person.objects.get(username=request.user)
review.save()
point_id = form.cleaned_data.get("point", 0)
if point_id:
point = get_object_or_404(PointsModels.Points, pk=point_id)
point.reviews.add(review)
point.save()
return HttpResponse(
json.serialize(
[review],
excludes=(),
extras=(),
relations={"author": {"fields": ("first_name", "last_name", "avatar")}},
),
mimetype="application/json",
)
else:
e = form.errors
errors = []
for er in e:
errors.append(er + ":" + e[er][0])
return HttpResponse(simplejson.dumps({"id": 0, "status": 1, "txt": ", ".join(errors)}))
def post(self, request, *args, **kwargs):
object = self.get_object()
json = YpSerialiser()
form = PhotosForm(request.POST, request.FILES)
if form.is_valid():
photo = form.save(commit=False)
photo.author = request.user.get_profile()
photo.save()
if object:
object.imgs.add(photo)
json = YpSerialiser()
return HttpResponse(json.serialize(
[photo],
excludes=("img"),
extras=('thumbnail104x104', 'img_url', 'thumbnail560',
'thumbnail207', 'thumbnail625x370',
'thumbnail207_height'),
relations={
'author': {
'fields': ('first_name', 'last_name', 'avatar')
}
}),
mimetype="application/json")
return HttpResponse(simplejson.dumps({
'id': 0,
'status': form._errors
}),
mimetype="application/json")
def post(self, request, *args, **kwargs):
json = YpSerialiser()
form = forms.ReviewsForm(request.POST)
if form.is_valid():
review = form.save(commit=False)
review.author = PointsModels.Person.objects.get(username=request.user)
review.save()
point_id = form.cleaned_data.get("point", 0)
if point_id:
point = get_object_or_404(PointsModels.Points, pk=point_id)
point.reviews.add(review)
point.save()
return HttpResponse(json.serialize([review], excludes=(),
extras=(),
relations={
'author': {
'fields': ('first_name', 'last_name', 'avatar')
}
}),
mimetype="application/json")
else:
e = form.errors
errors = []
for er in e:
errors.append(er +':'+e[er][0])
return HttpResponse(simplejson.dumps({'id': 0, "status": 1, "txt": ", ".join(errors)}))
def get(self, request, *args, **kwargs):
params = request.GET
COUNT_ELEMENTS = 10
page = kwargs.get("page", 1) or 1
limit = COUNT_ELEMENTS*int(page)
offset = (int(page)-1)*COUNT_ELEMENTS
person = MainModels.Person.objects.get(username=request.user)
content_type = ContentType.objects.get_for_model(MainModels.Points).id
points = MainModels.Points.objects.extra(
select = {
"new_feedbacks": "select coalesce(count(*), 0) from reports_reports where reports_reports.content_type_id=%(content_type)s and reports_reports.object_id=main_points.id and reports_reports.updated>'%(date)s'" % ({"content_type": content_type, "date": person.last_login.strftime("%Y-%m-%d %H:%M:%S")}),
"updated_events": "select coalesce(count(*), 0) from main_events where main_events.id=main_points.id and main_events.updated>'%(date)s'" % ({"date": person.last_login.strftime("%Y-%m-%d %H:%M:%S")}),
"new_photos": "select coalesce(count(*), 0) from main_photos join main_points_imgs on main_photos.id=main_points_imgs.photos_id and main_photos.updated>'%(date)s' where main_points_imgs.points_id=main_points.id " % ({"date": person.last_login.strftime("%Y-%m-%d %H:%M:%S")}),
#"all_params": "select new_feedbacks + new_events as all_params",
},
).order_by("-new_photos", "-new_feedbacks", "-updated_events")
points = points[offset:limit]
YpJson = YpSerialiser()
return HttpResponse(YpJson.serialize(points, extras=["new_feedbacks", "updated_events", "new_photos"], relations={'tags': {'fields': ('name', 'id', 'level')}, 'author':{'fields':('first_name','last_name','avatar')},'imgs':{'extras':('thumbnail207','thumbnail325',)},'type':{}}), mimetype="application/json")
def get(self, request, *args, **kwargs):
point = get_object_or_404(CollectionsModels.Collections, pk=kwargs.get("id"))
YpJson = YpSerialiser()
relations = {
'likeusers': {'fields': ('first_name', 'last_name', 'avatar')},
'author': {'fields': ('first_name', 'last_name', 'avatar')},
'points': {
'relations': {
'tags': {'fields': ('name', 'id', 'level')},
'author': {'fields': ('first_name', 'last_name', 'avatar')},
'imgs': {
'extras': ('thumbnail104x104', 'thumbnail207', 'thumbnail560'),
'relations': {
'author': {'fields': ('last_name', 'first_name', 'avatar')},
'likeusers': {'fields': ('last_name', 'first_name', 'avatar')},
'comments': {
'relations': {
'author': {'fields': ('first_name', 'last_name', 'avatar')}
}
}
}
}
}
}
}
t0 = time.time()
point = YpJson.serialize([point], excludes=('points_by_user',), relations=relations)
self.log.info('Serialize collection detail complete (%.2f sec.) point id: %s' % (time.time()-t0, kwargs.get('id')))
return HttpResponse(point, mimetype="application/json")
def post(self, request, *args, **kwargs):
json = YpSerialiser()
form = CommentForm(request.POST)
if form.is_valid():
comment = form.save(commit=False)
comment.author = request.user.get_profile()
comment.save()
photo_id = kwargs.get("id")
if photo_id:
photo = get_object_or_404(PhotosModels.Photos, pk=photo_id)
photo.comments.add(comment)
photo.save()
else:
return HttpResponse(
simplejson.dumps({"id": 0, "status": 2, "txt": "комментарий не добавлен к изображению"}),
mimetype="application/json",
)
return HttpResponse(
json.serialize(
[comment],
excludes=("object_id", "content_type"),
relations={"author": {"fields": ("first_name", "last_name", "avatar")}},
),
mimetype="application/json",
)
return HttpResponse(simplejson.dumps({"id": 0, "status": form._errors}), mimetype="application/json")
def get(self, request, *args, **kwargs):
params = request.GET
COUNT_ELEMENTS = 5
errors = []
limit = COUNT_ELEMENTS
offset = 0
form = forms.SearchForm(params)
if form.is_valid():
pointsreq = MainModels.Events.objects;
name = form.cleaned_data.get("s")
if name:
pointsreq = pointsreq.filter(name__icontains=name)
content = form.cleaned_data.get("content")
if content == 'new':
pointsreq = pointsreq.order_by('-created')
elif content == "popular":
pointsreq = pointsreq.annotate(uslikes=Count('likeusers__id')).order_by('-uslikes', '-created')
else:
pointsreq = pointsreq.order_by("name")
events = pointsreq[offset:limit]
YpJson = YpSerialiser()
return HttpResponse(YpJson.serialize(events, fields=("name")), mimetype="application/json")
else:
e = form.errors
for er in e:
errors.append(er +':'+e[er][0])
return JsonHTTPResponse({"status": 0, "txt": ", ".join(errors)});
def get(self, request, *args, **kwargs):
pk = kwargs.get("id")
event = get_object_or_404(MainModels.Events, pk=pk)
YpJson = YpSerialiser()
return HttpResponse(YpJson.serialize(
[event],
relations={
'point': {},
'feedbacks': {
'fields': ('type', 'feedback')
},
'tags': {
'fields': ('name', 'id', 'level')
},
'author': {
'fields': ('first_name', 'last_name', 'avatar')
},
'imgs': {
'extras': (
'thumbnail207',
'thumbnail325',
)
}
}),
mimetype="application/json")
def get(self, request, id, *args, **kwargs):
user_id = id
person = MainModels.Person.objects.filter(id=user_id).extra(
select={"liked_points": "select count(*) from main_points_likeusers where person_id=main_person.user_id",
"liked_events": "select count(*) from main_events_likeusers where person_id=main_person.user_id",
"liked_photos": "select count(*) from photos_photos_likeusers where user_id=main_person.user_id",
"liked_routes": "select count(*) from main_routes_likeusers where user_id=main_person.user_id",
"liked_trips": "select count(*) from trips_trips_likeusers where person_id=main_person.user_id",
"added_points": "select count(*) from main_points where author_id=main_person.user_id",
"added_events": "select count(*) from main_events where author_id=main_person.user_id",
"added_routes": "select count(*) from main_routes where author_id=main_person.user_id",
"added_trips": "select count(*) from trips_trips where author_id=main_person.user_id",
"added_photos": "select count(*) from photos_photos where author_id=main_person.user_id",
"want_visit_points": "select count(*) from main_points_visitusers where user_id=main_person.user_id",
"want_visit_events": "select count(*) from main_events_visitusers where user_id=main_person.user_id",
"person_followers": "select count(*) from main_person_followers where user_id=main_person.user_id",
}
)
YpJson = YpSerialiser()
return HttpResponse(YpJson.serialize(person,
extras=["liked_points", "liked_events", "liked_photod", "liked_routes", "liked_trips",
"added_points", "added_events", "added_routes", "added_trips",
"want_visit_points", "want_visit_events",
"person_followers", "icon", "icon_small"
],
fields=("username", "first_name", "last_name", "email", "dealer",
"avatar", "phone", "city", "website", "about")),
mimetype="application/json")
def get(self, request, *args, **kwargs):
trip = get_object_or_404(TripsModels.Trips, pk=kwargs.get("id"))
YpJson = YpSerialiser()
t0 = time.time()
trip = YpJson.serialize([trip], relations=TripOption.relations.getTripRelation())
self.log.info('Serialize trip detail complete (%.2f sec.) trip id: %s' % (time.time()-t0, kwargs.get('id')))
return HttpResponse(trip, mimetype="application/json")
def photoList(self, photos):
json = YpSerialiser()
return HttpResponse(json.serialize(
photos,
excludes=("img", ),
extras=["isliked", "likes_count", 'thumbnail104x104', 'img_url'],
relations={
'author': {
'fields': ('first_name', 'last_name', 'avatar')
},
'likeusers': {
'fields': ('first_name', 'last_name', 'avatar'),
'limit': LIMITS.IMAGES_LIST.LIKEUSERS_COUNT
},
'comments': {
'fields': ['txt', 'created', 'author'],
'relations': {
'author': {
'fields':
['id', 'first_name', 'last_name', 'avatar']
},
},
'limit': LIMITS.IMAGES_LIST.COMMENTS_COUNT
},
}),
mimetype="application/json")
def reviewList(self, reviews):
json = YpSerialiser()
return HttpResponse(
json.serialize(
reviews, excludes=(), relations={"author": {"fields": ("first_name", "last_name", "avatar")}}
),
mimetype="application/json",
)
def reviewList(self, reviews):
json = YpSerialiser()
return HttpResponse(json.serialize(reviews, excludes=(),
relations={'author': {'fields': (
'first_name',
'last_name',
'avatar'
)},
}), mimetype="application/json")
def get(self, request, *args, **kwargs):
params = request.GET
COUNT_ELEMENTS = 10
page = kwargs.get("page", 1) or 1
limit = COUNT_ELEMENTS * int(page)
offset = (int(page) - 1) * COUNT_ELEMENTS
person = MainModels.Person.objects.get(username=request.user)
content_type = ContentType.objects.get_for_model(MainModels.Points).id
points = MainModels.Points.objects.extra(
select={
"new_feedbacks":
"select coalesce(count(*), 0) from reports_reports where reports_reports.content_type_id=%(content_type)s and reports_reports.object_id=main_points.id and reports_reports.updated>'%(date)s'"
% ({
"content_type": content_type,
"date": person.last_login.strftime("%Y-%m-%d %H:%M:%S")
}),
"updated_events":
"select coalesce(count(*), 0) from main_events where main_events.id=main_points.id and main_events.updated>'%(date)s'"
% ({
"date": person.last_login.strftime("%Y-%m-%d %H:%M:%S")
}),
"new_photos":
"select coalesce(count(*), 0) from main_photos join main_points_imgs on main_photos.id=main_points_imgs.photos_id and main_photos.updated>'%(date)s' where main_points_imgs.points_id=main_points.id "
% ({
"date": person.last_login.strftime("%Y-%m-%d %H:%M:%S")
}),
#"all_params": "select new_feedbacks + new_events as all_params",
}, ).order_by("-new_photos", "-new_feedbacks", "-updated_events")
points = points[offset:limit]
YpJson = YpSerialiser()
return HttpResponse(YpJson.serialize(
points,
extras=["new_feedbacks", "updated_events", "new_photos"],
relations={
'tags': {
'fields': ('name', 'id', 'level')
},
'author': {
'fields': ('first_name', 'last_name', 'avatar')
},
'imgs': {
'extras': (
'thumbnail207',
'thumbnail325',
)
},
'type': {}
}),
mimetype="application/json")
def get(self, request, *args, **kwargs):
params = request.GET
COUNT_ELEMENTS = RESPONSE_LIMITS[kwargs["type"]]
errors = []
limit = COUNT_ELEMENTS
offset = 0
form = forms.SearchForm(params)
if form.is_valid():
pointsreq = TagsModels.Tags.objects
name = form.cleaned_data.get("s")
if name:
name_spl = name.split(' ')
pointsreq = []
blocklist = []
for phrase in name_spl:
if phrase.encode('utf-8') != '':
pointsrq = TagsModels.Tags.search.query(phrase)
for item2 in pointsreq:
blocklist.append(item2.id)
for item1 in pointsrq:
if item1.id in blocklist:
item2 = item1
else:
pointsreq.append(item1)
content = form.cleaned_data.get("content")
if content == 'new':
pointsreq = pointsreq.order_by('-id')
elif content == "popular":
pointsreq = pointsreq.extra(
select={
'popular1':
'select count(*) as p from main_points_tags where main_points_tags.tags_id = tags_tags.id',
'popular2':
'select count(*)+popular1 as p from main_events_tags where main_events_tags.tags_id = tags_tags.id'
}).order_by('-popular2', '-id')
else:
pointsreq = pointsreq
tags = pointsreq[offset:limit]
YpJson = YpSerialiser()
return HttpResponse(YpJson.serialize(
tags,
fields=("name", "level", "icons", "style", "parent",
"onmainmap")),
mimetype="application/json")
else:
e = form.errors
for er in e:
errors.append(er + ':' + e[er][0])
return JsonHTTPResponse({"status": 0, "txt": ", ".join(errors)})
def get(self, request, *args, **kwargs):
params = request.GET
COUNT_ELEMENTS = 5
errors = []
limit = COUNT_ELEMENTS
offset = 0
form = forms.SearchForm(params)
if form.is_valid():
#pointsreq = MainModels.Person.objects;
name = form.cleaned_data.get("s")
users_list = []
morph = get_morph('/home/tenoclock/yasenput/dicts')
if name:
#pointsreq = MainModels.Person.search.query(params.get("s"))
#search = SphinxSearch()
search = SphinxQuerySet(index="auth_user")
name_morph = morph.normalize(name.upper())
file1 = open('file1.txt','w')
file1.write(str(list(name_morph)))
file1.close()
phrase_list = name.split(' ')
for phrase in phrase_list:
if phrase != '':
name_morph = morph.normalize(phrase.upper())
for name_m in name_morph:
search_query = search.query(name_m)
for splited_item in search_query:
if not MainModels.Person.objects.get(id = splited_item['id']) in users_list:
users_list.append(MainModels.Person.objects.get(id = splited_item['id']))
content = form.cleaned_data.get("content")
if content == 'new':
pointsreq = pointsreq.order_by('-id')
elif content == "popular":
pointsreq = pointsreq.annotate(usfiliwers=Count('followers__id')).order_by('-usfiliwers', '-id')
else:
pointsreq = users_list
points = users_list[offset:limit]
YpJson = YpSerialiser()
return HttpResponse(YpJson.serialize(points, fields=("username", "first_name", "last_name")),
mimetype="application/json")
else:
e = form.errors
for er in e:
errors.append(er +':'+e[er][0])
return JsonHTTPResponse({"status": 0, "txt": ", ".join(errors)});
def post(self, request, *args, **kwargs):
params = request.POST.copy()
data = params.get('model', "{}")
data = json.loads(data)
if request.POST.get('_method') == 'DELETE':
trip = Trips.objects.get(pk=kwargs.get('id'))
trip.delete()
return JsonHTTPResponse({
'deleted': True
})
## update point with PUT emulate
if request.META.get('HTTP_X_HTTP_METHOD_OVERRIDE') == 'PUT':
form = forms.AddTripForm(data,
instance=Trips.objects.get(pk=kwargs.get('id')))
else:
form = forms.AddTripForm(data)
if form.is_valid():
trip = form.save(commit=False)
person = MainModels.Person.objects.get(username=request.user)
trip.author = person
trip.save()
trip.admins.add(person)
#Members
members = data.get('members')
if members is not None:
for member_id in members:
member = MainModels.Points.objects.get(id=member_id)
trip.members.add(member)
#Blocks
blocks = data.get('blocks')
block_ids = [block.get('id') for block in blocks]
b = trip.blocks.exclude(id__in=block_ids)
trip.blocks.remove(*b)
if blocks is not None:
for block in blocks:
block['points'] = [point['id'] for point in block['points']]
block['imgs'] = [img['id'] for img in block['imgs']]
if block.get('id'):
block_obj = Blocks.objects.get(id=block.get('id'))
block_form = forms.AddBlockForm(block, instance=block_obj)
else:
block_form = forms.AddBlockForm(block)
if block_form.is_valid():
block_obj = block_form.save()
trip.blocks.add(block_obj)
YpJson = YpSerialiser()
trip = YpJson.serialize([trip], relations=TripOption.relations.getTripRelation())
return HttpResponse(trip, mimetype="application/json")
else:
return JsonHTTPResponse({"id": 0, "status": 1, "txt": "Error"})
def post(self, request, *args, **kwargs):
queryset = self.get_queryset(request)
page_size = self.get_paginate_by(queryset)
if page_size:
paginator, page, reviews, is_paginated = self.paginate_queryset(queryset, page_size)
else:
reviews = []
json = YpSerialiser()
return HttpResponse(
json.serialize(reviews, relations={"author": {"fields": ("first_name", "last_name", "avatar")}}),
mimetype="application/json",
)
def get(self, request, *args, **kwargs):
params = request.GET
COUNT_ELEMENTS = RESPONSE_LIMITS[kwargs["type"]]
errors = []
limit = COUNT_ELEMENTS
offset = 0
form = forms.SearchForm(params)
if form.is_valid():
pointsreq = TagsModels.Tags.objects
name = form.cleaned_data.get("s")
if name:
name_spl = name.split(' ')
pointsreq = []
blocklist = []
for phrase in name_spl:
if phrase.encode('utf-8') != '':
pointsrq = TagsModels.Tags.search.query(phrase)
for item2 in pointsreq:
blocklist.append(item2.id)
for item1 in pointsrq:
if item1.id in blocklist:
item2 = item1
else:
pointsreq.append(item1)
content = form.cleaned_data.get("content")
if content == 'new':
pointsreq = pointsreq.order_by('-id')
elif content == "popular":
pointsreq = pointsreq.extra(
select={
'popular1': 'select count(*) as p from main_points_tags where main_points_tags.tags_id = tags_tags.id',
'popular2': 'select count(*)+popular1 as p from main_events_tags where main_events_tags.tags_id = tags_tags.id'
}
).order_by('-popular2', '-id')
else:
pointsreq = pointsreq
tags = pointsreq[offset:limit]
YpJson = YpSerialiser()
return HttpResponse(YpJson.serialize(tags, fields=("name","level", "icons", "style", "parent", "onmainmap")), mimetype="application/json")
else:
e = form.errors
for er in e:
errors.append(er +':'+e[er][0])
return JsonHTTPResponse({"status": 0, "txt": ", ".join(errors)})
def get(self, request):
queryset = self.get_queryset()
page_size = self.get_paginate_by(queryset)
if page_size:
paginator, page, reports, is_paginated = self.paginate_queryset(queryset, page_size)
else:
reports = []
json = YpSerialiser()
return HttpResponse(json.serialize(reports, excludes=("object_id", "content_type"),
relations={'author': {'fields': (
'first_name',
'last_name',
'avatar'
)}}), mimetype="application/json")
def get(self, request):
queryset = self.get_queryset()
page_size = self.get_paginate_by(queryset)
if page_size:
paginator, page, comments, is_paginated = self.paginate_queryset(queryset, page_size)
else:
comments = []
json = YpSerialiser()
return HttpResponse(json.serialize(comments, excludes=("object_id", "content_type"),
relations={'author': {'fields': (
'first_name',
'last_name',
'avatar'
)}}), mimetype="application/json")
def post(self, request):
json = YpSerialiser()
form = ReportForm(request.POST)
if form.is_valid():
comment = form.save(commit=False)
comment.author = request.user.get_profile()
comment.save()
return HttpResponse(json.serialize([comment], excludes=("object_id", "content_type"),
relations={
'author': {
'fields': ('first_name', 'last_name', 'avatar')
}
}),
mimetype="application/json")
return HttpResponse(simplejson.dumps({'id': 0, 'status': form._errors}), mimetype="application/json")
def post(self, request, *args, **kwargs):
queryset = self.get_queryset(request)
page_size = self.get_paginate_by(queryset)
if page_size:
paginator, page, reviews, is_paginated = self.paginate_queryset(queryset, page_size)
else:
reviews = []
json = YpSerialiser()
return HttpResponse(json.serialize(reviews, relations={
'author': {
'fields': ('first_name', 'last_name', 'avatar')
}
}),
mimetype="application/json")
def get(self, request):
queryset = self.get_queryset()
page_size = self.get_paginate_by(queryset)
if page_size:
paginator, page, comments, is_paginated = self.paginate_queryset(queryset, page_size)
else:
comments = []
json = YpSerialiser()
return HttpResponse(
json.serialize(
comments,
excludes=("object_id", "content_type"),
relations={"author": {"fields": ("first_name", "last_name", "avatar")}},
),
mimetype="application/json",
)
def post(self, request, *args, **kwargs):
id = kwargs.get('id', None)
if not request.user.is_authenticated():
return JsonHTTPResponse({"id":id,
"status": 1,
"txt":"Вы не авторизованы"})
trip = get_object_or_404(Trips, id=id)
if request.user.person in trip.likeusers.all():
trip.likeusers.remove(request.user.person)
trip.ypi -= 1
else:
trip.likeusers.add(request.user.person)
trip.ypi += 1
trip.save()
YpJson = YpSerialiser()
trip = YpJson.serialize([trip], extras=TripOption.getExtras(),
relations=TripOption.relations.getTripRelation())
return HttpResponse(trip, mimetype="application/json")
def post(self, request, *args, **kwargs):
object = self.get_object()
json = YpSerialiser()
form = PhotosForm(request.POST, request.FILES)
if form.is_valid():
photo = form.save(commit=False)
photo.author = request.user.get_profile()
photo.save()
if object:
object.imgs.add(photo)
json = YpSerialiser()
return HttpResponse(json.serialize([photo], excludes=("img"),
extras=('thumbnail104x104', 'img_url', 'thumbnail560', 'thumbnail207', 'thumbnail625x370', 'thumbnail207_height'),
relations={
'author': {
'fields': ('first_name', 'last_name', 'avatar')
}
}),
mimetype="application/json")
return HttpResponse(simplejson.dumps({'id': 0, 'status': form._errors}), mimetype="application/json")
def photoList(self, photos):
json = YpSerialiser()
return HttpResponse(json.serialize(photos, excludes= ("img",),
extras=["isliked", "likes_count", 'thumbnail104x104','img_url'],
relations={'author': {'fields': (
'first_name',
'last_name',
'avatar'
)},
'likeusers': {'fields': (
'first_name',
'last_name',
'avatar'
),
'limit': LIMITS.IMAGES_LIST.LIKEUSERS_COUNT},
'comments': {'fields': ['txt', 'created', 'author'],
'relations': {'author': {'fields': ['id', 'first_name', 'last_name', 'avatar']},},
'limit': LIMITS.IMAGES_LIST.COMMENTS_COUNT
},
}), mimetype="application/json")
def post(self, request):
json = YpSerialiser()
form = ReportForm(request.POST)
if form.is_valid():
comment = form.save(commit=False)
comment.author = request.user.get_profile()
comment.save()
return HttpResponse(json.serialize(
[comment],
excludes=("object_id", "content_type"),
relations={
'author': {
'fields': ('first_name', 'last_name', 'avatar')
}
}),
mimetype="application/json")
return HttpResponse(simplejson.dumps({
'id': 0,
'status': form._errors
}),
mimetype="application/json")
def get(self, request, *args, **kwargs):
params = request.GET
COUNT_ELEMENTS = 5
errors = []
limit = COUNT_ELEMENTS
offset = 0
form = forms.SearchForm(params)
if form.is_valid():
pointsreq = MainModels.Events.objects
name = form.cleaned_data.get("s")
if name:
pointsreq = pointsreq.filter(name__icontains=name)
content = form.cleaned_data.get("content")
if content == 'new':
pointsreq = pointsreq.order_by('-created')
elif content == "popular":
pointsreq = pointsreq.annotate(
uslikes=Count('likeusers__id')).order_by(
'-uslikes', '-created')
else:
pointsreq = pointsreq.order_by("name")
events = pointsreq[offset:limit]
YpJson = YpSerialiser()
return HttpResponse(YpJson.serialize(events, fields=("name")),
mimetype="application/json")
else:
e = form.errors
for er in e:
errors.append(er + ':' + e[er][0])
return JsonHTTPResponse({
"status": 0,
"txt": ", ".join(errors)
})
def post(self, request, *args, **kwargs):
json = YpSerialiser()
form = CommentForm(request.POST)
if form.is_valid():
comment = form.save(commit=False)
comment.author = request.user.get_profile()
comment.save()
photo_id = kwargs.get('id')
if photo_id:
photo = get_object_or_404(PhotosModels.Photos, pk=photo_id)
photo.comments.add(comment)
photo.save()
else:
return HttpResponse(simplejson.dumps({
'id':
0,
'status':
2,
'txt':
'комментарий не добавлен к изображению'
}),
mimetype="application/json")
return HttpResponse(json.serialize(
[comment],
excludes=("object_id", "content_type"),
relations={
'author': {
'fields': ('first_name', 'last_name', 'avatar')
}
}),
mimetype="application/json")
return HttpResponse(simplejson.dumps({
'id': 0,
'status': form._errors
}),
mimetype="application/json")
def get(self, request, *args, **kwargs):
params = request.GET
COUNT_ELEMENTS = LIMITS.POINTS_LIST.POINTS_SEARCH_COUNT
errors = []
limit = COUNT_ELEMENTS
offset = 0
form = forms.SearchForm(params)
#search_res_points = []
#search_res_sets = []
if form.is_valid():
#pointsreq = MainModels.Points.objects
#collectionsreq = CollectionsModels.Collections.objects
name = form.cleaned_data.get("s")
if name:
search_res_points = MainModels.Points.search.query(
params.get("s"))
search_res_sets = CollectionsModels.Collections.search.query(
name)
YpJson = YpSerialiser()
all_items = QuerySetJoin(
search_res_points.extra(select={'type_of_item': 1}),
search_res_sets.extra(select={'type_of_item': 2}))
items = json.loads(
self.getSerializeCollections(all_items.order_by('-ypi')))
#return HttpResponse(json.dumps({"points": allpoints, "collections": allcollections}), mimetype="application/json")
return HttpResponse(
YpJson.serialize(all_items, fields=('id', 'name')))
else:
e = form.errors
for er in e:
errors.append(er + ':' + e[er][0])
return JsonHTTPResponse({"status": 0, "txt": ", ".join(errors)})
def post(self, request, *args, **kwargs):
params = request.POST
COUNT_ELEMENTS = LIMITS.COLLECTIONS_LIST.COLLECTIONS_LIST_COUNT
errors = []
page = kwargs.get("page", 1) or 1
limit = COUNT_ELEMENTS*int(page)
offset = (int(page)-1)*COUNT_ELEMENTS
form = forms.FiltersForm(params)
if form.is_valid():
tripsreq = TripsModels.Trips.objects
user = form.cleaned_data.get("user")
if user:
tripsreq = tripsreq.filter(author__id__icontains=user)
coord_left = params.get("coord_left")
if coord_left:
try:
coord_left = json.loads(coord_left)
except:
errors.append("некорректно задана левая точка на карте для фильтра")
else:
ln = coord_left.get("ln")
lt = coord_left.get("lt")
if str(ln).replace(".", "", 1).isdigit() and str(lt).replace(".", "", 1).isdigit() and ln >= 0 and lt >= 0:
tripsreq = tripsreq.filter(blocks__points__longitude__gte=ln, blocks__points__latitude__gte=lt)
else:
errors.append("некорректно задана левая точка на карте для фильтра")
coord_right = params.get("coord_right")
if coord_right:
try:
coord_right = json.loads(coord_right)
except:
errors.append("некорректно задана правая точка на карте для фильтра")
else:
ln = coord_right.get("ln")
lt = coord_right.get("lt")
if str(ln).replace(".", "", 1).isdigit() and str(lt).replace(".", "", 1).isdigit() and ln >= 0 and lt >= 0:
tripsreq = tripsreq.filter(blocks__points__longitude__lte=ln, blocks__points__latitude__lte=lt)
name = form.cleaned_data.get("name")
if name:
tripsreq = tripsreq.filter(name__icontains=name)
tags = params.getlist("tags[]")
if tags and len(tags) > 0:
tripsreq = tripsreq.filter(blocks__points__tags__in=tags)
#.extra(where=['main_points.id in (select points_id from main_points_tags where tags_id in (%s))' % (",".join(map(lambda x: "'%s'" % x, tags)))])
content = form.cleaned_data.get("content") or 'new'
if content == 'new':
tripsreq = tripsreq.order_by('-created')
elif content == "popular":
tripsreq = tripsreq.annotate(uslikes=Count('likeusers__id')).order_by('-uslikes')
if request.user.is_authenticated():
user = MainModels.User.objects.get(username=request.user)
tripsreq = tripsreq.extra(
select={
'isliked': 'SELECT case when COUNT(*) > 0 then 1 else 0 end FROM trips_trips_likeusers WHERE trips_trips_likeusers.trips_id = trips_trips.id and trips_trips_likeusers.user_id = '+str(user.id),
'likes_count': 'SELECT count(*) from trips_trips_likeusers where trips_trips_likeusers.trips_id=trips_trips.id',
}
)
else:
tripsreq = tripsreq.extra(
select={
'isliked': 'SELECT 0 ',
'likes_count': 'SELECT count(*) from trips_trips_likeusers where trips_trips_likeusers.trips_id=trips_trips.id',
}
)
trips = tripsreq[offset:limit].all()
YpJson = YpSerialiser()
return HttpResponse(YpJson.serialize(trips,
extras=["isliked", "likes_count"],
fields=('id', 'name', 'members', 'admins', 'likeusers', 'updated', 'blocks', 'author'),
relations={'blocks': {'fields': ('id', 'name', 'txt', 'likeusers', 'points', 'events', 'imgs'),
'relations': {
'author': {'fields': ('first_name', 'last_name', 'avatar')},
'imgs': {'extras': ('thumbnail207', 'thumbnail560', 'thumbnail104x104', 'thumbnail625x370'),
'limit': LIMITS.POINTS_LIST.IMAGES_COUNT},
},
'points': {'fields': ('name', 'address', 'longitude', 'latitude')},
'events': {'fields': ('name', 'address', 'longitude', 'latitude')},
'limit': LIMITS.COLLECTIONS_LIST.POINTS_COUNT
},
'author': {'fields': ('id', 'first_name', 'last_name', 'avatar')},
'likeusers': {'fields': ('id', 'first_name', 'last_name', 'avatar'),
'limit': LIMITS.COLLECTIONS_LIST.LIKEUSERS_COUNT}
}
),
mimetype="application/json")
else:
e = form.errors
for er in e:
errors.append(er + ':' + e[er][0])
return JsonHTTPResponse({"status": 0, "txt": ", ".join(errors)})
def getSerializePoints(self, points):
YpJson = YpSerialiser()
return YpJson.serialize(
points,
fields=[
'main_img', 'id', 'name', 'description', 'address', 'author',
'imgs', 'longitude', 'latitude', 'tags', 'description',
'reviews', 'wifi', 'wc', 'invalid', 'parking', 'likeusers',
'created', 'updated', 'likes_count', 'isliked'
],
extras=[
'popular', 'type_of_item', 'name', 'address', 'longitude',
'latitude', 'wifi', 'wc', 'invalid', 'parking',
'reviewusersplus', 'reviewusersminus', 'id_point', 'isliked',
'collections_count', 'likes_count', 'beens_count'
],
relations={
'tags': {
'fields': ['name', 'id', 'level', 'icons'],
'limit': LIMITS.POINTS_LIST.TAGS_COUNT
},
'likeusers': {
'fields': ['id', 'first_name', 'last_name', 'avatar'],
'limit': LIMITS.POINTS_LIST.LIKEUSERS_COUNT
},
'author': {
'fields': ['id', 'first_name', 'last_name', 'avatar']
},
'main_img': {
'extras': [
'thumbnail207', 'thumbnail560', 'thumbnail104x104',
'isliked', 'thumbnail207_height'
],
},
'imgs': {
'extras': [
'thumbnail207', 'thumbnail560', 'thumbnail104x104',
'isliked', 'thumbnail207_height'
],
'relations': {
'author': {
'fields':
['id', 'first_name', 'last_name', 'avatar']
},
'comments': {
'fields': ['txt', 'created', 'author'],
'relations': {
'author': {
'fields': [
'id', 'first_name', 'last_name',
'avatar'
]
},
},
'limit': LIMITS.IMAGES_LIST.COMMENTS_COUNT
},
},
'limit':
LIMITS.POINTS_LIST.IMAGES_COUNT
},
'reviews': {
'fields': ['id', 'review', 'rating', 'author'],
'relations': {
'author': {
'fields':
['id', 'first_name', 'last_name', 'avatar']
},
},
'limit': LIMITS.POINTS_LIST.REVIEWS_COUNT
}
})
def getSerializeCollections(self, collections):
YpJson = YpSerialiser()
return YpJson.serialize(
collections,
fields=[
'id', 'name', 'sets', 'isliked', 'description', 'author',
'points', 'points_by_user', 'likeusers', 'updated',
'likes_count', 'imgs', 'longitude', 'latitude', 'address',
'reviewusersplus', 'reviewusersminus', 'ypi'
],
extras=[
'likes_count', 'sets', 'isliked', 'type_of_item',
'reviewusersplus', 'reviewusersminus'
],
relations={
'likeusers': {
'fields': ['id', 'first_name', 'last_name', 'avatar'],
'limit': LIMITS.COLLECTIONS_LIST.LIKEUSERS_COUNT
},
'imgs': {
'extras': [
'thumbnail207', 'thumbnail560', 'thumbnail104x104',
'thumbnail207_height'
],
'relations': {
'comments': {
'fields': ['id', 'txt', 'created', 'author'],
'relations': {
'author': {
'fields': [
'id', 'first_name', 'last_name',
'avatar'
]
}
}
},
'likeusers': {
'fields': ['id', 'first_name', 'last_name'],
},
'author': {
'fields':
['id', 'first_name', 'last_name', 'avatar'],
},
},
'limit':
LIMITS.COLLECTIONS_LIST.IMAGES_COUNT
},
'points': {
'fields':
['imgs', 'name', 'author', 'longitude', 'latitude', 'id'],
'relations': {
'imgs': {
'extras': [
'thumbnail207', 'thumbnail207_height',
'thumbnail560', 'thumbnail65x52',
'thumbnail135x52', 'thumbnail205x52',
'thumbnail104x104'
],
'limit':
4,
'relations': {
'author': {
'fields': [
'id', 'first_name', 'last_name',
'avatar'
]
},
'comments': {
'fields': ['txt', 'created', 'author'],
'relations': {
'author': {
'fields': [
'id', 'first_name',
'last_name', 'avatar'
]
},
},
'limit': LIMITS.IMAGES_LIST.COMMENTS_COUNT
},
}
},
'author': {
'fields':
['id', 'first_name', 'last_name', 'avatar']
},
},
},
'points_by_user': {
'fields': [
'imgs',
'name',
'author',
'longitude',
'latitude',
'id',
'point',
],
'relations': {
'imgs': {
'extras': [
'thumbnail207', 'thumbnail207_height',
'thumbnail560', 'thumbnail65x52',
'thumbnail135x52', 'thumbnail205x52',
'thumbnail104x104'
],
'limit':
4,
'relations': {
'author': {
'fields': [
'id', 'first_name', 'last_name',
'avatar'
]
},
'comments': {
'fields': ['txt', 'created', 'author'],
'relations': {
'author': {
'fields': [
'id', 'first_name',
'last_name', 'avatar'
]
},
},
'limit': LIMITS.IMAGES_LIST.COMMENTS_COUNT
},
}
},
'author': {
'fields':
['id', 'first_name', 'last_name', 'avatar']
},
'point': {
'fields': [
'name',
'longitude',
'latitude',
]
}
},
},
})
def get(self, request, *args, **kwargs):
trip = get_object_or_404(TripsModels.Trips, pk=kwargs.get("id"))
YpJson = YpSerialiser()
relations = {
'likeusers': {'fields': ('first_name', 'last_name', 'avatar')},
'author': {'fields': ('first_name', 'last_name', 'avatar')},
'admins': {'fields': ('first_name', 'last_name', 'avatar')},
'members': {'fields': ('first_name', 'last_name', 'avatar')},
'blocks': {
'relations': {
'points': {
# 'relations': {
# 'tags': {'fields': ('name', 'id', 'level')},
# 'author': {'fields': ('first_name', 'last_name', 'avatar')},
# 'imgs': {
# 'extras': ('thumbnail104x104', 'thumbnail207', 'thumbnail560'),
# 'relations': {
# 'author': {'fields': ('last_name', 'first_name', 'avatar')},
# 'likeusers': {'fields': ('last_name', 'first_name', 'avatar')},
# 'comments': {
# 'relations': {
# 'author': {'fields': ('first_name', 'last_name', 'avatar')}
# }
# }
# }
# }
# }
},
'events': {
# 'relations': {
# 'tags': {'fields': ('name', 'id', 'level')},
# 'author': {'fields': ('first_name', 'last_name', 'avatar')},
# 'imgs': {
# 'extras': ('thumbnail104x104', 'thumbnail207', 'thumbnail560'),
# 'relations': {
# 'author': {'fields': ('last_name', 'first_name', 'avatar')},
# 'likeusers': {'fields': ('last_name', 'first_name', 'avatar')},
# 'comments': {
# 'relations': {
# 'author': {'fields': ('first_name', 'last_name', 'avatar')}
# }
# }
# }
# }
# }
},
'likeusers': {'fields': ('last_name', 'first_name', 'avatar')},
'imgs': {
'extras': ('thumbnail104x104', 'thumbnail207', 'thumbnail560', 'thumbnail625x370'),
'relations': {
'author': {'fields': ('last_name', 'first_name', 'avatar')},
'likeusers': {'fields': ('last_name', 'first_name', 'avatar')},
'comments': {
'relations': {
'author': {'fields': ('first_name', 'last_name', 'avatar')}
}
}
}
}
}
}
}
t0 = time.time()
trip = YpJson.serialize([trip], relations=relations)
self.log.info('Serialize trip detail complete (%.2f sec.) trip id: %s' % (time.time()-t0, kwargs.get('id')))
return HttpResponse(trip, mimetype="application/json")
def post(self, request, *args, **kwargs):
params = request.POST
COUNT_ELEMENTS = LIMITS.COLLECTIONS_LIST.COLLECTIONS_LIST_COUNT
errors = []
page = kwargs.get("page", 1) or 1
limit = COUNT_ELEMENTS*int(page)
offset = (int(page)-1)*COUNT_ELEMENTS
form = forms.FiltersForm(params)
if form.is_valid():
pointsreq = CollectionsModels.Collections.objects
user = form.cleaned_data.get("user")
if user:
pointsreq = pointsreq.filter(author__id__icontains=user)
coord_left = params.get("coord_left")
if coord_left:
try:
coord_left = json.loads(coord_left)
except:
errors.append("некорректно задана левая точка на карте для фильтра")
else:
ln = coord_left.get("ln")
lt = coord_left.get("lt")
if str(ln).replace(".", "", 1).isdigit() and str(lt).replace(".", "", 1).isdigit() and ln >= 0 and lt >= 0:
pointsreq = pointsreq.filter(points__longitude__gte=ln, points__latitude__gte=lt)
else:
errors.append("некорректно задана левая точка на карте для фильтра")
coord_right = params.get("coord_right")
if coord_right:
try:
coord_right = json.loads(coord_right)
except:
errors.append("некорректно задана правая точка на карте для фильтра")
else:
ln = coord_right.get("ln")
lt = coord_right.get("lt")
if str(ln).replace(".", "", 1).isdigit() and str(lt).replace(".", "", 1).isdigit() and ln >= 0 and lt >= 0:
pointsreq = pointsreq.filter(points__longitude__lte=ln, points__latitude__lte=lt)
name = form.cleaned_data.get("name")
if name:
pointsreq = pointsreq.filter(name__icontains=name)
tags = params.getlist("tags[]")
if tags and len(tags) > 0:
pointsreq = pointsreq.filter(points__tags__in=tags)
#.extra(where=['main_points.id in (select points_id from main_points_tags where tags_id in (%s))' % (",".join(map(lambda x: "'%s'" % x, tags)))])
content = form.cleaned_data.get("content") or 'new'
if content == 'new':
pointsreq = pointsreq.order_by('-created')
elif content == "popular":
pointsreq = pointsreq.annotate(uslikes=Count('likeusers__id')).order_by('-uslikes')
if request.user.is_authenticated():
user = MainModels.User.objects.get(username = request.user)
pointsreq = pointsreq.extra(
select={
'isliked': 'SELECT case when COUNT(*) > 0 then 1 else 0 end FROM collections_collections_likeusers WHERE collections_collections_likeusers.collections_id = collections_collections.id and collections_collections_likeusers.user_id = '+str(user.id),
'likes_count': 'SELECT count(*) from collections_collections_likeusers where collections_collections_likeusers.collections_id=collections_collections.id',
}
)
else:
pointsreq = pointsreq.extra(
select={
'isliked': 'SELECT 0 ',
'likes_count': 'SELECT count(*) from collections_collections_likeusers where collections_collections_likeusers.collections_id=collections_collections.id',
}
)
collections = pointsreq[offset:limit].all()
YpJson = YpSerialiser()
return HttpResponse(YpJson.serialize(collections,
extras=["isliked", "likes_count"],
fields=('id', 'name', 'description', 'likeusers', 'updated', 'points', 'author'),
relations={'points': {'fields': ('id', 'name', 'address', 'author', 'imgs'),
'relations': {'author': {'fields': ('first_name', 'last_name', 'avatar')},
'imgs': {'extras': ('thumbnail207', 'thumbnail560', 'thumbnail104x104'),
'limit': LIMITS.POINTS_LIST.IMAGES_COUNT},
},
'limit': LIMITS.COLLECTIONS_LIST.POINTS_COUNT
},
'author': {'fields': ('id', 'first_name', 'last_name', 'avatar')},
'likeusers': {'fields': ('id', 'first_name', 'last_name', 'avatar'),
'limit': LIMITS.COLLECTIONS_LIST.LIKEUSERS_COUNT}
}
),
mimetype="application/json")
else:
e = form.errors
for er in e:
errors.append(er +':'+e[er][0])
return JsonHTTPResponse({"status": 0, "txt": ", ".join(errors)})
def get(self, request, *args, **kwargs):
params = request.GET
COUNT_ELEMENTS = 10
status = 2
errors = []
page = kwargs.get("page", 1) or 1
limit = COUNT_ELEMENTS * int(page)
offset = (int(page) - 1) * COUNT_ELEMENTS
form = forms.FiltersForm(params)
if form.is_valid():
pointsreq = MainModels.Events.objects
user = form.cleaned_data.get("user")
if user:
pointsreq = pointsreq.filter(author__id_icontains=user)
coord_left = params.get("coord_left")
if coord_left:
try:
coord_left = json.loads(coord_left)
except:
status = 1
errors.append(
"некорректно задана левая точка на карте для фильтра")
else:
ln = coord_left.get("ln")
lt = coord_left.get("lt")
if str(ln).isdigit() and str(
lt).isdigit() and ln >= 0 and lt >= 0:
pointsreq = pointsreq.filter(point__longitude__gte=ln,
point__latitude__gte=lt)
coord_right = params.get("coord_right")
if coord_right:
try:
coord_right = json.loads(coord_right)
except:
status = 1
errors.append(
"некорректно задана правая точка на карте для фильтра")
else:
ln = coord_right.get("ln")
lt = coord_right.get("lt")
if str(ln).isdigit() and str(
lt).isdigit() and ln >= 0 and lt >= 0:
pointsreq = pointsreq.filter(point__longitude__lte=ln,
point__latitude__lte=lt)
categ = form.cleaned_data.get("categ")
if categ:
pointsreq = pointsreq.filter(
point__categories__id__icontains=categ)
name = form.cleaned_data.get("name")
if name:
pointsreq = pointsreq.filter(name__icontains=name)
tags = form.cleaned_data.get("tags")
if tags:
try:
tags = json.loads(tags)
except:
status = 1
errors.append(
"некорректно задана правая точка на карте для фильтра")
else:
if len(tags) > 0:
object_type = ContentType.objects.get_for_model(
MainModels.Events).id
pointsreq = pointsreq.extra(where=[
'main_events.id in (select events_id from main_events_tags where tags_id in (%s))'
% (",".join(map(lambda x: "'%s'" % x, tags)))
])
content = form.cleaned_data.get("content") or 'new'
if content == 'new':
pointsreq = pointsreq.order_by('-created')
elif content == "popular":
pointsreq = pointsreq.annotate(
uslikes=Count('likeusers__id')).order_by('-uslikes')
points = pointsreq[offset:limit].all()
YpJson = YpSerialiser()
return HttpResponse(YpJson.serialize(
points,
relations={
'point': {},
'tags': {
'fields': ('name', 'id', 'level')
},
'feedbacks': {
'fields': ('type', 'feedback')
},
'author': {
'fields': ('first_name', 'last_name', 'avatar')
},
'imgs': {
'extras': (
'thumbnail207',
'thumbnail325',
)
}
}),
mimetype="application/json")
else:
e = form.errors
for er in e:
errors.append(er + ':' + e[er][0])
return JsonHTTPResponse({
"status": 0,
"txt": ", ".join(errors)
})
def get(self, request, *args, **kwargs):
pk = kwargs.get("id")
event = get_object_or_404(MainModels.Events, pk=pk)
YpJson = YpSerialiser()
return HttpResponse(YpJson.serialize([event], relations={'point':{}, 'feedbacks': {'fields': ('type', 'feedback')}, 'tags': {'fields': ('name', 'id', 'level')}, 'author':{'fields':('first_name','last_name','avatar')},'imgs':{'extras':('thumbnail207','thumbnail325',)}}), mimetype="application/json")
def get(self, request, *args, **kwargs):
params = request.GET
COUNT_ELEMENTS = 10
status = 2
errors = []
page = kwargs.get("page", 1) or 1
limit = COUNT_ELEMENTS*int(page)
offset = (int(page)-1)*COUNT_ELEMENTS
form = forms.FiltersForm(params)
if form.is_valid():
pointsreq = MainModels.Events.objects;
user = form.cleaned_data.get("user")
if user:
pointsreq = pointsreq.filter(author__id_icontains=user)
coord_left = params.get("coord_left")
if coord_left:
try:
coord_left = json.loads(coord_left)
except:
status = 1
errors.append("некорректно задана левая точка на карте для фильтра")
else:
ln = coord_left.get("ln")
lt = coord_left.get("lt")
if str(ln).isdigit() and str(lt).isdigit() and ln >= 0 and lt >= 0:
pointsreq = pointsreq.filter(point__longitude__gte=ln, point__latitude__gte=lt)
coord_right = params.get("coord_right")
if coord_right:
try:
coord_right = json.loads(coord_right)
except:
status = 1
errors.append("некорректно задана правая точка на карте для фильтра")
else:
ln = coord_right.get("ln")
lt = coord_right.get("lt")
if str(ln).isdigit() and str(lt).isdigit() and ln >= 0 and lt >= 0:
pointsreq = pointsreq.filter(point__longitude__lte=ln, point__latitude__lte=lt)
categ = form.cleaned_data.get("categ")
if categ:
pointsreq = pointsreq.filter(point__categories__id__icontains=categ)
name = form.cleaned_data.get("name")
if name:
pointsreq = pointsreq.filter(name__icontains=name)
tags = form.cleaned_data.get("tags")
if tags:
try:
tags = json.loads(tags)
except:
status = 1
errors.append("некорректно задана правая точка на карте для фильтра")
else:
if len(tags) > 0:
object_type = ContentType.objects.get_for_model(MainModels.Events).id
pointsreq = pointsreq.extra(where=['main_events.id in (select events_id from main_events_tags where tags_id in (%s))' % (",".join(map(lambda x: "'%s'" % x, tags)))])
content = form.cleaned_data.get("content") or 'new'
if content == 'new':
pointsreq = pointsreq.order_by('-created')
elif content == "popular":
pointsreq = pointsreq.annotate(uslikes=Count('likeusers__id')).order_by('-uslikes')
points = pointsreq[offset:limit].all()
YpJson = YpSerialiser()
return HttpResponse(YpJson.serialize(points, relations={'point':{}, 'tags': {'fields': ('name', 'id', 'level')}, 'feedbacks': {'fields': ('type', 'feedback')}, 'author':{'fields':('first_name','last_name','avatar')},'imgs':{'extras':('thumbnail207','thumbnail325',)}}), mimetype="application/json")
else:
e = form.errors
for er in e:
errors.append(er +':'+e[er][0])
return JsonHTTPResponse({"status": 0, "txt": ", ".join(errors)});
