Example #1
0
 def get_excluded_films(self):
     ids = set()
     ids.update(self.get_seen_films())
     if self.user.id:
         ids.update(Rating.get_user_ratings(self.user).keys())
         ids.update(Film._marked_film_ids(self.user))
     return ids
Example #2
0
def user_recommendations(user, films, with_rated=False, order_by=None):
    film_ids = [f.id for f in films]

    if user and user.is_authenticated():
        profile = user.get_profile()
        basket = BasketItem.user_basket(user)
        rated_ids = set(Rating.get_user_ratings(user).keys())
        if profile.recommendations_status in (profile.NORMAL_RECOMMENDATIONS,
                                              profile.FAST_RECOMMENDATIONS):
            recommendations = recommendations_engine.compute_guess_score_for_films(
                user, film_ids)
        else:
            recommendations = {}

        for f in films:
            r = recommendations.get(f.id)
            b = basket.get(f.id)
            f._rated = f.id in rated_ids
            f._guess_rating = r or 0
            f._on_wishlist = b and b[0] and (
                b[0] != BasketItem.NOT_INTERESTED) or False
            f._on_shitlist = b and (b[0] == BasketItem.NOT_INTERESTED) or False
    else:
        for f in films:
            f._rated = False
            f._guess_rating = 0
            f._on_wishlist = False
            f._on_shitlist = False

    test_with_rated = lambda f: with_rated or not f._rated

    films = list(f for f in films if not f._on_shitlist and test_with_rated(f))

    comparator = create_film_comparator(order_by)
    return sorted(films, cmp=comparator)
Example #3
0
def user_recommendations(user, films, with_rated=False, order_by=None):
    film_ids = [f.id for f in films]

    if user and user.is_authenticated():
        profile = user.get_profile()
        basket = BasketItem.user_basket(user)
        rated_ids = set(Rating.get_user_ratings(user).keys())
        if profile.recommendations_status in (profile.NORMAL_RECOMMENDATIONS, profile.FAST_RECOMMENDATIONS):
            recommendations = recommendations_engine.compute_guess_score_for_films(user, film_ids)
        else:
            recommendations = {}

        for f in films:
            r = recommendations.get(f.id)
            b = basket.get(f.id)
            f._rated = f.id in rated_ids
            f._guess_rating = r or 0
            f._on_wishlist = b and b[0] and (b[0] != BasketItem.NOT_INTERESTED) or False
            f._on_shitlist = b and (b[0] == BasketItem.NOT_INTERESTED) or False
    else:
        for f in films:
            f._rated = False
            f._guess_rating = 0
            f._on_wishlist = False
            f._on_shitlist = False

    test_with_rated = lambda f: with_rated or not f._rated

    films = list(f for f in films if not f._on_shitlist and test_with_rated(f))

    comparator = create_film_comparator(order_by)
    return sorted(films, cmp=comparator)
Example #4
0
    def save(self, **kw):
        ratings = Rating.get_user_ratings(self.user)
        number_of_ratings = len(ratings)
        if number_of_ratings:
            average_rating = decimal.Decimal(sum(ratings.values())) / number_of_ratings
        else:
            averate_rating = None
        ratings_based_prediction = None
        traits_based_prediction = None

        film_id = self.cleaned_data['film_id']
        vote = self.cleaned_data['vote'] or None
        
        defaults = {
                'vote': vote,
                'average_rating': average_rating,
                'number_of_ratings': number_of_ratings,
                'ratings_based_prediction': ratings_based_prediction,
                'traits_based_prediction': traits_based_prediction,
        }
        defaults.update(kw)
        vote, created = RecommendationVote.objects.get_or_create(user=self.user, film_id=film_id, defaults=defaults)
        if not created:
            vars(vote).update(defaults)
            vote.save()
        return vote
Example #5
0
def rate(user, value, film_id=None, actor_id=None, director_id=None, type=1, overwrite=True, check_if_exists=False, redis_only=False, skip_activity=False, **kw):
    if not user.id and hasattr(user, 'store_to_db'):
        # temporary anonymouse user, store to db on first rating
        user.store_to_db()

    assert user.id

    if not redis_only or not settings.USE_REDIS:
        if not settings.USE_REDIS:
            ret = Rating.rate(user, value, film_id, actor_id, director_id, type, overwrite=overwrite, _skip_activity=skip_activity, **kw)
        else:
            defer(Rating.rate, user, value, film_id, actor_id, director_id, type, overwrite=overwrite, _skip_activity=skip_activity, **kw)

    if settings.USE_REDIS:
        ret = redis_intf.rate(user.id, value, film_id, actor_id, director_id, type, overwrite=overwrite, check_if_exists=check_if_exists)

    profile = user.get_profile()
    no_rec = profile.recommendations_status == profile.NO_RECOMMENDATIONS

    if settings.RECOMMENDATIONS_ENGINE == 'film20.new_recommendations.recommendations_engine':
        engine.compute_user_features(user)
        if no_rec:
            profile.recommendations_status = profile.FAST_RECOMMENDATIONS
            profile.save()
    else:
        if no_rec and len(get_user_ratings(user.id)) >= settings.RECOMMENDATIONS_MIN_VOTES_USER:
            engine.compute_user_features(user, True, initial=True)
            profile.recommendations_status = profile.FAST_RECOMMENDATIONS
            profile.save()
    return ret
Example #6
0
def count_guessed_rate(user, film):
    ratings = Rating.get_user_ratings(user)
    logger.info("counting guessed rate for film %d", film.id)

    if len(ratings) < MIN_USER_RATES:
        return None

    average_rate, average_weight = AVERAGE_RATE, AVERAGE_WEIGHT

    film_weight = 0.0
    film_rate = film.average_score() or 0.0
    film_rate = float(film_rate)

    if film_rate:
        film_weight = FILM_WEIGHT * pow(
                float(film.number_of_votes() / FILM_RELIABILITY_BAR), 0.3)

    user_rate = sum(ratings.values()) / len(ratings)
    user_weight = USER_WEIGHT * (len(ratings) / USER_RELIABILITY_BAR) ** 0.3

#    film_ids = ratings.keys()
#    scores = dict(FilmComparator.objects.filter(
#            main_film=film, compared_film__id__in=film_ids).\
#            values_list('compared_film', 'score'))

    key = cache.Key("compared_films", film.id)
    scores = cache.get(key)
    if scores is None:
        query = FilmComparator.objects.filter(main_film=film).values_list(
                    'compared_film', 'score')
        scores = dict((f, float(s)) for (f, s) in query)
        cache.set(key, scores)


    sum_weights = 0.0
    sum_rate = 0.0
    for film_id, rating in ratings.items():
        if film_id in scores:
            weight = float(scores[film_id])
            sum_weights += weight
            sum_rate += float(rating) * weight

    sum_rate += film_weight * film_rate + user_weight * user_rate
    sum_rate += average_weight * average_rate
    sum_weights += film_weight + user_weight + average_weight
    recommendation = None
    if sum_weights > 0.0 and sum_rate >= 0.0:
        score = Decimal(str(sum_rate / sum_weights))
        if score <= 10:
            recommendation, created = Recommendation.objects.get_or_create(
                user=user, 
                film=film,
                defaults=dict(guess_rating_alg2=score),
            )
            if not created:
                recommendation.guess_rating_alg2 = score
                recommendation.save()
    # transaction.commit()
    return recommendation
Example #7
0
    def get_best_psi_films_queryset(self,
                                    user,
                                    tags=None,
                                    year_from=None,
                                    year_to=None,
                                    related_director=None,
                                    related_actor=None,
                                    popularity=None,
                                    include_features=(),
                                    exclude_features=(),
                                    netflix=None,
                                    exclude_production_country=None):
        from film20.recommendations import engine
        is_filtered = tags or year_from or year_to or related_director or related_actor or popularity or netflix

        if exclude_production_country:
            kw = dict(exclude_production_country=exclude_production_country)
        else:
            kw = {}
        all_scores = engine.compute_guess_score_for_all_films(user, **kw)
        all_scores = dict((key, val) for key, val in all_scores.items() if val)
        ratings = Rating.get_user_ratings(user)
        shitlisted = set(k for k, v in BasketItem.user_basket(user).items()
                         if v[0] == 9)

        film_ids = set(all_scores.keys())
        film_ids.difference_update(ratings.keys())
        film_ids.difference_update(shitlisted)

        if is_filtered:
            filtered = self._filter_films(tags, year_from, year_to,
                                          related_director, related_actor,
                                          popularity, netflix)
            filtered = filtered.filter(id__in=film_ids)
            film_ids = filtered.values_list('id', flat=True)

        if include_features:
            from film20.film_features.models import FilmFeature
            featured_ids = FilmFeature.matching_film_ids(
                include_features, exclude_features)
            film_ids = [id for id in film_ids if id in featured_ids]

        film_ids = sorted(film_ids, key=lambda f: -all_scores[f])

        from film20.utils.misc import ListWrapper

        class FilmWrapper(ListWrapper):
            def wrap(self, items):
                films = list(Film.objects.filter(id__in=items))
                films.sort(key=lambda f: -all_scores[f.id])
                for film in films:
                    film.guess_rating = all_scores.get(film.id)
                    yield film

        return FilmWrapper(film_ids)
Example #8
0
 def progress(self):
     contest = getattr(self.request, 'contest', False)
     if contest:
         return Progress(
                 0,
                 settings.FBAPP['config'].get('movies_to_rate_for_progress', 6)
         )
     return Progress(
             Rating.count_for_user(self.user),
             settings.RECOMMENDATIONS_MIN_VOTES_USER
     )
Example #9
0
def count_guessed_rate(user, film):
    ratings = Rating.get_user_ratings(user)
    logger.info("counting guessed rate for film %d", film.id)

    if len(ratings) < MIN_USER_RATES:
        return None

    average_rate, average_weight = AVERAGE_RATE, AVERAGE_WEIGHT

    film_weight = 0.0
    film_rate = film.average_score() or 0.0
    film_rate = float(film_rate)

    if film_rate:
        film_weight = FILM_WEIGHT * pow(float(film.number_of_votes() / FILM_RELIABILITY_BAR), 0.3)

    user_rate = sum(ratings.values()) / len(ratings)
    user_weight = USER_WEIGHT * (len(ratings) / USER_RELIABILITY_BAR) ** 0.3

    #    film_ids = ratings.keys()
    #    scores = dict(FilmComparator.objects.filter(
    #            main_film=film, compared_film__id__in=film_ids).\
    #            values_list('compared_film', 'score'))

    key = cache.Key("compared_films", film.id)
    scores = cache.get(key)
    if scores is None:
        query = FilmComparator.objects.filter(main_film=film).values_list("compared_film", "score")
        scores = dict((f, float(s)) for (f, s) in query)
        cache.set(key, scores)

    sum_weights = 0.0
    sum_rate = 0.0
    for film_id, rating in ratings.items():
        if film_id in scores:
            weight = float(scores[film_id])
            sum_weights += weight
            sum_rate += float(rating) * weight

    sum_rate += film_weight * film_rate + user_weight * user_rate
    sum_rate += average_weight * average_rate
    sum_weights += film_weight + user_weight + average_weight
    recommendation = None
    if sum_weights > 0.0 and sum_rate >= 0.0:
        score = Decimal(str(sum_rate / sum_weights))
        if score <= 10:
            recommendation, created = Recommendation.objects.get_or_create(
                user=user, film=film, defaults=dict(guess_rating_alg2=score)
            )
            if not created:
                recommendation.guess_rating_alg2 = score
                recommendation.save()
    # transaction.commit()
    return recommendation
Example #10
0
def rating_progress(context, user):
    vote_cnt = user.is_authenticated() and Rating.count_for_user(user) or 0
    MIN_VOTES = settings.RECOMMENDATIONS_MIN_VOTES_USER

    count = min(vote_cnt, MIN_VOTES)
    left = MIN_VOTES - count
    percent = int(round(count * 100.0 / MIN_VOTES))
    
    return {
        'count':count,
        'left':left,
        'percent':percent,
    }
Example #11
0
    def next_film_to_vote( self, user, exclude=[], all_movies=False, tag=None ):
        
        voted = [ ff.film.pk for ff in FilmFeatureVote.objects.filter( user=user ) ]
        if all_movies:
            films = Film.objects.all()
        else:
            rated = Rating.get_user_ratings( user )
            films = Film.objects.filter( pk__in=rated )

        if tag:
            films = films.tagged( tag )

        films = films.exclude( pk__in=voted + exclude ).order_by( '?' )
        return films[0] if len( films ) else None
Example #12
0
    def initialize(self):
        self.clean_data()

        # set up users
        self.u1= User.objects.create_user('michuk', '*****@*****.**', 'secret')
        self.u1.save()

        # set up film
        self.film = Film()
        self.film.title = "Battlefield Earth II"
        self.film.type = Object.TYPE_FILM
        self.film.permalink = "battlefirld-earth-ii"
        self.film.release_year = 2010
        self.film.save()

        # set up rating
        self.rating = Rating()
        self.rating.parent = self.film
        self.rating.user = self.u1
        self.rating.film = self.film
        self.rating.type = Rating.TYPE_FILM
        self.rating.rating = 8
        self.rating.normalized = 8
        self.rating.save()
Example #13
0
    def next_to_vote( self, user ):
        items = self.get_query_set().filter( user=user, status=FilmFeatureComparisionVote.STATUS_UNKNOWN )
        if len( items ):
            return items[0]
        
        rated_films = Film.objects.filter( pk__in=Rating.get_user_ratings( user ) )

        similar_films = SimilarFilm.objects.filter( film_a__in=rated_films, film_b__in=rated_films ).values_list( 'film_a', 'film_b' ).order_by( '?' )
        films_with_features = itertools.combinations( set( FilmFeature.objects.filter( film__in=rated_films ).values_list( 'film', flat=True ).order_by( '?' ) ), 2 )
        
        films = [similar_films, films_with_features]
        random.shuffle( films )

        for f in films:
            next_to_rate = self._find_next_to_rate( user, f )
            if next_to_rate:
                return next_to_rate
Example #14
0
    def get_best_psi_films_queryset(self, user, tags=None, year_from=None, year_to = None, related_director = None, related_actor = None, popularity = None, include_features=(), exclude_features=(), netflix=None, exclude_production_country=None):
        from film20.recommendations import engine
        is_filtered = tags or year_from or year_to or related_director or related_actor or popularity or netflix
        
        if exclude_production_country:
            kw = dict(exclude_production_country=exclude_production_country)
        else:
            kw = {}
        all_scores = engine.compute_guess_score_for_all_films(user, **kw)
        all_scores = dict((key, val) for key, val in all_scores.items() if val)
        ratings = Rating.get_user_ratings(user)
        shitlisted = set(k for k,v in BasketItem.user_basket(user).items() if v[0]==9)

        film_ids = set(all_scores.keys())
        film_ids.difference_update(ratings.keys())
        film_ids.difference_update(shitlisted)

        if is_filtered:
            filtered = self._filter_films(tags, year_from, year_to, related_director, related_actor, popularity, netflix)
            filtered = filtered.filter(id__in=film_ids)
            film_ids = filtered.values_list('id', flat=True)

        if include_features:
            from film20.film_features.models import FilmFeature
            featured_ids = FilmFeature.matching_film_ids(include_features, exclude_features)
            film_ids = [id for id in film_ids if id in featured_ids]

        film_ids = sorted(film_ids, key=lambda f: -all_scores[f])
        
        from film20.utils.misc import ListWrapper
        class FilmWrapper(ListWrapper):
            def wrap(self, items):
                films = list(Film.objects.filter(id__in=items))
                films.sort(key=lambda f:-all_scores[f.id])
                for film in films:
                    film.guess_rating = all_scores.get(film.id)
                    yield film
        return FilmWrapper(film_ids)
Example #15
0
    def __init__(self, data, request, film, initial=None):
        initial = initial or {}
        self.film = film
        self.user = request.unique_user
        initial['film_id'] = film.id

        if not 'rating_1' in initial:
            ratings = Rating.get_user_ratings(self.user)
            r = ratings.get(self.film.id)
            if r:
                initial['rating_1'] = r
        
        if self.user.is_authenticated():
            # collections only for registered users
            basket = BasketItem.user_basket(self.user)
            item = basket.get(film.id)
            if item:
                initial['dying_for'] = item[0] == BasketItem.DYING_FOR
                initial['not_interested'] = item[0] == BasketItem.NOT_INTERESTED
                initial['owned'] = item[1] == BasketItem.OWNED

        prefix = "flm-%d" % film.id
        super(forms.Form, self).__init__(data, initial=initial, prefix=prefix)
Example #16
0
 def __init__(self, data, user=None, film=None, mark_as_seen=False, initial=None):
     initial = initial or {}
     self.film = film
     self.user = user
     if user and user.is_authenticated():
         if not 'rating_1' in initial:
             ratings = Rating.get_user_ratings(user)
             r = ratings.get(self.film.id)
             if r:
                 initial['rating_1'] = r
         
         basket = BasketItem.user_basket(user)
         item = basket.get(film.id)
         if item:
             initial['dying_for'] = item[0] == BasketItem.DYING_FOR
             initial['not_interested'] = item[0] == BasketItem.NOT_INTERESTED
             initial['owned'] = item[1] == BasketItem.OWNED
         
         if mark_as_seen:
             film.mark_as_seen(user)
     
     prefix = "flm-%d" % film.id
     super(forms.Form, self).__init__(data, initial=initial, prefix=prefix)
Example #17
0
    def initialize(self):
        self.clean_data()

        # set up users
        self.u1= User.objects.create_user('michuk', '*****@*****.**', 'secret')
        self.u1.save()

        # set up film
        self.film = Film()
        self.film.title = "Battlefield Earth II"
        self.film.type = Object.TYPE_FILM
        self.film.permalink = "battlefirld-earth-ii"
        self.film.release_year = 2010
        self.film.save()

        # set up rating
        self.rating = Rating()
        self.rating.parent = self.film
        self.rating.user = self.u1
        self.rating.film = self.film
        self.rating.type = Rating.TYPE_FILM
        self.rating.rating = 8
        self.rating.normalized = 8
        self.rating.save()
Example #18
0
    def __init__(self, data, request, film, initial=None):
        initial = initial or {}
        self.film = film
        self.user = request.unique_user
        initial['film_id'] = film.id

        if not 'rating_1' in initial:
            ratings = Rating.get_user_ratings(self.user)
            r = ratings.get(self.film.id)
            if r:
                initial['rating_1'] = r

        if self.user.is_authenticated():
            # collections only for registered users
            basket = BasketItem.user_basket(self.user)
            item = basket.get(film.id)
            if item:
                initial['dying_for'] = item[0] == BasketItem.DYING_FOR
                initial['not_interested'] = item[
                    0] == BasketItem.NOT_INTERESTED
                initial['owned'] = item[1] == BasketItem.OWNED

        prefix = "flm-%d" % film.id
        super(forms.Form, self).__init__(data, initial=initial, prefix=prefix)
Example #19
0
    def initialize(self):
        self.clean_data()

        tags = "sciencie-fiction comedy"

        # set up test user
        self.user1 = User.objects.create_user("user1", "*****@*****.**",
                                              "secret")
        self.user1.save()

        # set up films
        self.film1 = Film()
        self.film1.title = "Battlefield Earth II"
        self.film1.type = Object.TYPE_FILM
        self.film1.permalink = "battlefirld-earth-ii"
        self.film1.release_year = 2010
        self.film1.production_country_list = "USA"
        self.film1.save()
        self.film1.save_tags(tags, LANG="pl", saved_by=2)

        self.film2 = Film()
        self.film2.title = "Battlefield Earth III"
        self.film2.type = Object.TYPE_FILM
        self.film2.permalink = "battlefirld-earth-iii"
        self.film2.release_year = 2011
        self.film2.production_country_list = "USA"
        self.film2.save()
        self.film2.save_tags(tags, LANG="pl", saved_by=2)

        self.film3 = Film()
        self.film3.title = "Battlefield Earth IV"
        self.film3.type = Object.TYPE_FILM
        self.film3.permalink = "battlefirld-earth-iv"
        self.film3.release_year = 2012
        self.film3.production_country_list = "Italy"
        self.film3.save()
        self.film3.save_tags(tags, LANG="pl", saved_by=2)

        self.film4 = Film()
        self.film4.title = "Battlefield Earth V"
        self.film4.type = Object.TYPE_FILM
        self.film4.permalink = "battlefirld-earth-v"
        self.film4.release_year = 2013
        self.film4.production_country_list = "UK"
        self.film4.save()
        self.film4.save_tags(tags, LANG="pl", saved_by=2)

        # set up filmrankings
        self.filmranking1 = FilmRanking()
        self.filmranking1.film = self.film1
        self.filmranking1.type = Rating.TYPE_FILM
        self.filmranking1.average_score = Decimal('8.0')
        self.filmranking1.number_of_votes = 80
        self.filmranking1.save()

        self.filmranking2 = FilmRanking()
        self.filmranking2.film = self.film2
        self.filmranking2.type = Rating.TYPE_FILM
        self.filmranking2.average_score = Decimal('7.0')
        self.filmranking2.number_of_votes = 70
        self.filmranking2.save()

        self.filmranking3 = FilmRanking()
        self.filmranking3.film = self.film3
        self.filmranking3.type = Rating.TYPE_FILM
        self.filmranking3.average_score = Decimal('6.0')
        self.filmranking3.number_of_votes = 60
        self.filmranking3.save()

        self.filmranking4 = FilmRanking()
        self.filmranking4.film = self.film4
        self.filmranking4.type = Rating.TYPE_FILM
        self.filmranking4.average_score = Decimal('5.0')
        self.filmranking4.number_of_votes = 2
        self.filmranking4.save()

        # save compared objects in database
        self.compared_film1 = FilmComparator()
        self.compared_film1.main_film = self.film1
        self.compared_film1.compared_film = self.film1
        self.compared_film1.score = 10
        self.compared_film1.save()

        self.compared_film2 = FilmComparator()
        self.compared_film2.main_film = self.film1
        self.compared_film2.compared_film = self.film2
        self.compared_film2.score = 9
        self.compared_film2.save()

        self.compared_film3 = FilmComparator()
        self.compared_film3.main_film = self.film1
        self.compared_film3.compared_film = self.film3
        self.compared_film3.score = 8
        self.compared_film3.save()

        self.compared_film4 = FilmComparator()
        self.compared_film4.main_film = self.film1
        self.compared_film4.compared_film = self.film4
        self.compared_film4.score = 7
        self.compared_film4.save()

        # set up test user ratings
        self.user1rating1 = Rating()
        self.user1rating1.type = Rating.TYPE_FILM
        self.user1rating1.user = self.user1
        self.user1rating1.parent = self.film1
        self.user1rating1.rating = 10
        self.user1rating1.save()

        self.user1rating2 = Rating()
        self.user1rating2.type = Rating.TYPE_FILM
        self.user1rating2.user = self.user1
        self.user1rating2.parent = self.film2
        self.user1rating2.rating = 9
        self.user1rating2.save()

        self.user1rating3 = Rating()
        self.user1rating3.type = Rating.TYPE_FILM
        self.user1rating3.user = self.user1
        self.user1rating3.parent = self.film3
        self.user1rating3.rating = 8
        self.user1rating3.save()

        self.user1rating4 = Rating()
        self.user1rating4.type = Rating.TYPE_FILM
        self.user1rating4.user = self.user1
        self.user1rating4.parent = self.film4
        self.user1rating4.rating = 7
        self.user1rating4.save()
Example #20
0
class FilmHelperTestCase(TestCase):
    def initialize(self):
        self.clean_data()

        tags = "sciencie-fiction comedy"

        # set up test user
        self.user1 = User.objects.create_user("user1", "*****@*****.**",
                                              "secret")
        self.user1.save()

        # set up films
        self.film1 = Film()
        self.film1.title = "Battlefield Earth II"
        self.film1.type = Object.TYPE_FILM
        self.film1.permalink = "battlefirld-earth-ii"
        self.film1.release_year = 2010
        self.film1.production_country_list = "USA"
        self.film1.save()
        self.film1.save_tags(tags, LANG="pl", saved_by=2)

        self.film2 = Film()
        self.film2.title = "Battlefield Earth III"
        self.film2.type = Object.TYPE_FILM
        self.film2.permalink = "battlefirld-earth-iii"
        self.film2.release_year = 2011
        self.film2.production_country_list = "USA"
        self.film2.save()
        self.film2.save_tags(tags, LANG="pl", saved_by=2)

        self.film3 = Film()
        self.film3.title = "Battlefield Earth IV"
        self.film3.type = Object.TYPE_FILM
        self.film3.permalink = "battlefirld-earth-iv"
        self.film3.release_year = 2012
        self.film3.production_country_list = "Italy"
        self.film3.save()
        self.film3.save_tags(tags, LANG="pl", saved_by=2)

        self.film4 = Film()
        self.film4.title = "Battlefield Earth V"
        self.film4.type = Object.TYPE_FILM
        self.film4.permalink = "battlefirld-earth-v"
        self.film4.release_year = 2013
        self.film4.production_country_list = "UK"
        self.film4.save()
        self.film4.save_tags(tags, LANG="pl", saved_by=2)

        # set up filmrankings
        self.filmranking1 = FilmRanking()
        self.filmranking1.film = self.film1
        self.filmranking1.type = Rating.TYPE_FILM
        self.filmranking1.average_score = Decimal('8.0')
        self.filmranking1.number_of_votes = 80
        self.filmranking1.save()

        self.filmranking2 = FilmRanking()
        self.filmranking2.film = self.film2
        self.filmranking2.type = Rating.TYPE_FILM
        self.filmranking2.average_score = Decimal('7.0')
        self.filmranking2.number_of_votes = 70
        self.filmranking2.save()

        self.filmranking3 = FilmRanking()
        self.filmranking3.film = self.film3
        self.filmranking3.type = Rating.TYPE_FILM
        self.filmranking3.average_score = Decimal('6.0')
        self.filmranking3.number_of_votes = 60
        self.filmranking3.save()

        self.filmranking4 = FilmRanking()
        self.filmranking4.film = self.film4
        self.filmranking4.type = Rating.TYPE_FILM
        self.filmranking4.average_score = Decimal('5.0')
        self.filmranking4.number_of_votes = 2
        self.filmranking4.save()

        # save compared objects in database
        self.compared_film1 = FilmComparator()
        self.compared_film1.main_film = self.film1
        self.compared_film1.compared_film = self.film1
        self.compared_film1.score = 10
        self.compared_film1.save()

        self.compared_film2 = FilmComparator()
        self.compared_film2.main_film = self.film1
        self.compared_film2.compared_film = self.film2
        self.compared_film2.score = 9
        self.compared_film2.save()

        self.compared_film3 = FilmComparator()
        self.compared_film3.main_film = self.film1
        self.compared_film3.compared_film = self.film3
        self.compared_film3.score = 8
        self.compared_film3.save()

        self.compared_film4 = FilmComparator()
        self.compared_film4.main_film = self.film1
        self.compared_film4.compared_film = self.film4
        self.compared_film4.score = 7
        self.compared_film4.save()

        # set up test user ratings
        self.user1rating1 = Rating()
        self.user1rating1.type = Rating.TYPE_FILM
        self.user1rating1.user = self.user1
        self.user1rating1.parent = self.film1
        self.user1rating1.rating = 10
        self.user1rating1.save()

        self.user1rating2 = Rating()
        self.user1rating2.type = Rating.TYPE_FILM
        self.user1rating2.user = self.user1
        self.user1rating2.parent = self.film2
        self.user1rating2.rating = 9
        self.user1rating2.save()

        self.user1rating3 = Rating()
        self.user1rating3.type = Rating.TYPE_FILM
        self.user1rating3.user = self.user1
        self.user1rating3.parent = self.film3
        self.user1rating3.rating = 8
        self.user1rating3.save()

        self.user1rating4 = Rating()
        self.user1rating4.type = Rating.TYPE_FILM
        self.user1rating4.user = self.user1
        self.user1rating4.parent = self.film4
        self.user1rating4.rating = 7
        self.user1rating4.save()

    def clean_data(self):
        Film.objects.all().delete()
        FilmComparator.objects.all().delete()
        FilmRanking.objects.all().delete()

    def test_get_users_best_films(self):
        """
            Test get_users_best_films method
        """

        self.initialize()
        helper = FilmHelper()
        best_films = helper.get_users_best_films(self.user1, 3)
        self.assertEquals(len(best_films), 3)
        self.assertEquals(self.film4 in best_films, False)
        self.assertEquals(self.film1 in best_films, True)

    def test_get_related_localized_objects(self):
        """
            Test get_related_localized_objects() method 
        """

        self.initialize()
        helper = FilmHelper()
        related = helper.get_related_localized_objects(self.film1, 3)
        self.assertEquals(len(related), 3)

    def test_get_popular_films(self):
        """
            Test get_popular_films method
        """

        self.initialize()
        helper = FilmHelper()

        films_english = set(helper.get_popular_films(exclude_nonEnglish=True))
        self.assertEquals(self.film1 in films_english, True)
        self.assertEquals(self.film3 in films_english, False)
        self.assertEquals(self.film4 in films_english, False)

        films_english = set(helper.get_popular_films())
        self.assertEquals(self.film1 in films_english, True)
        self.assertEquals(self.film3 in films_english, True)
Example #21
0
class ShortReviewTestCase(TestCase):

    def initialize(self):
        self.clean_data()

        # set up users
        self.u1= User.objects.create_user('michuk', '*****@*****.**', 'secret')
        self.u1.save()

        # set up film
        self.film = Film()
        self.film.title = "Battlefield Earth II"
        self.film.type = Object.TYPE_FILM
        self.film.permalink = "battlefirld-earth-ii"
        self.film.release_year = 2010
        self.film.save()

        # set up rating
        self.rating = Rating()
        self.rating.parent = self.film
        self.rating.user = self.u1
        self.rating.film = self.film
        self.rating.type = Rating.TYPE_FILM
        self.rating.rating = 8
        self.rating.normalized = 8
        self.rating.save()


    def clean_data(self):
        User.objects.all().delete()
        Post.objects.all().delete()
        ShortReview.objects.all().delete()


    def test_saving_single_shortreview(self):
        """
           Test saving single shortreview
        """

        self.initialize()

        # set up Shortreview
        obj = Object.objects.get(id=self.film.id)
        shortreview = ShortReview()
        shortreview.user = self.u1
        shortreview.review_text = "sialala bumcyk cyk"
        shortreview.status = Object.PUBLIC_STATUS
        shortreview.type = Object.TYPE_SHORT_REVIEW
        shortreview.kind = ShortReview.REVIEW
        shortreview.object = obj
        shortreview.rating = self.rating
        shortreview.save()

        # testing if shortreview was saved
        sr = ShortReview.objects.get(object=obj)
        
        self.failUnlessEqual(sr.user, shortreview.user)
        self.failUnlessEqual(sr.review_text, "sialala bumcyk cyk")
        self.failUnlessEqual(sr.status, Object.PUBLIC_STATUS)
        self.failUnlessEqual(sr.type, Object.TYPE_SHORT_REVIEW)
        self.failUnlessEqual(sr.kind, ShortReview.REVIEW)
        self.failUnlessEqual(sr.rating.rating, 8)
        self.failUnlessEqual(sr.object, obj)


    def test_delete_single_shortreview(self):
        """
            Test deleting single shortreview
        """

        self.initialize()

        # set up Shortreview
        obj = Object.objects.get(id=self.film.id)
        shortreview = ShortReview()
        shortreview.user = self.u1
        shortreview.review_text = "sialala bumcyk cyk"
        shortreview.status = Object.PUBLIC_STATUS
        shortreview.type = Object.TYPE_SHORT_REVIEW
        shortreview.kind = ShortReview.REVIEW
        shortreview.object = obj
        shortreview.save()

        # there should be one short review
        self.failUnlessEqual(ShortReview.objects.all().count(), 1)

        sr = ShortReview.objects.get(object=obj)

        # deleting shortreview
        sr.delete()

        # there should be zero short reviews
        self.failUnlessEqual(ShortReview.objects.all().count(), 0)


    def test_edit_single_shortreview(self):
        """
            Test editing single shortreview
        """

        self.initialize()

        # set up Shortreview
        obj = Object.objects.get(id=self.film.id)
        shortreview = ShortReview()
        shortreview.user = self.u1
        shortreview.review_text = "sialala bumcyk cyk"
        shortreview.status = Object.PUBLIC_STATUS
        shortreview.type = Object.TYPE_SHORT_REVIEW
        shortreview.kind = ShortReview.REVIEW
        shortreview.object = obj
        shortreview.save()
        shortreview.rating.rating = 10
        shortreview.rating.save()

        # testing if shortreview was saved
        sr = ShortReview.objects.get(object=obj)

        self.failUnlessEqual(sr.review_text, "sialala bumcyk cyk")

        sr.review_text = "Lorem ipsum"
        sr.save()

        # testing if short review was edited successfully
        sr = ShortReview.objects.get(object=obj)
        self.failUnlessEqual(sr.review_text, "Lorem ipsum")
        self.failUnlessEqual(sr.rating.rating, 10)


    def test_saving_double_shortreviews(self):
        """
           Test saving two shortreviews about the same movie by the same user
        """

        self.initialize()

        # set up Shortreviews
        obj = Object.objects.get(id=self.film.id)
        shortreview1 = ShortReview()
        shortreview1.user = self.u1
        shortreview1.review_text = "sialala bumcyk cyk"
        shortreview1.status = Object.PUBLIC_STATUS
        shortreview1.type = Object.TYPE_SHORT_REVIEW
        shortreview1.kind = ShortReview.REVIEW
        shortreview1.object = obj
        shortreview1.rating = self.rating
        shortreview1.save()

        obj = Object.objects.get(id=self.film.id)
        shortreview2 = ShortReview()
        shortreview2.user = self.u1
        shortreview2.review_text = "Lorem ipsum lorem ipsum"
        shortreview2.status = Object.PUBLIC_STATUS
        shortreview2.type = Object.TYPE_SHORT_REVIEW
        shortreview2.kind = ShortReview.REVIEW
        shortreview2.object = obj
        shortreview2.rating = self.rating
        shortreview2.save()


        # testing if shortreview was saved
        sr = ShortReview.objects.filter(object=obj).order_by("created_at")

        self.failUnlessEqual(sr[0].user, shortreview1.user)
        self.failUnlessEqual(sr[0].review_text, "sialala bumcyk cyk")
        self.failUnlessEqual(sr[0].status, Object.PUBLIC_STATUS)
        self.failUnlessEqual(sr[0].type, Object.TYPE_SHORT_REVIEW)
        self.failUnlessEqual(sr[0].kind, ShortReview.REVIEW)
        self.failUnlessEqual(sr[0].rating.rating, 8)
        self.failUnlessEqual(sr[0].object, obj)

        self.failUnlessEqual(sr[1].user, shortreview1.user)
        self.failUnlessEqual(sr[1].review_text, "Lorem ipsum lorem ipsum")
        self.failUnlessEqual(sr[1].status, Object.PUBLIC_STATUS)
        self.failUnlessEqual(sr[1].type, Object.TYPE_SHORT_REVIEW)
        self.failUnlessEqual(sr[1].kind, ShortReview.REVIEW)
        self.failUnlessEqual(sr[1].rating.rating, 8)
        self.failUnlessEqual(sr[1].object, obj)


    def test_saving_wall_post(self):
        """
            Test saving wall post
        """

        self.initialize()

        wallpost = ShortReview()
        wallpost.user = self.u1
        wallpost.review_text = "sialala bumcyk cyk"
        wallpost.status = Object.PUBLIC_STATUS
        wallpost.kind = ShortReview.WALLPOST
        wallpost.type = Object.TYPE_SHORT_REVIEW
        wallpost.save()

        permalink = 'http://%s.%s/%s/%s/' % (self.u1.username, settings.DOMAIN, urls['WALL'], wallpost.id)
        wp = ShortReview.objects.all()[0]

        self.failUnlessEqual(wp.get_absolute_url(), permalink)
        self.failUnlessEqual(wp.user, wallpost.user)
        self.failUnlessEqual(wp.review_text, "sialala bumcyk cyk")
        self.failUnlessEqual(wp.status, Object.PUBLIC_STATUS)
        self.failUnlessEqual(wp.type, Object.TYPE_SHORT_REVIEW)
Example #22
0
    def initialize(self):
        self.clean_data()

        # set up users
        self.u1= User.objects.create_user('michuk', '*****@*****.**', 'secret')
        self.u1.save()
        self.u2 = User(username='******', email='*****@*****.**')
        self.u2.save()
        self.u3 = User(username='******', email='*****@*****.**')
        self.u3.save()
        self.u4 = User(username='******', email='*****@*****.**')
        self.u4.save()

        # set up film
        self.film = Film()
        self.film.title = "Battlefield Earth II"
        self.film.type = Object.TYPE_FILM
        self.film.permalink = "battlefirld-earth-ii"
        self.film.release_year = 2010
        self.film.save()
        self.film.save_tags('comedy')

        self.film1 = Film()
        self.film1.title = "Battlefield Earth III"
        self.film1.type = Object.TYPE_FILM
        self.film1.permalink = "battlefirld-earth-iii"
        self.film1.release_year = 2010
        self.film1.save()
        self.film1.save_tags('sci-fi')

        self.film2 = Film()
        self.film2.title = "Battlefield Earth IV"
        self.film2.type = Object.TYPE_FILM
        self.film2.permalink = "battlefirld-earth-iv"
        self.film2.release_year = 2010
        self.film2.save()
        self.film2.save_tags('horror')

        self.rating = Rating()
        self.rating.parent = self.film
        self.rating.user = self.u1
        self.rating.film = self.film
        self.rating.type = Rating.TYPE_FILM
        self.rating.rating = 8
        self.rating.normalized = 8
        self.rating.save()

        self.rating1 = Rating()
        self.rating1.parent = self.film1
        self.rating1.user = self.u1
        self.rating1.film = self.film1
        self.rating1.type = Rating.TYPE_FILM
        self.rating1.rating = 8
        self.rating1.normalized = 8
        self.rating1.save()

        self.rating2 = Rating()
        self.rating2.parent = self.film2
        self.rating2.user = self.u1
        self.rating2.film = self.film2
        self.rating2.type = Rating.TYPE_FILM
        self.rating2.rating = 8
        self.rating2.normalized = 8
        self.rating2.save()
Example #23
0
    def save(self, *args, **kw):
        email_confirmed = False
        username = self.cleaned_data["username"]
        email = self.cleaned_data.get("email") or ""
        password = self.cleaned_data.get("password1")

        tmp_username = self._tmp_username()
        if not tmp_username and self.request and self.request.unique_user.id:
            tmp_username = self.request.unique_user.username

        if tmp_username:
            match = re.match("(\w{3})-[0-9a-f]{20,26}$", tmp_username)
            match = match or re.match("(fb)-\d+", tmp_username)
            assert match
            # rename anonymouse user
            user = User.objects.get(username=tmp_username, is_active=False)
            user.is_active = True
            user.username = username
            user.email = email

            if password:
                user.set_password(password)
            user.save()

            profile = user.get_profile()
            profile.user = user
            profile.registration_source = match.group(1)

            profile.save()
            # update username in activities
            for activity in UserActivity.objects.filter(user=user):
                activity.username = user.username
                activity.save()

            if (
                settings.RECOMMENDATIONS_ENGINE == "film20.new_recommendations.recommendations_engine"
                and Rating.get_user_ratings(user) > settings.RECOMMENDATIONS_MIN_VOTES_USER
            ):
                # recompute recommendations
                from film20.recommendations import engine

                engine.compute_user_features(user, True)

            ec = self.get_email_confirmation()
            if ec and ec.email_address.email == email:
                EmailConfirmation.objects.confirm_email(self.request.GET.get("confirmation_key"))
                email_confirmed = True

        else:
            # User.objects.create_user(username, email, **extra)
            user, created = User.objects.get_or_create(username=username, defaults={"email": email})
            if created:
                if password:
                    user.set_password(password)
                    user.save()
            else:
                # user already exists, probably double form submission
                return user

        if email and not email_confirmed:
            add_email(user, email)

        defaults = {}
        if self.request and self.request.geo:
            latitude = self.request.geo.get("latitude")
            longitude = self.request.geo.get("longitude")
            country_code = self.request.geo.get("country_code")
            timezone = self.request.geo.get("timezone")

            if latitude and longitude:
                defaults["latitude"] = str(latitude)
                defaults["longitude"] = str(longitude)

            defaults["country"] = country_code
            defaults["timezone_id"] = timezone

        profile, created = Profile.objects.get_or_create(user=user, defaults=defaults)
        if not created:
            profile.__dict__.update(defaults)
            profile.save()

        from film20.notification import models as notification
        from film20.notification.models import NoticeType

        inform_friends = self.cleaned_data.get("inform_friends")
        if not inform_friends:
            # disable all USER_ACTIVITY notifications
            notice_types = NoticeType.objects.filter(type=NoticeType.TYPE_USER_ACTIVITY)
            for notice_type in notice_types:
                for medium in notification.NOTICE_MEDIA:
                    if medium.supports(notice_type):
                        medium.update_notification_setting(user, notice_type, False)

        if self.request.is_mobile:
            names = dict((v, k) for k, v in settings.USER_AGENTS)
            platform_name = names.get(self.request.platform, "")
            link = reverse("mobile_app")
            picture = None
        else:
            platform_name = ""
            link = reverse("main_page")
            picture = "/static/layout/logo.png"

        notification.send(
            [user],
            "useractivity_just_joined",
            {
                "user": user,
                "is_mobile": self.request.is_mobile,
                "platform": self.request.platform,
                "platform_name": platform_name,
                "link": link,
                "picture": picture,
            },
            delay=30,
        )

        return user
Example #24
0
class FilmHelperTestCase(TestCase):

    def initialize(self):
        self.clean_data()

        tags = "sciencie-fiction comedy"

        # set up test user
        self.user1 = User.objects.create_user("user1", "*****@*****.**", "secret")
        self.user1.save()


        # set up films
        self.film1 = Film()
        self.film1.title = "Battlefield Earth II"
        self.film1.type = Object.TYPE_FILM
        self.film1.permalink = "battlefirld-earth-ii"
        self.film1.release_year = 2010
        self.film1.production_country_list = "USA"
        self.film1.save()
        self.film1.save_tags(tags, LANG="pl", saved_by=2)

        self.film2 = Film()
        self.film2.title = "Battlefield Earth III"
        self.film2.type = Object.TYPE_FILM
        self.film2.permalink = "battlefirld-earth-iii"
        self.film2.release_year = 2011
        self.film2.production_country_list = "USA"
        self.film2.save()
        self.film2.save_tags(tags, LANG="pl", saved_by=2)

        self.film3 = Film()
        self.film3.title = "Battlefield Earth IV"
        self.film3.type = Object.TYPE_FILM
        self.film3.permalink = "battlefirld-earth-iv"
        self.film3.release_year = 2012
        self.film3.production_country_list = "Italy"
        self.film3.save()
        self.film3.save_tags(tags, LANG="pl", saved_by=2)

        self.film4 = Film()
        self.film4.title = "Battlefield Earth V"
        self.film4.type = Object.TYPE_FILM
        self.film4.permalink = "battlefirld-earth-v"
        self.film4.release_year = 2013
        self.film4.production_country_list = "UK"
        self.film4.save()
        self.film4.save_tags(tags, LANG="pl", saved_by=2)

        # set up filmrankings
        self.filmranking1 = FilmRanking()
        self.filmranking1.film = self.film1
        self.filmranking1.type = Rating.TYPE_FILM
        self.filmranking1.average_score = Decimal('8.0')
        self.filmranking1.number_of_votes = 80
        self.filmranking1.save()
        
        self.filmranking2 = FilmRanking()
        self.filmranking2.film = self.film2
        self.filmranking2.type = Rating.TYPE_FILM
        self.filmranking2.average_score = Decimal('7.0')
        self.filmranking2.number_of_votes = 70
        self.filmranking2.save()

        self.filmranking3 = FilmRanking()
        self.filmranking3.film = self.film3
        self.filmranking3.type = Rating.TYPE_FILM
        self.filmranking3.average_score = Decimal('6.0')
        self.filmranking3.number_of_votes = 60
        self.filmranking3.save()

        self.filmranking4 = FilmRanking()
        self.filmranking4.film = self.film4
        self.filmranking4.type = Rating.TYPE_FILM
        self.filmranking4.average_score = Decimal('5.0')
        self.filmranking4.number_of_votes = 2
        self.filmranking4.save()

        # save compared objects in database
        self.compared_film1 = FilmComparator()
        self.compared_film1.main_film = self.film1
        self.compared_film1.compared_film = self.film1
        self.compared_film1.score = 10
        self.compared_film1.save()

        self.compared_film2 = FilmComparator()
        self.compared_film2.main_film = self.film1
        self.compared_film2.compared_film = self.film2
        self.compared_film2.score = 9
        self.compared_film2.save()

        self.compared_film3 = FilmComparator()
        self.compared_film3.main_film = self.film1
        self.compared_film3.compared_film = self.film3
        self.compared_film3.score = 8
        self.compared_film3.save()

        self.compared_film4 = FilmComparator()
        self.compared_film4.main_film = self.film1
        self.compared_film4.compared_film = self.film4
        self.compared_film4.score = 7
        self.compared_film4.save()

        # set up test user ratings
        self.user1rating1 = Rating()
        self.user1rating1.type = Rating.TYPE_FILM
        self.user1rating1.user = self.user1
        self.user1rating1.film = self.film1
        self.user1rating1.parent = self.film1
        self.user1rating1.rating = 10
        self.user1rating1.save()

        self.user1rating2 = Rating()
        self.user1rating2.type = Rating.TYPE_FILM
        self.user1rating2.user = self.user1
        self.user1rating2.film = self.film2
        self.user1rating2.parent = self.film2
        self.user1rating2.rating = 9
        self.user1rating2.save()

        self.user1rating3 = Rating()
        self.user1rating3.type = Rating.TYPE_FILM
        self.user1rating3.user = self.user1
        self.user1rating3.film = self.film3
        self.user1rating3.parent = self.film3
        self.user1rating3.rating = 8
        self.user1rating3.save()

        self.user1rating4 = Rating()
        self.user1rating4.type = Rating.TYPE_FILM
        self.user1rating4.user = self.user1
        self.user1rating4.film = self.film4
        self.user1rating4.parent = self.film4
        self.user1rating4.rating = 7
        self.user1rating4.save()

    def clean_data(self):
        Film.objects.all().delete()
        FilmComparator.objects.all().delete()
        FilmRanking.objects.all().delete()

    def test_get_users_best_films(self):
        """
            Test get_users_best_films method
        """

        self.initialize()
        helper = FilmHelper()
        best_films = helper.get_users_best_films(self.user1, 3)
        self.assertEquals(len(best_films), 3)
        self.assertEquals(self.film4 in best_films, False)
        self.assertEquals(self.film1 in best_films, True)

    def test_get_related_localized_objects(self):
        """
            Test get_related_localized_objects() method 
        """

        self.initialize()
        helper = FilmHelper()
        related = helper.get_related_localized_objects(self.film1, 3)
        self.assertEquals(len(related), 3)

    def test_get_popular_films(self):
        """
            Test get_popular_films method
        """

        self.initialize()
        helper = FilmHelper()

        films_english = set(helper.get_popular_films(exclude_nonEnglish=True))
        self.assertEquals(self.film1 in films_english, True)
        self.assertEquals(self.film3 in films_english, False)
        self.assertEquals(self.film4 in films_english, False)

        films_english = set(helper.get_popular_films())
        self.assertEquals(self.film1 in films_english, True)
        self.assertEquals(self.film3 in films_english, True)
Example #25
0
    def initialize(self):
        self.clean_data()

        tags = "sciencie-fiction comedy"

        # set up test user
        self.user1 = User.objects.create_user("user1", "*****@*****.**", "secret")
        self.user1.save()


        # set up films
        self.film1 = Film()
        self.film1.title = "Battlefield Earth II"
        self.film1.type = Object.TYPE_FILM
        self.film1.permalink = "battlefirld-earth-ii"
        self.film1.release_year = 2010
        self.film1.production_country_list = "USA"
        self.film1.save()
        self.film1.save_tags(tags, LANG="pl", saved_by=2)

        self.film2 = Film()
        self.film2.title = "Battlefield Earth III"
        self.film2.type = Object.TYPE_FILM
        self.film2.permalink = "battlefirld-earth-iii"
        self.film2.release_year = 2011
        self.film2.production_country_list = "USA"
        self.film2.save()
        self.film2.save_tags(tags, LANG="pl", saved_by=2)

        self.film3 = Film()
        self.film3.title = "Battlefield Earth IV"
        self.film3.type = Object.TYPE_FILM
        self.film3.permalink = "battlefirld-earth-iv"
        self.film3.release_year = 2012
        self.film3.production_country_list = "Italy"
        self.film3.save()
        self.film3.save_tags(tags, LANG="pl", saved_by=2)

        self.film4 = Film()
        self.film4.title = "Battlefield Earth V"
        self.film4.type = Object.TYPE_FILM
        self.film4.permalink = "battlefirld-earth-v"
        self.film4.release_year = 2013
        self.film4.production_country_list = "UK"
        self.film4.save()
        self.film4.save_tags(tags, LANG="pl", saved_by=2)

        # set up filmrankings
        self.filmranking1 = FilmRanking()
        self.filmranking1.film = self.film1
        self.filmranking1.type = Rating.TYPE_FILM
        self.filmranking1.average_score = Decimal('8.0')
        self.filmranking1.number_of_votes = 80
        self.filmranking1.save()
        
        self.filmranking2 = FilmRanking()
        self.filmranking2.film = self.film2
        self.filmranking2.type = Rating.TYPE_FILM
        self.filmranking2.average_score = Decimal('7.0')
        self.filmranking2.number_of_votes = 70
        self.filmranking2.save()

        self.filmranking3 = FilmRanking()
        self.filmranking3.film = self.film3
        self.filmranking3.type = Rating.TYPE_FILM
        self.filmranking3.average_score = Decimal('6.0')
        self.filmranking3.number_of_votes = 60
        self.filmranking3.save()

        self.filmranking4 = FilmRanking()
        self.filmranking4.film = self.film4
        self.filmranking4.type = Rating.TYPE_FILM
        self.filmranking4.average_score = Decimal('5.0')
        self.filmranking4.number_of_votes = 2
        self.filmranking4.save()

        # save compared objects in database
        self.compared_film1 = FilmComparator()
        self.compared_film1.main_film = self.film1
        self.compared_film1.compared_film = self.film1
        self.compared_film1.score = 10
        self.compared_film1.save()

        self.compared_film2 = FilmComparator()
        self.compared_film2.main_film = self.film1
        self.compared_film2.compared_film = self.film2
        self.compared_film2.score = 9
        self.compared_film2.save()

        self.compared_film3 = FilmComparator()
        self.compared_film3.main_film = self.film1
        self.compared_film3.compared_film = self.film3
        self.compared_film3.score = 8
        self.compared_film3.save()

        self.compared_film4 = FilmComparator()
        self.compared_film4.main_film = self.film1
        self.compared_film4.compared_film = self.film4
        self.compared_film4.score = 7
        self.compared_film4.save()

        # set up test user ratings
        self.user1rating1 = Rating()
        self.user1rating1.type = Rating.TYPE_FILM
        self.user1rating1.user = self.user1
        self.user1rating1.film = self.film1
        self.user1rating1.parent = self.film1
        self.user1rating1.rating = 10
        self.user1rating1.save()

        self.user1rating2 = Rating()
        self.user1rating2.type = Rating.TYPE_FILM
        self.user1rating2.user = self.user1
        self.user1rating2.film = self.film2
        self.user1rating2.parent = self.film2
        self.user1rating2.rating = 9
        self.user1rating2.save()

        self.user1rating3 = Rating()
        self.user1rating3.type = Rating.TYPE_FILM
        self.user1rating3.user = self.user1
        self.user1rating3.film = self.film3
        self.user1rating3.parent = self.film3
        self.user1rating3.rating = 8
        self.user1rating3.save()

        self.user1rating4 = Rating()
        self.user1rating4.type = Rating.TYPE_FILM
        self.user1rating4.user = self.user1
        self.user1rating4.film = self.film4
        self.user1rating4.parent = self.film4
        self.user1rating4.rating = 7
        self.user1rating4.save()
Example #26
0
 def progress(self):
     return Progress(
             Rating.count_for_user(self.user),
             1000
     )
Example #27
0
def get_ratings(film_id=None, actor_id=None, director_id=None, type=1):
    if settings.USE_REDIS:
        return redis_intf.get_ratings(film_id=film_id, actor_id=actor_id, director_id=director_id, type=type)
    return Rating.get_ratings(film_id=film_id, actor_id=actor_id, director_id=director_id, type=type)
Example #28
0
def get_user_ratings(user_id):
    return Rating.get_user_ratings(user_id)
Example #29
0
class ShortReviewTestCase(TestCase):

    def initialize(self):
        self.clean_data()

        # set up users
        self.u1= User.objects.create_user('michuk', '*****@*****.**', 'secret')
        self.u1.save()

        # set up film
        self.film = Film()
        self.film.title = "Battlefield Earth II"
        self.film.type = Object.TYPE_FILM
        self.film.permalink = "battlefirld-earth-ii"
        self.film.release_year = 2010
        self.film.save()

        # set up rating
        self.rating = Rating()
        self.rating.parent = self.film
        self.rating.user = self.u1
        self.rating.film = self.film
        self.rating.type = Rating.TYPE_FILM
        self.rating.rating = 8
        self.rating.normalized = 8
        self.rating.save()


    def clean_data(self):
        User.objects.all().delete()
        Post.objects.all().delete()
        ShortReview.objects.all().delete()


    def test_saving_single_shortreview(self):
        """
           Test saving single shortreview
        """

        self.initialize()

        # set up Shortreview
        obj = Object.objects.get(id=self.film.id)
        shortreview = ShortReview()
        shortreview.user = self.u1
        shortreview.review_text = "sialala bumcyk cyk"
        shortreview.status = Object.PUBLIC_STATUS
        shortreview.type = Object.TYPE_SHORT_REVIEW
        shortreview.kind = ShortReview.REVIEW
        shortreview.object = obj
        shortreview.rating = self.rating
        shortreview.save()

        # testing if shortreview was saved
        sr = ShortReview.objects.get(object=obj)
        
        self.failUnlessEqual(sr.user, shortreview.user)
        self.failUnlessEqual(sr.review_text, "sialala bumcyk cyk")
        self.failUnlessEqual(sr.status, Object.PUBLIC_STATUS)
        self.failUnlessEqual(sr.type, Object.TYPE_SHORT_REVIEW)
        self.failUnlessEqual(sr.kind, ShortReview.REVIEW)
        self.failUnlessEqual(sr.rating.rating, 8)
        self.failUnlessEqual(sr.object, obj)


    def test_delete_single_shortreview(self):
        """
            Test deleting single shortreview
        """

        self.initialize()

        # set up Shortreview
        obj = Object.objects.get(id=self.film.id)
        shortreview = ShortReview()
        shortreview.user = self.u1
        shortreview.review_text = "sialala bumcyk cyk"
        shortreview.status = Object.PUBLIC_STATUS
        shortreview.type = Object.TYPE_SHORT_REVIEW
        shortreview.kind = ShortReview.REVIEW
        shortreview.object = obj
        shortreview.save()

        # there should be one short review
        self.failUnlessEqual(ShortReview.objects.all().count(), 1)

        sr = ShortReview.objects.get(object=obj)

        # deleting shortreview
        sr.delete()

        # there should be zero short reviews
        self.failUnlessEqual(ShortReview.objects.all().count(), 0)


    def test_edit_single_shortreview(self):
        """
            Test editing single shortreview
        """

        self.initialize()

        # set up Shortreview
        obj = Object.objects.get(id=self.film.id)
        shortreview = ShortReview()
        shortreview.user = self.u1
        shortreview.review_text = "sialala bumcyk cyk"
        shortreview.status = Object.PUBLIC_STATUS
        shortreview.type = Object.TYPE_SHORT_REVIEW
        shortreview.kind = ShortReview.REVIEW
        shortreview.object = obj
        shortreview.save()
        shortreview.rating.rating = 10
        shortreview.rating.save()

        # testing if shortreview was saved
        sr = ShortReview.objects.get(object=obj)

        self.failUnlessEqual(sr.review_text, "sialala bumcyk cyk")

        sr.review_text = "Lorem ipsum"
        sr.save()

        # testing if short review was edited successfully
        sr = ShortReview.objects.get(object=obj)
        self.failUnlessEqual(sr.review_text, "Lorem ipsum")
        self.failUnlessEqual(sr.rating.rating, 10)


    def test_saving_double_shortreviews(self):
        """
           Test saving two shortreviews about the same movie by the same user
        """

        self.initialize()

        # set up Shortreviews
        obj = Object.objects.get(id=self.film.id)
        shortreview1 = ShortReview()
        shortreview1.user = self.u1
        shortreview1.review_text = "sialala bumcyk cyk"
        shortreview1.status = Object.PUBLIC_STATUS
        shortreview1.type = Object.TYPE_SHORT_REVIEW
        shortreview1.kind = ShortReview.REVIEW
        shortreview1.object = obj
        shortreview1.rating = self.rating
        shortreview1.save()

        obj = Object.objects.get(id=self.film.id)
        shortreview2 = ShortReview()
        shortreview2.user = self.u1
        shortreview2.review_text = "Lorem ipsum lorem ipsum"
        shortreview2.status = Object.PUBLIC_STATUS
        shortreview2.type = Object.TYPE_SHORT_REVIEW
        shortreview2.kind = ShortReview.REVIEW
        shortreview2.object = obj
        shortreview2.rating = self.rating
        shortreview2.save()


        # testing if shortreview was saved
        sr = ShortReview.objects.filter(object=obj).order_by("created_at")

        self.failUnlessEqual(sr[0].user, shortreview1.user)
        self.failUnlessEqual(sr[0].review_text, "sialala bumcyk cyk")
        self.failUnlessEqual(sr[0].status, Object.PUBLIC_STATUS)
        self.failUnlessEqual(sr[0].type, Object.TYPE_SHORT_REVIEW)
        self.failUnlessEqual(sr[0].kind, ShortReview.REVIEW)
        self.failUnlessEqual(sr[0].rating.rating, 8)
        self.failUnlessEqual(sr[0].object, obj)

        self.failUnlessEqual(sr[1].user, shortreview1.user)
        self.failUnlessEqual(sr[1].review_text, "Lorem ipsum lorem ipsum")
        self.failUnlessEqual(sr[1].status, Object.PUBLIC_STATUS)
        self.failUnlessEqual(sr[1].type, Object.TYPE_SHORT_REVIEW)
        self.failUnlessEqual(sr[1].kind, ShortReview.REVIEW)
        self.failUnlessEqual(sr[1].rating.rating, 8)
        self.failUnlessEqual(sr[1].object, obj)


    def test_saving_wall_post(self):
        """
            Test saving wall post
        """

        self.initialize()

        wallpost = ShortReview()
        wallpost.user = self.u1
        wallpost.review_text = "sialala bumcyk cyk"
        wallpost.status = Object.PUBLIC_STATUS
        wallpost.kind = ShortReview.WALLPOST
        wallpost.type = Object.TYPE_SHORT_REVIEW
        wallpost.save()

        permalink = 'http://%s.%s/%s/%s/' % (self.u1.username, settings.DOMAIN, urls['WALL'], wallpost.id)
        wp = ShortReview.objects.all()[0]

        self.failUnlessEqual(wp.get_absolute_url(), permalink)
        self.failUnlessEqual(wp.user, wallpost.user)
        self.failUnlessEqual(wp.review_text, "sialala bumcyk cyk")
        self.failUnlessEqual(wp.status, Object.PUBLIC_STATUS)
        self.failUnlessEqual(wp.type, Object.TYPE_SHORT_REVIEW)
Example #30
0
class UserActivityTestCase(TestCase):
    def setUp(self):
        Film.objects.filter(imdb_code__lt=1000).delete()

    def initialize(self):
        self.clean_data()

        # set up users
        self.u1= User.objects.create_user('michuk', '*****@*****.**', 'secret')
        self.u1.save()
        self.u2 = User(username='******', email='*****@*****.**')
        self.u2.save()
        self.u3 = User(username='******', email='*****@*****.**')
        self.u3.save()
        self.u4 = User(username='******', email='*****@*****.**')
        self.u4.save()

        # set up film
        self.film = Film()
        self.film.title = "Battlefield Earth II"
        self.film.type = Object.TYPE_FILM
        self.film.permalink = "battlefirld-earth-ii"
        self.film.release_year = 2010
        self.film.save()
        self.film.save_tags('comedy')

        self.film1 = Film()
        self.film1.title = "Battlefield Earth III"
        self.film1.type = Object.TYPE_FILM
        self.film1.permalink = "battlefirld-earth-iii"
        self.film1.release_year = 2010
        self.film1.save()
        self.film1.save_tags('sci-fi')

        self.film2 = Film()
        self.film2.title = "Battlefield Earth IV"
        self.film2.type = Object.TYPE_FILM
        self.film2.permalink = "battlefirld-earth-iv"
        self.film2.release_year = 2010
        self.film2.save()
        self.film2.save_tags('horror')

        self.rating = Rating()
        self.rating.parent = self.film
        self.rating.user = self.u1
        self.rating.film = self.film
        self.rating.type = Rating.TYPE_FILM
        self.rating.rating = 8
        self.rating.normalized = 8
        self.rating.save()

        self.rating1 = Rating()
        self.rating1.parent = self.film1
        self.rating1.user = self.u1
        self.rating1.film = self.film1
        self.rating1.type = Rating.TYPE_FILM
        self.rating1.rating = 8
        self.rating1.normalized = 8
        self.rating1.save()

        self.rating2 = Rating()
        self.rating2.parent = self.film2
        self.rating2.user = self.u1
        self.rating2.film = self.film2
        self.rating2.type = Rating.TYPE_FILM
        self.rating2.rating = 8
        self.rating2.normalized = 8
        self.rating2.save()

    def films_for_comparator(self):
        # films for comnparator
        self.f1 = Film(type=1, permalink='przypadek', imdb_code=111, status=1, version=1,
            release_year=1999, title='Przypadek', popularity=20, popularity_month=10)
        self.f1.save()

        self.f2 = Film(type=1, permalink='wrestler', imdb_code=112, status=1, version=1,
            release_year=2008, title='Wrestler', popularity=10, popularity_month=1)
        self.f2.save()

        self.f3 = Film(type=1, permalink='american-history-x', imdb_code=113, status=1, version=1,
            release_year=1998, title='American History X', popularity=1, popularity_month=1)
        self.f3.save()

        self.f4 = Film(type=1, permalink='the-big-lebowski', imdb_code=114, status=1, version=1,
            release_year=1998, title='The Big Lebowski', popularity=1, popularity_month=1)
        self.f4.save()

        self.f5 = Film(type=1, permalink='the-lord-of-the-rings-the-fellowship-of-the-ring', imdb_code=115, status=1, version=1,
            release_year=2001, title='The Lord of the Rings: The Fellowship of the Ring', popularity=1, popularity_month=1)
        self.f5.save()

        self.f6 = Film(type=1, permalink='raiders-of-the-lost-ark', imdb_code=116, status=1, version=1,
            release_year=1981, title='Raiders of the Lost Ark', popularity=1, popularity_month=1)
        self.f6.save()

        self.f7 = Film(type=1, permalink='the-alien', imdb_code=117, status=1, version=1,
            release_year=1979, title='The Alien', popularity=1, popularity_month=1)
        self.f7.save()

        self.f8 = Film(type=1, permalink='terminator-2-judgment-day', imdb_code=118, status=1, version=1,
        release_year=1991, title='Terminator 2: Judgment Day', popularity=1, popularity_month=1)
        self.f8.save()

        self.f9 = Film(type=1, permalink='przypadek', imdb_code=119, status=1, version=1,
            release_year=1999, title='Przypadek', popularity=20, popularity_month=10)
        self.f9.save()

        self.f10 = Film(type=1, permalink='wrestler', imdb_code=120, status=1, version=1,
            release_year=2008, title='Wrestler', popularity=10, popularity_month=1)
        self.f10.save()

        self.f11 = Film(type=1, permalink='american-history-x', imdb_code=121, status=1, version=1,
            release_year=1998, title='American History X', popularity=1, popularity_month=1)
        self.f11.save()

        self.f12 = Film(type=1, permalink='the-big-lebowski', imdb_code=122, status=1, version=1,
            release_year=1998, title='The Big Lebowski', popularity=1, popularity_month=1)
        self.f12.save()

        self.f13 = Film(type=1, permalink='the-lord-of-the-rings-the-fellowship-of-the-ring', imdb_code=123, status=1, version=1,
            release_year=2001, title='The Lord of the Rings: The Fellowship of the Ring', popularity=1, popularity_month=1)
        self.f13.save()

        self.f14 = Film(type=1, permalink='raiders-of-the-lost-ark', imdb_code=124, status=1, version=1,
            release_year=1981, title='Raiders of the Lost Ark', popularity=1, popularity_month=1)
        self.f14.save()

        self.f15 = Film(type=1, permalink='the-alien', imdb_code=125, status=1, version=1,
            release_year=1979, title='The Alien', popularity=1, popularity_month=1)
        self.f15.save()

        self.f16 = Film(type=1, permalink='przypadek', imdb_code=126, status=1, version=1,
            release_year=1999, title='Przypadek', popularity=20, popularity_month=10)
        self.f16.save()

        self.f17 = Film(type=1, permalink='wrestler', imdb_code=127, status=1, version=1,
            release_year=2008, title='Wrestler', popularity=10, popularity_month=1)
        self.f17.save()

        self.f18 = Film(type=1, permalink='american-history-x', imdb_code=128, status=1, version=1,
            release_year=1998, title='American History X', popularity=1, popularity_month=1)
        self.f18.save()

        self.f19 = Film(type=1, permalink='the-big-lebowski', imdb_code=129, status=1, version=1,
            release_year=1998, title='The Big Lebowski', popularity=1, popularity_month=1)
        self.f19.save()

        self.f20 = Film(type=1, permalink='the-lord-of-the-rings-the-fellowship-of-the-ring', imdb_code=130, status=1, version=1,
            release_year=2001, title='The Lord of the Rings: The Fellowship of the Ring', popularity=1, popularity_month=1)
        self.f20.save()

        self.f21 = Film(type=1, permalink='raiders-of-the-lost-ark', imdb_code=131, status=1, version=1,
            release_year=1981, title='Raiders of the Lost Ark', popularity=1, popularity_month=1)
        self.f21.save()

        self.f22 = Film(type=1, permalink='the-alien', imdb_code=132, status=1, version=1,
            release_year=1979, title='The Alien', popularity=1, popularity_month=1)
        self.f22.save()

        self.f23 = Film(type=1, permalink='terminator-2-judgment-day', imdb_code=133, status=1, version=1,
        release_year=1991, title='Terminator 2: Judgment Day', popularity=1, popularity_month=1)
        self.f23.save()

        self.f24 = Film(type=1, permalink='przypadek', imdb_code=134, status=1, version=1,
            release_year=1999, title='Przypadek', popularity=20, popularity_month=10)
        self.f24.save()

        self.f25 = Film(type=1, permalink='wrestler', imdb_code=135, status=1, version=1,
            release_year=2008, title='Wrestler', popularity=10, popularity_month=1)
        self.f25.save()

        self.f26 = Film(type=1, permalink='american-history-x', imdb_code=136, status=1, version=1,
            release_year=1998, title='American History X', popularity=1, popularity_month=1)
        self.f26.save()

        self.f27 = Film(type=1, permalink='the-big-lebowski', imdb_code=137, status=1, version=1,
            release_year=1998, title='The Big Lebowski', popularity=1, popularity_month=1)
        self.f27.save()

        self.f28 = Film(type=1, permalink='the-lord-of-the-rings-the-fellowship-of-the-ring', imdb_code=138, status=1, version=1,
            release_year=2001, title='The Lord of the Rings: The Fellowship of the Ring', popularity=1, popularity_month=1)
        self.f28.save()

        self.f29 = Film(type=1, permalink='raiders-of-the-lost-ark', imdb_code=139, status=1, version=1,
            release_year=1981, title='Raiders of the Lost Ark', popularity=1, popularity_month=1)
        self.f29.save()

        self.f30 = Film(type=1, permalink='the-alien', imdb_code=140, status=1, version=1,
            release_year=1979, title='The Alien', popularity=1, popularity_month=1)
        self.f30.save()

        self.f1.save_tags('comedy drama horror animation mystery')
        self.f2.save_tags('comedy sci-fi thriller series')
        self.f3.save_tags('comedy')
        self.f4.save_tags('sci-fi')
        self.f5.save_tags('horror')
        self.f6.save_tags('thriller')
        self.f7.save_tags('drama')
        self.f8.save_tags('series')
        self.f9.save_tags('sci-fi')
        self.f10.save_tags('fantasy')
        self.f11.save_tags('mystery')
        self.f12.save_tags('action')
        self.f13.save_tags('adventure')
        self.f14.save_tags('animation')
        self.f15.save_tags('family')
        self.f16.save_tags('thriller')
        self.f17.save_tags('drama')
        self.f18.save_tags('series')
        self.f19.save_tags('sci-fi')
        self.f20.save_tags('fantasy')
        self.f21.save_tags('comedy')
        self.f22.save_tags('animation')
        self.f23.save_tags('comedy')
        self.f24.save_tags('sci-fi')
        self.f25.save_tags('horror')
        self.f26.save_tags('thriller')
        self.f27.save_tags('drama')
        self.f28.save_tags('series')
        self.f29.save_tags('sci-fi')
        self.f30.save_tags('fantasy')

        #First user ratings
        save_rating(self.f1, self.u1, 1)
        save_rating(self.f2, self.u1, 2)
        save_rating(self.f3, self.u1, 3)
        save_rating(self.f4, self.u1, 4)
        save_rating(self.f5, self.u1, 5)
        save_rating(self.f6, self.u1, 6)
        save_rating(self.f7, self.u1, 7)
        save_rating(self.f8, self.u1, 8)
        save_rating(self.f9, self.u1, 9)
        save_rating(self.f10, self.u1, 10)
        save_rating(self.f11, self.u1, 1)
        save_rating(self.f12, self.u1, 2)
        save_rating(self.f13, self.u1, 3)
        save_rating(self.f14, self.u1, 4)
        save_rating(self.f15, self.u1, 5)
        save_rating(self.f16, self.u1, 6)
        save_rating(self.f17, self.u1, 7)
        save_rating(self.f18, self.u1, 8)
        save_rating(self.f19, self.u1, 9)
        save_rating(self.f20, self.u1, 10)
        save_rating(self.f21, self.u1, 1)
        save_rating(self.f22, self.u1, 2)
        save_rating(self.f23, self.u1, 3)
        save_rating(self.f24, self.u1, 4)
        save_rating(self.f25, self.u1, 5)
        save_rating(self.f26, self.u1, 6)
        save_rating(self.f27, self.u1, 7)
        save_rating(self.f28, self.u1, 8)
        save_rating(self.f29, self.u1, 9)
        save_rating(self.f30, self.u1, 10)

        #Second user ratings - more than minimal common films requirement (15)
        save_rating(self.f1, self.u2, 1)
        save_rating(self.f2, self.u2, 2)
        save_rating(self.f3, self.u2, 3)
        save_rating(self.f4, self.u2, 4)
        save_rating(self.f5, self.u2, 5)
        save_rating(self.f6, self.u2, 6)
        save_rating(self.f7, self.u2, 7)
        save_rating(self.f8, self.u2, 8)
        save_rating(self.f9, self.u2, 9)
        save_rating(self.f10, self.u2, 10)
        save_rating(self.f11, self.u2, 1)
        #save_rating(self.f12, self.u2, 2)
        save_rating(self.f13, self.u2, 3)
        #save_rating(self.f14, self.u2, 4)
        save_rating(self.f15, self.u2, 5)
        #save_rating(self.f16, self.u2, 6)
        save_rating(self.f17, self.u2, 7)
        #save_rating(self.f18, self.u2, 8)
        save_rating(self.f19, self.u2, 9)
        #save_rating(self.f20, self.u2, 10)
        save_rating(self.f21, self.u2, 1)
        #save_rating(self.f22, self.u2, 2)
        save_rating(self.f23, self.u2, 3)
        #save_rating(self.f24, self.u2, 4)
        save_rating(self.f25, self.u2, 5)
        #save_rating(self.f26, self.u2, 6)
        save_rating(self.f27, self.u2, 7)
        #save_rating(self.f28, self.u2, 8)
        save_rating(self.f29, self.u2, 9)
        #save_rating(self.f30, self.u2, 10)

        # Third user ratings - equal with minimal common films requirement (15)
        #save_rating(self.f1, self.u3, 1)
        #save_rating(self.f2, self.u3, 2)
        #save_rating(self.f3, self.u3, 3)
        #save_rating(self.f4, self.u3, 4)
        #save_rating(self.f5, self.u3, 5)
        #save_rating(self.f6, self.u3, 6)
        #save_rating(self.f7, self.u3, 7)
        #save_rating(self.f8, self.u3, 8)
        #save_rating(self.f9, self.u3, 9)
        #save_rating(self.f10, self.u3, 10)
        #save_rating(self.f11, self.u3, 1)
        #save_rating(self.f12, self.u3, 2)
        #save_rating(self.f13, self.u3, 3)
        #save_rating(self.f14, self.u3, 4)
        #save_rating(self.f15, self.u3, 5)
        save_rating(self.f16, self.u3, 6)
        save_rating(self.f17, self.u3, 7)
        save_rating(self.f18, self.u3, 8)
        save_rating(self.f19, self.u3, 9)
        save_rating(self.f20, self.u3, 10)
        save_rating(self.f21, self.u3, 1)
        save_rating(self.f22, self.u3, 2)
        save_rating(self.f23, self.u3, 3)
        save_rating(self.f24, self.u3, 4)
        save_rating(self.f25, self.u3, 5)
        save_rating(self.f26, self.u3, 6)
        save_rating(self.f27, self.u3, 7)
        save_rating(self.f28, self.u3, 8)
        save_rating(self.f29, self.u3, 9)
        save_rating(self.f30, self.u3, 10)

        # Fourth user ratings - less than minimal films requirement
        #save_rating(self.f1, self.u4, 1)
        #save_rating(self.f2, self.u4, 2)
        #save_rating(self.f3, self.u4, 3)
        #save_rating(self.f4, self.u4, 4)
        #save_rating(self.f5, self.u4, 5)
        #save_rating(self.f6, self.u4, 6)
        #save_rating(self.f7, self.u4, 7)
        #save_rating(self.f8, self.u4, 8)
        #save_rating(self.f9, self.u4, 9)
        #save_rating(self.f10, self.u4, 10)
        #save_rating(self.f11, self.u4, 1)
        #save_rating(self.f12, self.u4, 2)
        #save_rating(self.f13, self.u4, 3)
        #save_rating(self.f14, self.u4, 4)
        #save_rating(self.f15, self.u4, 5)
        #save_rating(self.f16, self.u4, 6)
        #save_rating(self.f17, self.u4, 7)
        #save_rating(self.f18, self.u4, 8)
        #save_rating(self.f19, self.u4, 9)
        #save_rating(self.f20, self.u4, 10)
        save_rating(self.f21, self.u4, 1)
        save_rating(self.f22, self.u4, 2)
        save_rating(self.f23, self.u4, 3)
        save_rating(self.f24, self.u4, 4)
        save_rating(self.f25, self.u4, 5)
        save_rating(self.f26, self.u4, 6)
        save_rating(self.f27, self.u4, 7)
        save_rating(self.f28, self.u4, 8)
        save_rating(self.f29, self.u4, 9)
        save_rating(self.f30, self.u4, 10)
        
    def clean_data(self):
        User.objects.all().delete()
        Post.objects.all().delete()
        Rating.objects.all().delete()
        UserActivity.objects.all().delete()

        
    def test_saving_post_activity(self):
        """
            Test saving post activity
        """
        self.initialize()

        # set up post
        post = Post()
        post.title = "Lorem ipsum"
        post.permalink = "lorem-ipsum"
        post.body = "siala lala tralala"
        post.user = self.u1
        post.status = Object.PUBLIC_STATUS
        post.type = Object.TYPE_POST
        post.save()
        post.related_film.add(self.film)
        # this method will call save_activity method and in this case create new activity
        post.save()

        activity = UserActivity.objects.get(post=post)

        # testing if activity was saved properly
        self.failUnlessEqual(activity.title, post.title)
        self.failUnlessEqual(activity.content, post.body)
        self.failUnlessEqual(activity.permalink, post.get_absolute_url())
        self.failUnlessEqual(activity.status, post.status)
        self.failUnlessEqual(activity.activity_type, UserActivity.TYPE_POST)
        self.failUnlessEqual(activity.username, self.u1.username)
        self.failUnlessEqual(activity.film_title, self.film.title)
        self.failUnlessEqual(activity.film_permalink, self.film.permalink)

        # TODO: add a get_absolute_url(), get_slug() and get_subdomain() test

    def test_updating_post_activity(self):
        """
            Test updating post activity
        """
        self.initialize()

        # set up post
        post = Post()
        post.title = "Lorem ipsum"
        post.permalink = "lorem-ipsum"
        post.body = "siala lala tralala"
        post.user = self.u1
        post.status = Object.PUBLIC_STATUS
        post.type = Object.TYPE_POST
        post.save()
        post.related_film.add(self.film)
        post.save()

        post.title = "Bum bum bum"
        post.permalink = "bum-bum-bum"
        post.body = "Lubuduubu lubu dubu niech zyje nam prezes naszego klubu!"
        post.status = Object.DRAFT_STATUS
        post.save()
        
        activity = UserActivity.objects.get(post=post)

        # testing if activity was updated properly
        self.failUnlessEqual(activity.title, "Bum bum bum")
        self.failUnlessEqual(activity.content, "Lubuduubu lubu dubu niech zyje nam prezes naszego klubu!")
        self.failUnlessEqual(activity.permalink, post.get_absolute_url())
        self.failUnlessEqual(activity.status, UserActivity.DRAFT_STATUS)
        self.failUnlessEqual(activity.activity_type, UserActivity.TYPE_POST)
        self.failUnlessEqual(activity.username, self.u1.username)
        self.failUnlessEqual(activity.film_title, self.film.title)
        self.failUnlessEqual(activity.film_permalink, self.film.permalink)

    def test_saving_shortreview_activity(self):
        """
           Test saving shortreview activity     
        """

        self.initialize()

        # set up Shortreview
        obj = Object.objects.get(id=self.film.id)
        shortreview = ShortReview()
        shortreview.user = self.u1
        shortreview.review_text = "sialala bumcyk cyk"
        shortreview.status = Object.PUBLIC_STATUS
        shortreview.type = Object.TYPE_SHORT_REVIEW
        shortreview.object = obj
        shortreview.kind = ShortReview.REVIEW
        shortreview.save()

        activity = UserActivity.objects.get(short_review=shortreview)

        # testing if activity was saved properly
        self.failUnlessEqual(activity.title, shortreview.get_title())
        self.failUnlessEqual(activity.content, shortreview.review_text)
        self.failUnlessEqual(activity.permalink, shortreview.get_absolute_url())
        self.failUnlessEqual(activity.status, shortreview.status)
        self.failUnlessEqual(activity.activity_type, UserActivity.TYPE_SHORT_REVIEW)
        self.failUnlessEqual(activity.username, self.u1.username)
        self.failUnlessEqual(activity.film_title, self.film.title)
        self.failUnlessEqual(activity.film_permalink, self.film.permalink)

    def test_updating_shortreview_activity(self):
        """
           Test updating shortreview activity
        """

        self.initialize()

        # set up Shortreview
        obj = Object.objects.get(id=self.film.id)
        shortreview = ShortReview()
        shortreview.user = self.u1
        shortreview.review_text = "sialala bumcyk cyk"
        shortreview.status = Object.PUBLIC_STATUS
        shortreview.type = Object.TYPE_SHORT_REVIEW
        shortreview.object = obj
        shortreview.kind = ShortReview.REVIEW
        shortreview.save()

        shortreview = ShortReview.objects.get(id=shortreview.id)
        shortreview.review_text = "Lorem ipsum"
        shortreview.status = Object.DELETED_STATUS
        shortreview.save()

        activity = UserActivity.objects.get(short_review=shortreview)
        
        # testing if activity was updated properly
        self.failUnlessEqual(activity.title, shortreview.get_title())
        self.failUnlessEqual(activity.content, "Lorem ipsum")
        self.failUnlessEqual(activity.permalink, shortreview.get_absolute_url())
        self.failUnlessEqual(activity.status, UserActivity.DELETED_STATUS)
        self.failUnlessEqual(activity.activity_type, UserActivity.TYPE_SHORT_REVIEW)
        self.failUnlessEqual(activity.username, self.u1.username)
        self.failUnlessEqual(activity.film_title, self.film.title)
        self.failUnlessEqual(activity.film_permalink, self.film.permalink)

    def test_saving_externallink_activity(self):
        """
            Test saving externallink activity
        """

        self.initialize()

        # set up Externallink

        ext = ExternalLink()
        ext.title = "Link title!"
        ext.url = "http://filmaster.pl"
        ext.url_kind = ExternalLink.REVIEW
        ext.excerpt = "Lorem ipsum"
        ext.film = self.film
        ext.user = self.u1
        ext.status = Object.PUBLIC_STATUS
        ext.type = Object.TYPE_LINK
        ext.save()

        self.assertRaises(UserActivity.DoesNotExist, UserActivity.objects.get, link=ext)
        
        ext.moderation_status = ExternalLink.STATUS_ACCEPTED
        ext.save()

        activity = UserActivity.objects.get(link=ext)

        # testing if activity was saved properly
        self.failUnlessEqual(activity.title, ext.title)
        self.failUnlessEqual(activity.content, ext.excerpt)
        self.failUnlessEqual(activity.get_absolute_url(), ext.get_absolute_url())
        self.failUnlessEqual(activity.status, ext.status)
        self.failUnlessEqual(activity.activity_type, UserActivity.TYPE_LINK)
        self.failUnlessEqual(activity.username, self.u1.username)
        self.failUnlessEqual(activity.film_title, self.film.title)
        self.failUnlessEqual(activity.film_permalink, self.film.permalink)

    def test_updating_externallink_activity(self):
        """
            Test updating externallink activity
        """

        self.initialize()

        # set up Externallink

        ext = ExternalLink()
        ext.title = "Link title!"
        ext.url = "http://filmaster.pl"
        ext.url_kind = ExternalLink.REVIEW
        ext.excerpt = "Lorem ipsum"
        ext.film = self.film
        ext.user = self.u1
        ext.status = Object.PUBLIC_STATUS
        ext.type = Object.TYPE_LINK
        ext.save()

        ext.url = "http://osnews.pl"
        ext.excerpt = "Lorem lorem"
        ext.save()

        activity = UserActivity.objects.get(link=ext)

        # testing if activity was saved properly
        self.failUnlessEqual(activity.title, ext.title)
        self.failUnlessEqual(activity.content, "Lorem lorem")
        self.failUnlessEqual(activity.get_absolute_url(), ext.get_absolute_url())
        self.failUnlessEqual(activity.status, ext.status)
        self.failUnlessEqual(activity.url, "http://osnews.pl")
        self.failUnlessEqual(activity.activity_type, UserActivity.TYPE_LINK)
        self.failUnlessEqual(activity.username, self.u1.username)
        self.failUnlessEqual(activity.film_title, self.film.title)
        self.failUnlessEqual(activity.film_permalink, self.film.permalink)

    def test_saving_comment_activity(self):
        """
            Test saving comment activity
        """
        self.initialize()

        # set up post for commenting
        post = Post()
        post.title = "Lorem ipsum"
        post.permalink = "lorem-ipsum"
        post.body = "siala lala tralala"
        post.user = self.u1
        post.status = Object.PUBLIC_STATUS
        post.type = Object.TYPE_POST
        post.save()
        post.related_film.add(self.film)
        post.save()

        comment = ThreadedComment()
        comment.user = self.u1
        comment.comment = "Lorem ipsum"
        comment.content_object = post
        comment.status = Object.PUBLIC_STATUS
        comment.type=Object.TYPE_COMMENT
        comment.permalink="COMMENT"
        comment.save()

        activity = UserActivity.objects.get(comment=comment)

        # testing if activity was saved properly
        self.failUnlessEqual(activity.title, comment.content_object.get_comment_title())
        self.failUnlessEqual(activity.content, comment.comment)
        if settings.ENSURE_OLD_STYLE_PERMALINKS:
            self.failUnlessEqual(activity.permalink, comment.content_object.get_absolute_url_old_style()+"#"+ str(comment.id))
        else:
            self.failUnlessEqual(activity.permalink, comment.content_object.get_absolute_url()+"#"+ str(comment.id))
        self.failUnlessEqual(activity.status, comment.status)
        self.failUnlessEqual(activity.activity_type, UserActivity.TYPE_COMMENT)
        self.failUnlessEqual(activity.username, self.u1.username)

        #planet_tag_helper without tag = 1 comment
        pth = PlanetTagHelper()
        comments = pth.planet_tag_comments()
        self.assertEquals(len(comments), 1)
        
        #planet_tag_helper with tag 'comedy' = 0 comment
        #no assigned films to comment
        pth_tags = PlanetTagHelper(tag='comedy')
        comments = pth_tags.planet_tag_comments()
        self.assertEquals(len(comments), 0)

    def test_updating_comment_activity(self):
        """
            Test updating comment activity
        """

        self.initialize()

        # set up post for commenting
        post = Post()
        post.title = "Lorem ipsum"
        post.permalink = "lorem-ipsum"
        post.body = "siala lala tralala"
        post.user = self.u1
        post.status = Object.PUBLIC_STATUS
        post.type = Object.TYPE_POST
        post.save()
        post.related_film.add(self.film)
        post.save()

        comment = ThreadedComment()
        comment.user = self.u1
        comment.comment = "Lorem ipsum"
        comment.content_object = post
        comment.status = Object.PUBLIC_STATUS
        comment.type=Object.TYPE_COMMENT
        comment.permalink="COMMENT"
        comment.save()

        comment.comment = "siala lala tralala"
        comment.status = Object.DELETED_STATUS
        comment.save()
        activity = UserActivity.objects.get(comment=comment)

        # testing if activity was updated properly
        self.failUnlessEqual(activity.title, comment.content_object.get_comment_title())
        self.failUnlessEqual(activity.content, "siala lala tralala")
        if settings.ENSURE_OLD_STYLE_PERMALINKS:
            self.failUnlessEqual(activity.permalink, comment.content_object.get_absolute_url_old_style()+"#"+ str(comment.id))
        else:
            self.failUnlessEqual(activity.permalink, comment.content_object.get_absolute_url()+"#"+ str(comment.id))
        self.failUnlessEqual(activity.status, UserActivity.DELETED_STATUS)
        self.failUnlessEqual(activity.activity_type, UserActivity.TYPE_COMMENT)
        self.failUnlessEqual(activity.username, self.u1.username)

    def test_saving_draft_post_activity(self):
        """
           Test saving draft activity
           Make sure that activity is not created for draft posts
        """

        self.initialize()
        post = Post()
        post.title = "Lorem ipsum"
        post.permalink = "lorem-ipsum"
        post.body = "siala lala tralala"
        post.user = self.u1
        post.status = Object.DRAFT_STATUS
        post.type = Object.TYPE_POST
        post.save()
        post.related_film.add(self.film)
        post.save()

        self.failUnlessEqual(UserActivity.objects.all().count(), 1) # now we want to create an activity each time
        act = UserActivity.objects.get(post=post)
        self.failUnlessEqual(act.status, UserActivity.DRAFT_STATUS)

        post.status = Post.PUBLIC_STATUS
        post.save()
        self.failUnlessEqual(UserActivity.objects.all().count(), 1)
        act = UserActivity.objects.get(post=post)
        self.failUnlessEqual(act.status, UserActivity.PUBLIC_STATUS)

        post.status = Post.DRAFT_STATUS
        post.save()
        self.failUnlessEqual(UserActivity.objects.all().count(), 1)
        act = UserActivity.objects.get(post=post)
        self.failUnlessEqual(act.status, UserActivity.DRAFT_STATUS)

    def test_deleting_post_activity(self):
        """
            Test deleting post activity
        """

        self.initialize()
        post = Post()
        post.title = "Lorem ipsum"
        post.permalink = "lorem-ipsum"
        post.body = "siala lala tralala"
        post.user = self.u1
        post.status = Object.PUBLIC_STATUS
        post.type = Object.TYPE_POST
        post.save()
        post.related_film.add(self.film)
        post.save()

        act = UserActivity.objects.get(post=post)

        self.failUnlessEqual(act.status, UserActivity.PUBLIC_STATUS)

        post.status = Object.DELETED_STATUS
        post.save()

        act = UserActivity.objects.get(post=post)
        self.failUnlessEqual(act.status, UserActivity.DELETED_STATUS)

    def test_updating_relatedfilm_post_activity(self):
        """
            Test updating film fields in post activity when related films
            are removed from post
        """
        self.initialize()
        self.client.login(username='******', password='******')
        
        # set up post
        post = Post()
        post.title = "Lorem ipsum"
        post.permalink = "lorem-ipsum"
        post.body = "siala lala tralala"
        post.user = self.u1
        post.status = Object.PUBLIC_STATUS
        post.type = Object.TYPE_POST
        post.save()
        post.related_film.add(self.film)
        post.save()

        activity = UserActivity.objects.get(post=post)

        # testing if activity was saved properly
        self.failUnlessEqual(activity.title, "Lorem ipsum")
        self.failUnlessEqual(activity.content, "siala lala tralala")
        self.failUnlessEqual(activity.permalink, post.get_absolute_url())
        self.failUnlessEqual(activity.status, UserActivity.PUBLIC_STATUS)
        self.failUnlessEqual(activity.activity_type, UserActivity.TYPE_POST)
        self.failUnlessEqual(activity.username, self.u1.username)
        self.failUnlessEqual(activity.film is None, False)
        self.failUnlessEqual(activity.film_permalink, self.film.permalink)
        self.failUnlessEqual(activity.film_title, self.film.title)

        # update post
        post.title = "New title"
        post.body = "Lorem ipsum! Lorem ipsum! Lorem ipsum!"
        post.related_film = []
        post.save()
        activity = UserActivity.objects.get(post=post)

        # testing if activity was updated properly
        self.failUnlessEqual(activity.title, "New title")
        self.failUnlessEqual(activity.content, "Lorem ipsum! Lorem ipsum! Lorem ipsum!")
        self.failUnlessEqual(activity.permalink, post.get_absolute_url())
        self.failUnlessEqual(activity.status, UserActivity.PUBLIC_STATUS)
        self.failUnlessEqual(activity.activity_type, UserActivity.TYPE_POST)
        self.failUnlessEqual(activity.username, self.u1.username)
        self.failUnlessEqual(activity.film is None, True)
        self.failUnlessEqual(activity.film_permalink, None)
        self.failUnlessEqual(activity.film_title, None)

    def test_rating_activity(self):
        """
           Test creating rating activity     
        """

        self.initialize()

        ratings = Rating.objects.filter(user=self.u1)

        userratingtime = UserRatingTimeRange()

        userratingtime.save_activity(ratings, 3, self.u1)

        ua = UserActivity.objects.get(activity_type=UserActivity.TYPE_RATING, user=self.u1)

        self.failUnlessEqual(ua is None, False)
        self.failUnlessEqual(ua.user, self.u1)
        self.failUnlessEqual(ua.content, u'2')


    def test_planet_tag(self):
        # --- Initialize ---
        self.initialize()
        helper_without_tags = PlanetTagHelper()
        helper_with_tags = PlanetTagHelper(tag='comedy')
        recom_helper = RecomHelper()
        user_activity_helper = UserActivityHelper()

        # --- setup followers ---
        self.u1.followers.follow(self.u2)
        self.u1.followers.follow(self.u3)
        self.u1.followers.follow(self.u4)

        # similar users
        from film20.recommendations.bot_helper import do_create_comparators
        self.films_for_comparator()
        do_create_comparators()

        friends_list = recom_helper.get_following_ids_as_list(self.u1)
        friends_without_activities = helper_without_tags.planet_tag_friends(friends_list)
        self.assertEquals(len(friends_without_activities), 0)
        
        similar_users_list = user_activity_helper.get_similar_users_list(request)
        similar_users_without_tags = helper_without_tags.planet_tag_similar_users(similar_users_list)
        self.assertEquals(len(similar_users_without_tags), 0)

        notes_without_tags = helper_without_tags.planet_tag_notes()
        self.assertEquals(len(notes_without_tags), 0)

        all_planet_activities = helper_without_tags.planet_tag_all()
        self.assertEquals(len(all_planet_activities), 0)

        # --- setup User activities ---
        post = Post()
        post.title = "Lorem ipsum"
        post.permalink = "lorem-ipsum"
        post.body = "siala lala tralala"
        post.user = self.u1
        post.status = Object.PUBLIC_STATUS
        post.type = Object.TYPE_POST
        post.save()
        post.related_film.add(self.film)
        post.save()
        
        all_activities = helper_without_tags.planet_tag_all()
        self.assertEquals(len(all_activities), 1)
        
        post = Post()
        post.title = "Lorem ipsum"
        post.permalink = "lorem-ipsum"
        post.body = "siala lala tralala"
        post.user = self.u1
        post.status = Object.PUBLIC_STATUS
        post.type = Object.TYPE_POST
        post.save()
        post.related_film.add(self.film1)
        post.save()
        
        all_activities = helper_without_tags.planet_tag_all()
        self.assertEquals(len(all_activities), 2)
                
        obj = Object.objects.get(id=self.film2.id)
        shortreview = ShortReview()
        shortreview.user = self.u1
        shortreview.review_text = "sialala bumcyk cyk"
        shortreview.status = Object.PUBLIC_STATUS
        shortreview.type = Object.TYPE_SHORT_REVIEW
        shortreview.object = obj
        shortreview.kind = ShortReview.REVIEW
        shortreview.save()

        all_activities = helper_without_tags.planet_tag_all()
        self.assertEquals(len(all_activities), 3)
        
        # Activities with 'comedy' tag
        all_activities_with_tags = helper_with_tags.planet_tag_all()
        self.assertEquals(len(all_activities_with_tags), 1)

        # --- setup followers activities ---
        post = Post()
        post.title = "#1 Lorem ipsum"
        post.permalink = "lorem-ipsum"
        post.body = "siala lala tralala"
        post.user = self.u2
        post.status = Object.PUBLIC_STATUS
        post.type = Object.TYPE_POST
        post.save()
        post.related_film.add(self.film)
        post.save()

        all_activities = helper_without_tags.planet_tag_all()
        self.assertEquals(len(all_activities), 4)

        post = Post()
        post.title = "#2 Lorem ipsum"
        post.permalink = "lorem-ipsum"
        post.body = "siala lala tralala"
        post.user = self.u3
        post.status = Object.PUBLIC_STATUS
        post.type = Object.TYPE_POST
        post.save()
        post.related_film.add(self.film1)
        post.save()

        all_activities = helper_without_tags.planet_tag_all()
        self.assertEquals(len(all_activities), 5)

        obj = Object.objects.get(id=self.film2.id)
        shortreview = ShortReview()
        shortreview.user = self.u4
        shortreview.review_text = "sialala bumcyk cyk"
        shortreview.status = Object.PUBLIC_STATUS
        shortreview.type = Object.TYPE_SHORT_REVIEW
        shortreview.object = obj
        shortreview.kind = ShortReview.REVIEW
        shortreview.save()

        all_activities = helper_without_tags.planet_tag_all()
        self.assertEquals(len(all_activities), 6)

        activities_with_tags = helper_with_tags.planet_tag_all()
        self.assertEquals(len(activities_with_tags), 2)

        all_friends_activities = helper_without_tags.planet_tag_friends(friends_list)
        self.assertEquals(len(all_friends_activities), 3)
        friends_activities_with_tag = helper_with_tags.planet_tag_friends(friends_list)
        self.assertEquals(len(friends_activities_with_tag), 1)

        # --- Check notes ---
        all_planet_notes = helper_without_tags.planet_tag_notes()
        self.assertEquals(len(all_planet_notes), 4)

        # Post notes with 'comedy' tag
        notes_activities_with_tag = helper_with_tags.planet_tag_notes()
        self.assertEquals(len(notes_activities_with_tag), 2)

        similar_users_activities = helper_without_tags.planet_tag_similar_users(similar_users_list)
        self.assertEquals(len(similar_users_activities), 2)

        users_with_tags = helper_with_tags.planet_tag_similar_users(similar_users_list)
        self.assertEquals(len(users_with_tags), 1)
        
        activities = UserActivity.objects.all() 
Example #31
0
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.get_user_ratings(curuser)
    ratings2 = Rating.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))
Example #32
0
    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-'))