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_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 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))