def save(self):
if not self.instance or not self.user:
return
content_type = ContentType.objects.get_for_model(self.instance)
object_id = self.instance.id
rating = self.cleaned_data["number"].strip()
if rating == "delete":
# Delete rating
self.instance.ratings.filter(user=self.user).delete()
else:
try:
rating_obj = Rating.objects.get(content_type=content_type,
object_id=object_id,
user=self.user)
rating_obj.value = int(rating)
rating_obj.save()
except Rating.DoesNotExist:
rating_obj = Rating(content_type=content_type,
object_id=object_id,
user=self.user,
value=int(rating))
rating_obj.save()
if isinstance(self.instance, Indexed):
self.instance.reindex()
def rateSong(request, songPK):
if request.method=='POST':
if request.user.is_authenticated():
song = Loop.objects.get(pk=songPK)
points = request.POST['rating']
r = Rating(model='song', points=int(points), song = song, player = request.user.get_profile(), comment='')
r.save()
return HttpResponseRedirect('/song/list/page1')
else:
return HttpResponseRedirect('/')
def update(request):
rating_type, iid, value, ip = parse_request(request)
if is_already_voted(rating_type, ip, iid):
return HttpResponseBadRequest(json.dumps({"message": "ALREADY_VOTED"}))
Model = get_rating_model(rating_type)
model = Model.objects.get(pk=iid)
model.update_rating(value)
Rating.create(rating_type=rating_type, iid=iid, ip=ip, value=value)
return JsonResponse({
"rating_positive": model.rating_positive,
"rating_negative": model.rating_negative,
})
def rating_create(request):
if request.method == 'POST':
form = RatingForm(request.POST)
if form.is_valid():
id_of_profile = form.cleaned_data['profile_id']
doctor = DoctorProfile.objects.get(id=id_of_profile)
rating_obj = Rating()
if not request.user.is_doctor:
rating_obj.user = request.user
rating_obj.profile = doctor
rating_obj.comment = form.cleaned_data['comment']
rating_obj.rating = form.cleaned_data['rating']
rating_obj.save()
return redirect(reverse_lazy('doctor:doctor_detail',kwargs={ 'pk': id_of_profile } ))
else:
form = RatingForm()
return render(request, "doctor/doctor_detail.html", {"form" : form })
def post(self, request):
video_serializer = VideoSerializer(data=request.data)
if video_serializer.is_valid() and 'main' in request.data:
data = video_serializer.validated_data
video = video_serializer.create(validated_data=data, user=request.user)
Views(video=video).save()
Rating(video=video).save()
print(request.data)
import json
try:
main = json.loads(request.data['main'])
video_parts = self.get_video_parts(main, user=request.user)
except Exception as e:
return Response("Video parts are incorrect", status=status.HTTP_400_BAD_REQUEST)
for part in video_parts:
if part.parent_ref is None:
part.parent = None
else:
part.parent = part.parent_ref
part.main_video = video
part.save()
head = video_parts[0]
video.head_video_part = head
# Проверять кодеки, что совместимы
video.codec = head.source.codec
video.save()
'''
for all sources
status = used
'''
return Response({ 'key': video.key }, status=status.HTTP_201_CREATED)
else:
return Response(video_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def run():
libraries = connections["old"].cursor()
cursor = connections["old"].cursor()
# Delete existing courses
print "Removing existing libraries..."
Library.objects.all().delete()
print "Creating libraries..."
cached_users = dict([(profile.principal_id, profile.user) for profile in Profile.objects.select_related().all()])
cached_users["zope.manager"] = admin
class_id = 101
cursor.execute("SELECT object_id, id FROM _intids WHERE class_id = %s", [class_id])
intids = dict(cursor.fetchall())
tags_dict = {}
cursor.execute("SELECT * FROM _tags")
for item, principal, name, timestamp in cursor.fetchall():
if item not in tags_dict:
tags_dict[item] = []
if principal in cached_users:
tags_dict[item].append((name, cached_users[principal], timestamp))
rating_dict = {}
cursor.execute("SELECT * FROM _overall_rating WHERE id = 'overall_rating'")
for item, id, principal, value, timestamp in cursor.fetchall():
if item not in rating_dict:
rating_dict[item] = []
if principal in cached_users:
rating_dict[item].append((int(value), cached_users[principal], timestamp))
reviews_dict = {}
cursor.execute("SELECT * FROM _reviews")
for item, principal, text, timestamp in cursor.fetchall():
if item not in reviews_dict:
reviews_dict[item] = []
if principal in cached_users:
reviews_dict[item].append((text, cached_users[principal], timestamp))
saved_items_dict = {}
cursor.execute("SELECT * FROM _bookmarks")
for item, principal, timestamp in cursor.fetchall():
if item not in saved_items_dict:
saved_items_dict[item] = []
if principal in cached_users:
saved_items_dict[item].append((cached_users[principal], timestamp))
creators = {}
cursor.execute("SELECT * FROM _ownership WHERE class_id = %s", [class_id])
for object_id, class_id, principal_id in cursor.fetchall():
if principal_id in cached_users:
creators[object_id] = cached_users[principal_id]
else:
creators[object_id] = admin
created_dict = {}
cursor.execute("SELECT * FROM _dublincore WHERE class_id = %s AND property = %s AND qualified = %s",
[class_id, "Date", "Created"])
for id, object_id, class_id, property, qualified, value in cursor.fetchall():
created_dict[object_id] = parse(value)
modified_dict = {}
cursor.execute("SELECT * FROM _dublincore WHERE class_id = %s AND property = %s AND qualified = %s",
[class_id, "Date", "Modified"])
for id, object_id, class_id, property, qualified, value in cursor.fetchall():
modified_dict[object_id] = parse(value)
workflow_state_dict = {}
cursor.execute("SELECT object_id, state FROM _workflowstates WHERE class_id = %s",
[class_id, ])
for object_id, state in cursor.fetchall():
workflow_state_dict[object_id] = state
libraries.execute("SELECT * FROM libraries")
total_items = libraries.rowcount
cnt = 0
for id, name, title, description, content_creation_date, authors, \
author_emails, author_countries, remote_url, keywords, \
tech_requirements, general_subjects, grade_levels, languages, \
geographic_relevance, institution, collection, material_types, \
media_formats, curriculum_standards, is_homepage, iskme_id, cksum, native_id, \
license_url, license_name, license_image, license_description, \
copyright_holder, in_rss, rss_description, rss_datetime, is_featured, \
publication_time, _searchindex, cou_bucket, tags in libraries.fetchall():
if "audio-lectures" in material_types:
continue
cnt += 1
creator = creators[id]
try:
library = Library(id=id,
slug=force_unicode(name),
title=force_unicode(title),
abstract=force_unicode(description),
content_creation_date=content_creation_date,
url=force_unicode(remote_url),
tech_requirements=force_unicode(tech_requirements),
institution=institution and Institution.objects.get_or_create(name=force_unicode(institution))[0] or None,
collection=collection and Collection.objects.get_or_create(name=force_unicode(collection))[0] or None,
license=License.objects.get_or_create(url=force_unicode(license_url),
name=force_unicode(license_name),
image_url=force_unicode(license_image),
description=force_unicode(license_description),
copyright_holder=force_unicode(copyright_holder))[0],
curriculum_standards=curriculum_standards,
is_homepage=bool(is_homepage),
provider_id=force_unicode(native_id),
in_rss=in_rss,
rss_description=rss_description,
rss_timestamp=rss_datetime,
featured=is_featured,
published_on=publication_time,
creator=creator,
created_on=created_dict[id],
modified_on=modified_dict[id],
workflow_state=workflow_state_dict[id],
)
library.save()
except DatabaseError:
import pprint
pprint.pprint(dict([(k, len(v)) for k, v in locals().items() if isinstance(v, basestring) and len(v) > 100]))
raise
for i, author_name in enumerate(authors):
author_name = force_unicode(author_name).replace(u'"', u"")
author_email = len(author_emails) > i and force_unicode(author_emails[i]) or u""
author_country = len(author_countries) > i and Country.objects.get(slug=force_unicode(author_countries[i])) or None
library.authors.add(Author.objects.get_or_create(name=author_name,
email=author_email,
country=author_country)[0])
for o in general_subjects:
library.general_subjects.add(GeneralSubject.objects.get(slug=o))
for o in grade_levels:
library.grade_levels.add(GradeLevel.objects.get(slug=o))
cleaned_keywords = cleanup_keywords(force_unicode(keywords))
for o in cleaned_keywords:
library.keywords.add(Keyword.objects.get_or_create(name=o)[0])
for o in languages:
library.languages.add(Language.objects.get(slug=o))
for o in geographic_relevance:
library.geographic_relevance.add(GeographicRelevance.objects.get(slug=o))
for o in material_types:
library.material_types.add(LibraryMaterialType.objects.get(slug=o))
for o in media_formats:
library.media_formats.add(MediaFormat.objects.get(slug=o))
int_id = intids[id]
if int_id in tags_dict:
for name, user, timestamp in tags_dict[int_id]:
tag = Tag(object_id=id, content_type=content_type,
name=force_unicode(name), user=user)
tag.timestamp = timestamp
tag.save()
if int_id in rating_dict:
for value, user, timestamp in rating_dict[int_id]:
rating = Rating(object_id=id, content_type=content_type,
value=value, user=user)
rating.timestamp = timestamp
rating.save()
if int_id in reviews_dict:
for text, user, timestamp in reviews_dict[int_id]:
review = Review(object_id=id, content_type=content_type,
text=force_unicode(text), user=user)
review.timestamp = timestamp
review.save()
if int_id in saved_items_dict:
for user, timestamp in saved_items_dict[int_id]:
saved_item = SavedItem(object_id=id, content_type=content_type,
user=user)
saved_item.timestamp = timestamp
saved_item.save()
if cnt % 100 == 0:
print "%i of %i" % (cnt, total_items)
reindex_materials()
print "Done!"
drop = input('Do You want to drop the tables if they exist?')
if drop.lower() != 'n':
db.drop_all()
number_of_pubs = int(input('How many pubs?'))
number_of_cocktails = int(input('How many cocktails for each pub?'))
number_of_ratings = int(input('How many ratings for each cocktail?'))
fake = Faker()
db.create_all()
fake.name()
for n in range(number_of_pubs):
name = fake.first_name() + "'s pub"
n = Pub(name=name)
db.session.add(n)
for pub in Pub.query.all():
for c in range(number_of_cocktails):
c_name = fake.first_name() + "'s cocktail"
description = fake.text()
c = Cocktail(name=c_name, pub_id=pub.id, description=description)
db.session.add(c)
for cocktail in Cocktail.query.all():
for r in range(number_of_ratings):
rating = randint(0, 5)
r = Rating(cocktail_id=cocktail.id, rating=rating)
db.session.add(r)
db.session.commit()
