def post(self, *args, **kw):
ticket_id = int(self.request.POST['ticket'])
if not ticket_id:
return http.HttpResponseRedirect(reverse("fbapp_choose_ticket"))
ticket = ContestTickets.objects.get(id=ticket_id)
contest = self.get_contest()
try:
participant = ContestParticipation.objects.get(
contest=contest,
user=self.request.unique_user
)
except ContestParticipation.DoesNotExist:
fb_user = FBUser.create_or_update(self.user_details)
ratings_cnt = len(rating_helper.get_user_ratings(self.request.unique_user).keys())
participant = ContestParticipation.objects.create(
contest=contest,
user=self.request.unique_user,
fb_user=fb_user,
contest_ticket=ticket,
score=5,
ratings_start_count = ratings_cnt,
)
participant.state = ContestParticipation.STATE_TICKET
participant.contest_ticket = ticket
participant.save()
return http.HttpResponseRedirect(reverse("fbapp_quiz"))
def get_all_recommendations(user, mood=None, similar=True, limit=True):
if not user.id:
return ()
recommendations = recompute_recommendations(user)
ratings = rating_helper.get_user_ratings(user.id)
return RecommendationsWrapper(recommendations, ratings, mood, similar=similar, limit=limit)
def read(self, request, id):
user = self.get_user(request, id)
ratings = rating_helper.get_user_ratings(user.id)
return paginated_collection(request, [
{
'film_uri': reverse(films_handler, args=[self.film_id_to_imdb_code(i)]),
'value': rating
} for (i, rating) in ratings.items()
], default_limit=50)
def read(self, request, id):
from film20.new_recommendations.similarity_engine import reclist_from_similarities
user = self.get_user(request, id)
ratings = rating_helper.get_user_ratings(user.id)
film_ids = self.to_recommend_ids(request)
reclist = [
{
'film_uri': reverse(films_handler, args=[self.film_id_to_imdb_code(id)])
} for id in reclist_from_similarities(ratings, film_ids) if id not in ratings.keys()
]
return paginated_collection(request, reclist, default_limit=50)
def get_vue_recommendations(user, mood=None, similar=True, limit=True):
from film20.new_recommendations.rateless_alg import rec_engine
if not user.id:
return ()
ratings = rating_helper.get_user_ratings(user.id)
unliked = RecommendationVote.get_unliked_film_ids(user)
recommendations = rec_engine.get_recommendations(ratings.items(), 1000)
key = cache.Key("user_vue_recommendations", user.id)
cache.set(key, recommendations, cache.A_WEEK)
return RecommendationsWrapper(recommendations, ratings, mood, similar=similar, limit=limit, exclude=unliked)
def get_all_recommendations(user, mood=None, similar=True, limit=True):
if not user.id:
return ()
recommendations = recompute_recommendations(user)
ratings = rating_helper.get_user_ratings(user.id)
return RecommendationsWrapper(recommendations,
ratings,
mood,
similar=similar,
limit=limit)
def get_vue_recommendations(user, mood=None, similar=True, limit=True):
from film20.new_recommendations.rateless_alg import rec_engine
if not user.id:
return ()
ratings = rating_helper.get_user_ratings(user.id)
unliked = RecommendationVote.get_unliked_film_ids(user)
recommendations = rec_engine.get_recommendations(ratings.items(), 1000)
key = cache.Key("user_vue_recommendations", user.id)
cache.set(key, recommendations, cache.A_WEEK)
return RecommendationsWrapper(recommendations,
ratings,
mood,
similar=similar,
limit=limit,
exclude=unliked)
def get_participant( self ):
contest = self.get_object()
fb_user = FBUser.create_or_update( self.request.session['user_details'] )
try:
participant = ContestParticipation.objects.get( contest=contest, fb_user=fb_user )
if participant.user != self.request.unique_user:
participant.user = self.request.unique_user
participant.save()
except ContestParticipation.DoesNotExist:
ratings_cnt = len(rating_helper.get_user_ratings(self.request.unique_user).keys())
participant = ContestParticipation.objects.create(
contest=contest,
user=self.request.unique_user,
ratings_start_count = ratings_cnt,
fb_user=fb_user, state=ContestParticipation.STATE_TICKET
)
return participant
def calculate_progress(self, participant):
ratings_cnt = len(rating_helper.get_user_ratings(participant.user).keys())
progress_max = settings.FBAPP.get('config').get('movies_to_rate_for_progress', 6)
progress_value = max(0, ratings_cnt - participant.ratings_start_count)
progress_value = min(progress_value, progress_max)
progress_left = progress_max - progress_value
progress_percent = progress_value * 100 / progress_max
if progress_value > participant.rated_count:
n = progress_value - participant.rated_count
participant.state = ContestParticipation.STATE_RATINGS
participant.rated_count = progress_value
participant.score += n * settings.FBAPP.get('points').get('rated_movie', 10)
participant.save()
return {
'progress_max': progress_max,
'progress_value': progress_value,
'progress_left': progress_left,
'progress_percent': progress_percent,
'participant': participant,
}
def create_comparator_for_two_users(curuser, compared_user, new_user=False):
# data for creating a RatingComparator object
oryg_films_compared = 0
films_compared = 0
sum_difference = 0
comparator = None
## TODO: this has to be optimized. This data can be extracted in one query,
## having compared_user and user rating for each film in one row
# for new users get all their ratings
if new_user:
# new comparator
comparator = RatingComparator()
comparator.main_user = curuser
comparator.compared_user = compared_user
curuser_ratings = Rating.objects.filter(user=compared_user.id, type=Rating.TYPE_FILM, rating__isnull=False)
# for old users (that we have comparators with) get only
else:
# get old comparator
try:
comparator = RatingComparator.objects.get(main_user=curuser.id, compared_user=compared_user.id)
films_compared = comparator.common_films
oryg_films_compared = comparator.common_films
sum_difference = comparator.sum_difference
ddebug("Fetched: " + unicode(comparator))
# this means not set
if sum_difference == -1:
sum_difference = oryg_films_compared * comparator.score
ddebug("Re-computed sum difference: " + unicode(sum_difference))
except RatingComparator.DoesNotExist:
debug(
"FATAL ERROR!!! CANNOT GET COMPARATOR FOR USERS: "
+ unicode(curuser.username)
+ " and "
+ unicode(compared_user.username)
)
debug("Creating new one... but this is WRONG!!!")
comparator = RatingComparator()
comparator.main_user = curuser
comparator.compared_user = compared_user
ratings1 = rating_helper.get_user_ratings(curuser)
ratings2 = rating_helper.get_user_ratings(compared_user)
common_films = set(ratings1.keys()).intersection(ratings2.keys())
sum_difference = sum(abs(ratings1[id] - ratings2[id]) for id in common_films)
films_compared = len(common_films)
if True:
ddebug("Films compared: " + unicode(films_compared))
ddebug("Accum. difference: " + unicode(sum_difference))
if oryg_films_compared != films_compared:
if films_compared > MIN_FILMS_COMPARED:
the_score = Decimal(sum_difference) / Decimal(films_compared)
comparator.score = the_score
comparator.common_films = films_compared
comparator.sum_difference = sum_difference
# save every other time to make sure that we always update both comparators (user1 vs user2 and user2 vs user1)
# THIS IS NOT NECESSARY ANYMORE (we only need to do it once)
# if comparator.previous_save_date:
# comparator.previous_save_date = None
# else:
# comparator.previous_save_date = comparator.updated_at
comparator.previous_save_date = None
comparator.save()
# create/update the other object
try:
other_comparator = RatingComparator.objects.get(
main_user=compared_user.id, compared_user=curuser.id
)
ddebug("Fetched the other comparator: " + unicode(comparator))
except RatingComparator.DoesNotExist:
ddebug("Creating the other comparator")
other_comparator = RatingComparator()
other_comparator.main_user = compared_user
other_comparator.compared_user = curuser
other_comparator.score = comparator.score
other_comparator.common_films = comparator.common_films
other_comparator.sum_difference = comparator.sum_difference
other_comparator.previous_save_date = comparator.previous_save_date
other_comparator.save()
debug(
"Updated ratings between: "
+ unicode(curuser)
+ ", "
+ unicode(compared_user)
+ "["
+ unicode(comparator.score)
+ "]"
)
else:
ddebug(
"Too few common films ("
+ unicode(films_compared)
+ ") between users: "
+ unicode(curuser)
+ ", "
+ unicode(compared_user)
)
else:
ddebug("No new films to be compared between users: " + unicode(curuser) + ", " + unicode(compared_user))
def get_rated_films(self):
return set(rating_helper.get_user_ratings(self.user.id).keys())
def get_rated_films(self):
return set(rating_helper.get_user_ratings(self.user.id).keys())
def test_anonymous_rating(self):
from django.core.urlresolvers import reverse
self.client = self.client_class()
self.assertTrue(Film.objects.tagged('dramat'))
rate_url = reverse('rate_films')
response = self.client.get(rate_url)
to_rate = list(response.context['films'])
self.assertTrue(to_rate)
request = response.context['request']
username = request.unique_user.username
self.assertTrue(username.startswith('tmp-'))
self.assertNotEquals(username, 'tmp-anonymous')
self.assertFalse(request.unique_user.id)
self.assertFalse(User.objects.filter(username__startswith='tmp-', is_active=False))
self.client.post('/ajax/rate-film/', {'film_id':to_rate[0].id, 'rating':10})
user = User.objects.get(username__startswith='tmp-', is_active=False)
username = user.username
for i, film in enumerate(to_rate[1:]):
self.client.post('/ajax/rate-film/', {'film_id':film.id, 'rating':i+1})
cnt = len(to_rate)
self.assertEquals(cnt, 6)
self.assertEquals(Rating.count_for_user(user), cnt)
left = max(0, settings.RECOMMENDATIONS_MIN_VOTES_USER - cnt)
if left:
for i in range(left / settings.RATING_FILMS_NUMBER + 1):
response = self.client.get(rate_url)
for film in list(response.context['films']):
self.client.post('/ajax/rate-film/', {'film_id':film.id, 'rating':5})
left -= 1
if not left:
break
# extra fetch to make sure few films are marked as seen
response = self.client.get(rate_url)
to_rate = list(response.context['films'])
data = {'prev_film_ids': ','.join(str(f.id) for f in to_rate)}
self.client.post(rate_url, data)
self.assertEquals(Rating.count_for_user(user), settings.RECOMMENDATIONS_MIN_VOTES_USER)
self.assertTrue(Profile.objects.get(user=user).recommendations_status in (Profile.FAST_RECOMMENDATIONS, Profile.NORMAL_RECOMMENDATIONS))
self.assertFalse(UserActivity.objects.all())
response = self.client.post(reverse('acct_signup'), {
'email': '*****@*****.**',
'username': '******',
'password1': 'abcdef123',
'password2': 'abcdef123',
})
self.assertEquals(response.status_code, 302)
self.assertTrue(response['Location'].endswith(reverse('main_page')))
user = User.objects.get(username='******')
self.assertEquals(len(rating_helper.get_user_ratings(user.id)), settings.RECOMMENDATIONS_MIN_VOTES_USER)
self.assertTrue(len(rating_helper.get_seen_films(user)))
# check if user has public rating activities
activities = UserActivity.objects.filter(activity_type=UserActivity.TYPE_RATING, user=user)
self.assertTrue(activities)
# make sure temporary username was updated
self.assertFalse(activities.filter(username__startswith='tmp-'))
def create_comparator_for_two_users(curuser, compared_user, new_user=False):
# data for creating a RatingComparator object
oryg_films_compared = 0
films_compared = 0
sum_difference = 0
comparator = None
## TODO: this has to be optimized. This data can be extracted in one query,
## having compared_user and user rating for each film in one row
# for new users get all their ratings
if new_user:
# new comparator
comparator = RatingComparator()
comparator.main_user = curuser
comparator.compared_user = compared_user
curuser_ratings = Rating.objects.filter(
user=compared_user.id,
type=Rating.TYPE_FILM,
rating__isnull=False
)
# for old users (that we have comparators with) get only
else:
# get old comparator
try:
comparator = RatingComparator.objects.get(main_user=curuser.id, compared_user=compared_user.id)
films_compared = comparator.common_films
oryg_films_compared = comparator.common_films
sum_difference = comparator.sum_difference
ddebug('Fetched: ' + unicode(comparator))
# this means not set
if sum_difference == -1:
sum_difference = oryg_films_compared * comparator.score
ddebug('Re-computed sum difference: ' + unicode(sum_difference))
except RatingComparator.DoesNotExist:
debug("FATAL ERROR!!! CANNOT GET COMPARATOR FOR USERS: " + unicode(curuser.username) + " and " + unicode(compared_user.username))
debug("Creating new one... but this is WRONG!!!")
comparator = RatingComparator()
comparator.main_user = curuser
comparator.compared_user = compared_user
ratings1 = rating_helper.get_user_ratings(curuser)
ratings2 = rating_helper.get_user_ratings(compared_user)
common_films = set(ratings1.keys()).intersection(ratings2.keys())
sum_difference = sum(abs(ratings1[id]-ratings2[id]) for id in common_films)
films_compared = len(common_films)
if True:
ddebug('Films compared: ' + unicode(films_compared))
ddebug('Accum. difference: ' + unicode(sum_difference))
if oryg_films_compared != films_compared:
if films_compared > MIN_FILMS_COMPARED:
the_score = Decimal(sum_difference)/Decimal(films_compared)
comparator.score = the_score
comparator.common_films = films_compared
comparator.sum_difference = sum_difference
# save every other time to make sure that we always update both comparators (user1 vs user2 and user2 vs user1)
# THIS IS NOT NECESSARY ANYMORE (we only need to do it once)
# if comparator.previous_save_date:
# comparator.previous_save_date = None
# else:
# comparator.previous_save_date = comparator.updated_at
comparator.previous_save_date = None
comparator.save()
# create/update the other object
try:
other_comparator = RatingComparator.objects.get(main_user=compared_user.id, compared_user=curuser.id)
ddebug('Fetched the other comparator: ' + unicode(comparator))
except RatingComparator.DoesNotExist:
ddebug("Creating the other comparator")
other_comparator = RatingComparator()
other_comparator.main_user = compared_user
other_comparator.compared_user = curuser
other_comparator.score = comparator.score
other_comparator.common_films = comparator.common_films
other_comparator.sum_difference = comparator.sum_difference
other_comparator.previous_save_date = comparator.previous_save_date
other_comparator.save()
debug("Updated ratings between: " + unicode(curuser) + ", " + unicode(compared_user) + "[" + unicode(comparator.score) + "]")
else:
ddebug("Too few common films ("+unicode(films_compared)+") between users: " + unicode(curuser) + ", " + unicode(compared_user))
else:
ddebug("No new films to be compared between users: " + unicode(curuser) + ", " + unicode(compared_user))
