def get_from_tag_basket(cls, user, tag, number_of_films=1):
basket_key = cache.Key(cache.CACHE_TAG_BASKET, user, tag)
no_films_key = cache.Key("no_films_left_for_tag", user, tag)
# indicates whether there are any films left to show to user
no_films = cache.get(no_films_key)
if not no_films:
tag_basket = cache.get(basket_key) or dict()
if len(tag_basket) < number_of_films:
cls.refill_tag_basket(user, tag)
tag_basket = cache.get(basket_key) or dict()
result = sorted(tag_basket, key=tag_basket.get,
reverse=True)[:number_of_films]
if not result:
cache.set(no_films_key, True, cache.A_MONTH)
else:
for film_id in result:
tag_basket.pop(film_id)
cache.set(basket_key, tag_basket, cache.A_MONTH)
defer(cls.refill_tag_basket, user, tag)
return result
else:
return []
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
def queue(users, label, extra_context=None, on_site=True, priority=PRIORITY_DEFAULT):
"""
Queue the notification in NoticeQueueBatch. This allows for large amounts
of user notifications to be deferred to a seperate process running outside
the webserver.
"""
if extra_context is None:
extra_context = {}
user_ids = [user.pk for user in users]
key = lambda u: u[1]
userids_w_lang = [(u.pk, get_notification_language(u, label)) for u in users]
userids_w_lang = sorted(userids_w_lang, key=key)
from itertools import groupby
for lang, userids in groupby(userids_w_lang, key=key):
ids = list(u[0] for u in userids)
defer(
_send_now,
ids,
label,
extra_context,
on_site,
_routing_key="%s%s.notice" % (settings.CELERY_QUEUE_PREFIX, lang),
)
def delete_from_tag_basket(cls, user, id, tag):
basket_key = cache.Key(cache.CACHE_TAG_BASKET, user, tag)
tag_basket = cache.get(basket_key) or dict()
if id in tag_basket:
tag_basket.pop(id)
cache.set(basket_key, tag_basket, cache.A_MONTH)
defer(cls.refill_tag_basket, user, tag)
def compute_user_features(user, save=False, initial=False):
if initial:
profile = user.get_profile()
no_recommendations = (profile.recommendations_status == profile.NO_RECOMMENDATIONS)
if no_recommendations:
profile.recommendations_status = profile.FAST_RECOMMENDATIONS_WAITING
profile.save()
from film20.core.deferred import defer
defer(_compute_fast_recommendations, user, no_recommendations)
def fb_like(request):
url = request.POST.get('url')
content_type = request.POST.get('content_type')
object_id = request.POST.get('object_id')
if not (url and content_type and object_id):
return HttpResponse(status=400)
defer(LikeCounter.update, url, content_type, object_id)
return HttpResponse('ok')
def fb_like(request):
url = request.POST.get('url')
content_type=request.POST.get('content_type')
object_id = request.POST.get('object_id')
if not (url and content_type and object_id):
return HttpResponse(status=400)
defer(LikeCounter.update, url, content_type, object_id)
return HttpResponse('ok')
def send_notice(self, user, type, context):
if getattr(settings, 'NOTIFICATION_QUEUE_ALL', False):
from film20.core.deferred import defer
key = '%s%s.notice.%s.%s' % (
settings.CELERY_QUEUE_PREFIX,
settings.LANGUAGE_CODE,
self.name,
type.label
)
logger.debug('notice %r to %s queued to send via %s', type.label, user, self.name)
defer(self._send_notice_impl, user, type, context, _routing_key=key)
else:
try:
self._send_notice_impl(user, type, context)
except Exception, e:
pass
def send_notice(self, user, type, context, now=False):
if getattr(settings, 'NOTIFICATION_QUEUE_ALL', False) and not now:
from film20.core.deferred import defer
key = '%s%s.notice.%s.%s' % (settings.CELERY_QUEUE_PREFIX,
settings.LANGUAGE_CODE, self.name,
type.label)
logger.debug('notice %r to %s queued to send via %s', type.label,
user, self.name)
defer(self._send_notice_impl,
user,
type,
context,
_routing_key=key)
else:
try:
self._send_notice_impl(user, type, context)
except Exception, e:
pass
def delete_film_from_baskets_by_id(self, user, film_id):
# delete from tag baskets
for tag in self.BASKETS_TAGS_LIST:
self.delete_from_tag_basket(user, film_id, tag)
defer(self.refill_tag_baskets, user, self.BASKETS_TAGS_LIST)
# delete from regular basket
rating_basket_key = self.cache_key(cache.CACHE_USER_BASKET, user)
rating_basket = cache.get(rating_basket_key) or set()
rating_basket.discard(film_id)
cache.set(rating_basket_key, rating_basket, cache.A_MONTH)
# delete from special basket
special_rating_basket_key = self.cache_key(cache.CACHE_SPECIAL_USER_BASKET,
user)
special_rating_basket = cache.get(special_rating_basket_key) or set()
special_rating_basket.discard(film_id)
cache.set(special_rating_basket_key, special_rating_basket, cache.A_MONTH)
def compute_fast_recommendations(user_id, send_notice=True):
from recom_helper import RecomHelper
from film20.core.models import Recommendation
from film20.showtimes.showtimes_helper import get_films
from film20.showtimes.models import Channel
from film20.showtimes.utils import get_today
from itertools import chain
import pytz
helper = RecomHelper()
user = User.objects.get(pk=user_id)
profile = user.get_profile()
for r in helper.get_ranking()[:settings.FAST_RECOMMENDATIONS_NUMBER_OF_TOP_FILMS]:
count_guessed_rate(user, r.film)
profile.recommendations_status = profile.FAST_RECOMMENDATIONS
profile.save()
from film20.core.deferred import defer
defer(compute_fast_recommendations_phase2, user_id, send_notice)
def compute_fast_recommendations(user_id, send_notice=True):
from recom_helper import RecomHelper
from film20.core.models import Recommendation
from film20.showtimes.showtimes_helper import get_films
from film20.showtimes.models import Channel
from film20.showtimes.utils import get_today
from itertools import chain
import pytz
helper = RecomHelper()
user = User.objects.get(pk=user_id)
profile = user.get_profile()
for r in helper.get_ranking()[: settings.FAST_RECOMMENDATIONS_NUMBER_OF_TOP_FILMS]:
count_guessed_rate(user, r.film)
profile.recommendations_status = profile.FAST_RECOMMENDATIONS
profile.save()
from film20.core.deferred import defer
defer(compute_fast_recommendations_phase2, user_id, send_notice)
def post_save(cls, sender, instance, *args, **kw):
from film20.import_ratings.import_ratings_helper import import_ratings
defer(import_ratings)
def recompute_recommendations(user):
if user.id:
routing_key = "%s%s.recommendations" % (settings.CELERY_QUEUE_PREFIX, settings.LANGUAGE_CODE)
defer(vue.recompute_recommendations, user, _routing_key=routing_key)
def post_commit(cls, sender, instance, created, *args, **kw):
if created:
from film20.core.deferred import defer
defer(instance._sync_with_fb, instance.id)
def post_save(cls, sender, instance, *args, **kw):
from film20.import_ratings.import_ratings_helper import import_ratings
defer(import_ratings)
def post_commit(cls, sender, instance, created, *args, **kw):
if created:
from film20.core.deferred import defer
defer(instance._sync_with_fb, instance.id)
