def channel_screenings(channel,
date,
films=None,
days=1,
past=False,
order_by=None):
date = date.replace(tzinfo=None)
to_date = date + datetime.timedelta(days=days)
key = cache.Key("channel_screenings", channel, date, to_date, films)
screenings = cache.get(key)
if screenings is None:
screenings = Screening.objects.filter(channel=channel, utc_time__gte=date, utc_time__lt=to_date)\
.order_by('film__film', 'film', 'utc_time')
screenings = dict((f, list(v)) for (f, v) in groupby(
screenings, lambda s:
(s.film.film or film_from_film_on_channel(s.film))))
if films is None:
films = sorted(screenings.keys(), cmp=__film_cmp) #
screenings = list((f, screenings[f]) for f in films if f in screenings)
cache.set(key, screenings)
comparator = _film_comparator(order_by)
if comparator:
_cmp = lambda a, b: comparator(a[0], b[0])
logger.info(screenings)
screenings = sorted(screenings, cmp=_cmp)
return screenings
def film_screenings(film, date, channels=None, days=1, past=False, type=None):
channels = channels or []
date = date.replace(tzinfo=None)
to_date = date + datetime.timedelta(days=days)
key = cache.Key("film_screenings", film.pk or film.title, date, to_date,
channels, type)
screenings = cache.get(key)
if screenings is None:
if film.pk:
q = Screening.objects.filter(film__film=film, utc_time__gte=date, utc_time__lt=to_date)\
.order_by('channel', 'utc_time')
else:
q = Screening.objects.filter(film__title=film.title, utc_time__gte=date, utc_time__lt=to_date)\
.order_by('channel', 'utc_time')
q = q.filter(channel__in=channels)
if type:
q = q.filter(channel__type=type)
q = q.select_related('film', 'film__film', 'channel')
screenings = dict(
(c, list(v)) for (c, v) in groupby(q, lambda s: s.channel))
if channels:
screenings = list(
(c, screenings[c]) for c in channels if c in screenings)
else:
channels = sorted(screenings.keys(), key=lambda c: c.name)
screenings = list((c, screenings[c]) for c in channels)
cache.set(key, screenings)
return screenings
def film_similar_ratings(request, film=None):
user = request.user
film = film or get_object_or_404(Film, id=request.GET.get('film_id'))
ratings = ()
if user.is_authenticated():
key = cache.Key("film_similar_ratings", film, user)
ratings = cache.get(key)
if ratings is None:
N_SIMILAR = 100
N = 5
query = User.objs.similar(user)[:N_SIMILAR]
similar_users = cache_query(query, "similar_users", user)
if similar_users:
d = dict((u.id, u) for u in similar_users)
ratings = Rating.objects.select_related()
ratings = list(ratings.film(film).filter(user__in=d.keys()))
ratings = sorted(ratings, key=lambda r:d[r.user_id].score)[:N]
logger.debug("%d of %d similar friends rated this film", len(ratings), N_SIMILAR)
if len(ratings)<N:
logger.debug("not enough results, executing full query")
ratings = Rating.objects.select_related()
ratings = ratings.film(film).similar_ratings(user)[0:N]
logger.debug("similar ratings fetched")
cache.set(key, ratings)
return {
'film':film,
'title':_("Similar users ratings"),
'ratings':ratings,
'friends': False
}
def threaded_messages(self, user):
cache_key = "conversation_thread_%s" % self.pk
thread = cache.get(cache_key)
if thread is not None:
return thread
query = self.messages.order_by('id')
messages = {}
root = None
for msg in query:
msg.children = []
messages[msg.id] = msg
if msg.parent_msg_id:
parent = messages.get(msg.parent_msg_id)
if parent:
msg.level = parent.level + 1
parent.children.append(msg)
else:
msg.level = 0
root = msg
def traverse(root):
yield root
for c in root.children:
for i in traverse(c):
yield i
def not_deleted(msg):
return msg.sender_id == user.id and msg.sender_deleted_at is None or \
msg.recipient_id == user.id and msg.recipient_deleted_at is None
thread = root and list(traverse(root)) or ()
thread = filter(not_deleted, thread)
cache.set(cache_key, thread)
return thread
def main_page_featured_activities(self):
"""Gets list of daily featured activities. """
#TODO add filtering by featured activities but only when featuring
# becomes automatical. http://jira.filmaster.org/browse/FLM-700
TYPES_OF_ACTIVITIES = \
getattr(settings, 'MAIN_PAGE_TYPES_OF_ACTIVITIES')
key = cache.Key('main_page_displayed_activities')
displayed = cache.get(key)
if not displayed:
activities = UserActivity.objects.public().order_by('-created_at')
displayed = []
for act_type in TYPES_OF_ACTIVITIES:
activity_type = vars(UserActivity)[act_type]
DISPLAYED_NUMBER = TYPES_OF_ACTIVITIES[act_type]
typed_activities = list(activities.filter(
activity_type=activity_type)[:DISPLAYED_NUMBER])
displayed += typed_activities
random.shuffle(displayed)
logger.info(displayed)
cache.set(key, displayed)
return displayed
def get(cls, **kw):
key = cls._create_key(**kw)
obj = cache.get(key)
if obj is None:
obj = cls.objects.get(**kw)
cache.set(key, obj)
return obj
def random_film_to_rate(request):
"""
Widget for main page (for not logged in users)
displaying a film to rate, selected from
the list of 10 most popular films.
"""
user = request.user
if user.is_authenticated():
film = Film.get_next_film_to_rate(user)
else:
key = cache.Key("popular_films_list")
popular_films = cache.get(key)
if popular_films is None:
fhelper = FilmHelper()
lang = getattr(settings, 'LANGUAGE_CODE', 'en')
if lang == 'en':
popular_films = fhelper.get_popular_films(
exclude_nonEnglish=True)
else:
popular_films = fhelper.get_popular_films()
cache.set(key, popular_films)
film = popular_films and random.choice(popular_films) or None
return {
'film': film,
}
def random_film_to_rate(request):
"""
Widget for main page (for not logged in users)
displaying a film to rate, selected from
the list of 10 most popular films.
"""
user = request.user
if user.is_authenticated():
film = Film.get_next_film_to_rate(user)
else:
key = cache.Key("popular_films_list")
popular_films = cache.get(key)
if popular_films is None:
fhelper = FilmHelper()
lang = getattr(settings, 'LANGUAGE_CODE', 'en')
if lang == 'en':
popular_films = fhelper.get_popular_films(exclude_nonEnglish=True)
else:
popular_films = fhelper.get_popular_films()
cache.set(key, popular_films)
film = popular_films and random.choice(popular_films) or None
return {
'film': film,
}
def film_user_rating(context, film, user, type='SIMPLE'):
R_TYPES = dict(Rating.ALL_RATING_TYPES)
key = cache.Key(film, user, type)
ratings = cache.get(key)
simple = True
if type == 'DETAILED':
simple = False
if not ratings:
if type == 'DETAILED':
ratings = Rating.objects.filter(film=film.id,
user=user, type__in=R_TYPES.keys(), rating__isnull=False).order_by('type').values('rating', 'type')
else:
ratings = Rating.objects.filter(film=film.id,
user=user, type=Rating.TYPE_FILM,
rating__isnull=False).values('rating', 'type')
for rate in ratings:
rate['desc'] = R_TYPES[rate['type']]
cache.set(key, ratings)
return {
'film':film,
'ratings':ratings,
'simple': simple,
}
def film_user_rating(context, film, user, type='SIMPLE'):
R_TYPES = dict(Rating.ALL_RATING_TYPES)
key = cache.Key(film, user, type)
ratings = cache.get(key)
simple = True
if type == 'DETAILED':
simple = False
if not ratings:
if type == 'DETAILED':
ratings = Rating.objects.filter(
film=film.id,
user=user,
type__in=R_TYPES.keys(),
rating__isnull=False).order_by('type').values(
'rating', 'type')
else:
ratings = Rating.objects.filter(film=film.id,
user=user,
type=Rating.TYPE_FILM,
rating__isnull=False).values(
'rating', 'type')
for rate in ratings:
rate['desc'] = R_TYPES[rate['type']]
cache.set(key, ratings)
return {
'film': film,
'ratings': ratings,
'simple': simple,
}
def threaded_messages(self, user):
cache_key = "conversation_thread_%s" % self.pk
thread = cache.get(cache_key)
if thread is not None:
return thread
query = self.messages.order_by('id')
messages = {}
root = None
for msg in query:
msg.children = []
messages[msg.id] = msg
if msg.parent_msg_id:
parent = messages.get(msg.parent_msg_id)
if parent:
msg.level = parent.level + 1
parent.children.append(msg)
else:
msg.level = 0
root = msg
def traverse(root):
yield root
for c in root.children:
for i in traverse(c):
yield i
def not_deleted(msg):
return msg.sender_id == user.id and msg.sender_deleted_at is None or \
msg.recipient_id == user.id and msg.recipient_deleted_at is None
thread = root and list(traverse(root)) or ()
thread = filter(not_deleted, thread)
cache.set(cache_key, thread)
return thread
def film_similar_ratings(request, film=None):
user = request.user
film = film or get_object_or_404(Film, id=request.GET.get('film_id'))
ratings = ()
if user.is_authenticated():
key = cache.Key("film_similar_ratings", film, user)
ratings = cache.get(key)
if ratings is None:
N_SIMILAR = 100
N = 5
query = User.objs.similar(user)[:N_SIMILAR]
similar_users = cache_query(query, "similar_users", user)
if similar_users:
d = dict((u.id, u) for u in similar_users)
ratings = Rating.objects.select_related()
ratings = list(ratings.film(film).filter(user__in=d.keys()))
ratings = sorted(ratings, key=lambda r: d[r.user_id].score)[:N]
logger.debug("%d of %d similar friends rated this film",
len(ratings), N_SIMILAR)
if len(ratings) < N:
logger.debug("not enough results, executing full query")
ratings = Rating.objects.select_related()
ratings = ratings.film(film).similar_ratings(user)[0:N]
logger.debug("similar ratings fetched")
cache.set(key, ratings)
link = film.get_absolute_url()
link = str(link) + '?u=similar'
return {
'film': film,
'title': _("Similar users ratings"),
'link': link,
'ratings': ratings,
'friends': False
}
def get(cls, **kw):
key = cls._create_key(**kw)
obj = cache.get(key)
if obj is None:
obj = cls.objects.get(**kw)
cache.set(key, obj)
return obj
def film_screenings(film, date, channels=None, days=1, past=False, type=None):
channels = channels or []
date = date.replace(tzinfo=None)
to_date = date + datetime.timedelta(days=days)
key = cache.Key("film_screenings", film.pk or film.title, date, to_date, channels, type)
screenings = cache.get(key)
if screenings is None:
if film.pk:
q = Screening.objects.filter(film__film=film, utc_time__gte=date, utc_time__lt=to_date)\
.order_by('channel', 'utc_time')
else:
q = Screening.objects.filter(film__title=film.title, utc_time__gte=date, utc_time__lt=to_date)\
.order_by('channel', 'utc_time')
q = q.filter(channel__in=channels)
if type:
q = q.filter(channel__type=type)
q = q.select_related('film', 'film__film', 'channel')
screenings = dict( (c, list(v)) for (c, v) in groupby(q, lambda s:s.channel) )
if channels:
screenings = list( (c, screenings[c]) for c in channels if c in screenings )
else:
channels = sorted(screenings.keys(), key=lambda c:c.name)
screenings = list( (c, screenings[c]) for c in channels )
cache.set(key, screenings)
return screenings
def in_town(self, town):
key = cache.Key("town_theaters", town)
channels = cache.get(key)
if channels is None:
channels = self.theaters().filter(town=town).order_by('name')
channels = list(channels.select_related('town'))
cache.set(key, channels)
return channels
def _tagged_film_ids(cls, tags):
key = cache.Key('tagged_films', tags)
ids = cache.get(key)
if ids is None:
ids = set(Film.objects.tagged(tags).values_list('id', flat=True))
logger.info("%s ids: %r", tags, ids)
cache.set(key, ids)
return ids
def _tagged_film_ids(cls, tags):
key = cache.Key('tagged_films', tags)
ids = cache.get(key)
if ids is None:
ids = set(Film.objects.tagged(tags).values_list('id', flat=True))
logger.info("%s ids: %r", tags, ids)
cache.set(key, ids)
return ids
def in_town(self, town):
key = cache.Key("town_theaters", town)
channels = cache.get(key)
if channels is None:
channels = self.theaters().filter(town=town).order_by('name')
channels = list(channels.select_related('town'))
cache.set(key, channels)
return channels
def unread_counter(self, user):
key = cache.Key("conversation_unread_counter", user.id)
cnt = cache.get(key)
if cnt is None:
query = self.filter(models.Q(sender=user, sender_cnt__gt=0, sender_unread_cnt__gt=0) | \
models.Q(recipient=user, recipient_cnt__gt=0, recipient_unread_cnt__gt=0))
cnt = query.distinct().count()
cache.set(key, cnt)
return cnt
def unread_counter(self, user):
key = cache.Key("conversation_unread_counter", user.id)
cnt = cache.get(key)
if cnt is None:
query = self.filter(models.Q(sender=user, sender_cnt__gt=0, sender_unread_cnt__gt=0) | \
models.Q(recipient=user, recipient_cnt__gt=0, recipient_unread_cnt__gt=0))
cnt = query.distinct().count()
cache.set(key, cnt)
return cnt
def get_main_related_film(self):
cache_key = cache.Key('film_related', self.permalink)
self.main_related_film = cache.get(cache_key)
if not self.main_related_film:
all_related_films= Film.objects.filter(id__in=self.related_film.all())
if all_related_films:
if len(all_related_films) == 1:
self.main_related_film = all_related_films[0]
cache.set(cache_key, self.main_related_film)
return self.main_related_film
def default_tv(self, country_code):
key = cache.Key("default_tv", country_code)
ret = cache.get(key)
if ret is None:
if country_code not in settings.COUNTRIES_WITH_SHOWTIMES:
ret = ()
else:
ret = list(self.tv().filter(country__code=country_code, is_active=True, is_default=True))
cache.set(key, ret)
return ret
def top_personalized_recommendations(request):
user = request.user
has_location = user.is_authenticated() and user.get_profile().has_location(
)
cinema_films = []
tv_films = []
today = get_today(request.timezone)
a_day = datetime.timedelta(days=1)
key = cache.Key("top_personalized_recommendations", today, request.user)
films = cache.get(key)
if films is None:
cinemas = showtimes_helper.get_theaters(request)
tvs = showtimes_helper.get_tv_channels(request)
# How many days ahead we want to check
PERSONALIZED_CINEMA_DAYS = settings.PERSONALIZED_CINEMA_DAYS
PERSONALIZED_TV_DAYS = settings.PERSONALIZED_TV_DAYS
# How many films we want to get
PERS_CINEMA_NUMBER = settings.PERSONALIZED_CINEMA_FILMS_NUMBER
PERS_TV_NUMBER = settings.PERSONALIZED_TV_FILMS_NUMBER
# We get films sorted by personal taste of user
if cinemas:
cinema_films = showtimes_helper.collect_unique_films(
today,
cinemas,
PERS_CINEMA_NUMBER,
settings.PERSONALIZED_CINEMA_DAYS,
user=user)
if tvs:
tv_films = showtimes_helper.collect_unique_films(
today,
tvs,
PERS_TV_NUMBER,
settings.PERSONALIZED_TV_DAYS,
user=user)
films = (cinema_films, tv_films)
cache.set(key, films)
(cinema_films, tv_films) = films
display = (not has_location) | bool(tv_films) | bool(cinema_films)
return {
'display': display,
'has_location': has_location,
'tv_films': tv_films,
'cinema_films': cinema_films,
}
def _user_film_recommendations(user, ids):
if not ids:
return {}
ids = sorted(ids)
key = cache.Key("user_recommendations", user, ids)
recommendations = cache.get(key)
if recommendations is None:
recommendations = dict((r.film_id, r.guess_rating_alg2)
for r in Recommendation.objects.filter(user=user, film__in=ids))
cache.set(key, recommendations)
return recommendations
def get_main_related_film(self):
cache_key = cache.Key('film_related', self.permalink)
self.main_related_film = cache.get(cache_key)
if not self.main_related_film:
all_related_films = Film.objects.filter(
id__in=self.related_film.all())
if all_related_films:
if len(all_related_films) == 1:
self.main_related_film = all_related_films[0]
cache.set(cache_key, self.main_related_film)
return self.main_related_film
def iterator(self):
items = super(QuerySet, self).iterator()
cache_prefix, cache_timeout = getattr(self, 'cache_params', (None, None))
cache_key = self._make_key()
if cache_key:
result = cache.get(cache_key)
if result is None:
result = list(items)
cache.set(cache_key, result, cache_timeout)
items = iter(result)
return self.postprocess_query(items)
def user_basket(cls, user):
if not hasattr(user, '_basket'):
key = cache.Key("user_basket", user)
user._basket = cache.get(key)
if user._basket is None:
basket = BasketItem.objects.filter(user=user)\
.filter(Q(wishlist__isnull=False) | Q(owned__isnull=False))
user._basket = dict(
(b.film_id, (b.wishlist, b.owned)) for b in basket
)
cache.set(key, user._basket)
return user._basket
def default_tv(self, country_code):
key = cache.Key("default_tv", country_code)
ret = cache.get(key)
if ret is None:
if country_code not in settings.COUNTRIES_WITH_SHOWTIMES:
ret = ()
else:
ret = list(self.tv().filter(country__code=country_code,
is_active=True,
is_default=True))
cache.set(key, ret)
return ret
def related_articles(activity, user):
""" Displays list of related articles """
MAX_RELATED_ARTICLES = getattr(settings, 'MAX_RELATED_ARTICLES')
key = cache.Key("related_posts", activity)
related_posts = cache.get(key)
if not related_posts:
related_posts = get_related_posts(activity, user, MAX_RELATED_ARTICLES)
cache.set(key, related_posts, cache.A_DAY)
return {'related_posts': related_posts}
def get_town_films(cls, town_id, date, to_date, tags=None):
extra = tags and (tags,) or ()
key = cache.Key("showtimes_town_films", date, to_date, town_id, *extra)
films = cache.get(key)
if films is None:
s = cls.get_screenings(date, to_date, tags)
s = s.filter(channel__type=1)
s = list(s.filter(channel__town=town_id))
films = cls._get_films(s)
timeout = not s and settings.SHOWTIMES_EMPTY_CACHE_TIMEOUT or None
cache.set(key, films, timeout)
return films
def get_similar_users_list(self, request):
users = []
if request.user.is_authenticated():
key = cache.Key('similar_users_list', request.user)
similar_users_list = cache.get(key)
if not similar_users_list:
similar_users_list = RatingComparator.objects.filter(main_user=request.user, score__lte=SIMILAR_USER_LEVEL).select_related('user')
cache.set(key, similar_users_list)
if similar_users_list:
for similar_user in similar_users_list:
users.append(similar_user.compared_user)
return users
def related_articles(activity, user):
""" Displays list of related articles """
MAX_RELATED_ARTICLES = getattr(settings, 'MAX_RELATED_ARTICLES')
key = cache.Key("related_posts", activity)
related_posts = cache.get(key)
if not related_posts:
related_posts = get_related_posts(activity, user, MAX_RELATED_ARTICLES)
cache.set(key, related_posts, cache.A_DAY)
return {'related_posts': related_posts}
def get_town_films(cls, town_id, date, to_date, tags=None):
extra = tags and (tags, ) or ()
key = cache.Key("showtimes_town_films", date, to_date, town_id, *extra)
films = cache.get(key)
if films is None:
s = cls.get_screenings(date, to_date, tags)
s = s.filter(channel__type=1)
s = list(s.filter(channel__town=town_id))
films = cls._get_films(s)
timeout = not s and settings.SHOWTIMES_EMPTY_CACHE_TIMEOUT or None
cache.set(key, films, timeout)
return films
def __init__(self, country_code, show_nearby, *args, **kw):
super(SelectTownForm, self).__init__(*args, **kw)
key = cache.Key("country_towns", country_code)
if country_code in settings.COUNTRIES_WITH_SHOWTIMES:
self.towns = cache.get(key)
if not self.towns:
self.towns = Town.objects_with_cinemas.filter(country__code=country_code)
cache.set(key, self.towns)
else:
self.towns = ()
choices = show_nearby and [('', _('Nearby'))] or []
choices.extend((t.id, t.name) for t in self.towns)
self.fields['city'].choices = choices
def top_recommendations_all(context, films_number=4):
"""
Displays user's top recommended movies
(most popular for not logged in).
"""
POPULAR_FILMS_NUMBER_ALL = getattr(settings,
'POPULAR_FILMS_MAIN_PAGE_NUMBER_ALL')
user = context.get('recommendations_user', context['request'].user)
key = cache.Key("popular_films_main_page", user)
films = cache.get(key)
if (not films) or len(films) < films_number:
key_all = cache.Key("popular_films_main_page_all", user)
all_films = cache.get(key_all)
if not all_films:
has_recommendations = user.is_authenticated() and \
user.get_profile().recommendations_status
if has_recommendations:
recom_helper = RecomHelper()
all_films = list(
recom_helper.get_best_psi_films_queryset(user)
[:POPULAR_FILMS_NUMBER_ALL])
else:
fhelper = FilmHelper()
all_films = list(
fhelper.get_popular_films(
number_of_films=POPULAR_FILMS_NUMBER_ALL,
exclude_nonEnglish=True))
cache.set(key_all, all_films, cache.A_MONTH)
# Select random few films
random.shuffle(all_films)
films = all_films[:films_number]
cache.set(key, films, cache.A_QUARTER)
return films[:films_number]
def iterator(self):
items = super(QuerySet, self).iterator()
cache_prefix, cache_timeout = getattr(self, 'cache_params',
(None, None))
cache_key = self._make_key()
if cache_key:
result = cache.get(cache_key)
if result is None:
result = list(items)
cache.set(cache_key, result, cache_timeout)
items = iter(result)
return self.postprocess_query(items)
def top_recommendations_all(context, films_number=4):
"""
Displays user's top recommended movies
(most popular for not logged in).
"""
POPULAR_FILMS_NUMBER_ALL = getattr(settings,
'POPULAR_FILMS_MAIN_PAGE_NUMBER_ALL')
user = context['request'].user
key = cache.Key("popular_films_main_page", user)
films = cache.get(key)
if (not films) or len(films) < films_number:
key_all = cache.Key("popular_films_main_page_all", user)
all_films = cache.get(key_all)
if not all_films:
has_recommendations = user.is_authenticated() and \
user.get_profile().recommendations_status
if has_recommendations:
recom_helper = RecomHelper()
all_films = list(recom_helper.get_best_psi_films_queryset(
user_id = user.id, offset=0,
limit=POPULAR_FILMS_NUMBER_ALL))
else:
fhelper = FilmHelper()
all_films = list(fhelper.get_popular_films(
number_of_films=POPULAR_FILMS_NUMBER_ALL,
exclude_nonEnglish=True))
cache.set(key_all, all_films, cache.A_MONTH)
# Select random few films
random.shuffle(all_films)
films = all_films[:films_number]
cache.set(key, films, cache.A_QUARTER)
return films[:films_number]
def render(self, context):
key = cache.Key("all-comments-tag", self.object.resolve(context))
query = cache.get(key)
if query is None:
query = ThreadedComment.objects.select_related().\
filter(object_id=self.object.resolve(context),
status=ThreadedComment.PUBLIC_STATUS).\
order_by('date_submitted')
cache.set(key, query)
context[self.context_name] = query
return ''
else:
context[self.context_name] = query
return ''
def __init__(self, country_code, show_nearby, *args, **kw):
super(SelectTownForm, self).__init__(*args, **kw)
key = cache.Key("country_towns", country_code)
if country_code in settings.COUNTRIES_WITH_SHOWTIMES:
self.towns = cache.get(key)
if not self.towns:
self.towns = Town.objects_with_cinemas.filter(
country__code=country_code)
cache.set(key, self.towns)
else:
self.towns = ()
choices = show_nearby and [('', _('Nearby'))] or []
choices.extend((t.id, t.name) for t in self.towns)
self.fields['city'].choices = choices
def get_checkins(self):
date = self.utc_time.date()
to_date = date + datetime.timedelta(days=1)
if not hasattr(self, '_checkins'):
cache_key = cache.Key("checkins", date, self.channel_id)
self._checkins = cache.get(cache_key)
if self._checkins is None:
ss = ScreeningCheckIn.objects.filter(
screening__utc_time__gte=date,
screening__utc_time__lt=to_date).\
order_by('screening__id', 'created_at').select_related('screening', 'user')
self._checkins = dict((k, list(g)) for k, g in groupby(ss, lambda s:s.screening))
cache.set(cache_key, self._checkins)
return self._checkins.get(self, [])
def get_country_tv_films(cls, country_id, date, to_date, tags=None):
extra = tags and (tags,) or ()
key = cache.Key("showtimes_country_tv_films", date, to_date, country_id, *extra)
films = cache.get(key)
if films is None:
s = cls.get_screenings(date, to_date, tags)
s = s.filter(film__film__isnull=False)
s = s.filter(channel__type=2)
s = s.filter(film__is_tv_series=False)
s = list(s.filter(channel__country=country_id))
films = cls._get_films(s)
timeout = not s and settings.SHOWTIMES_EMPTY_CACHE_TIMEOUT or None
cache.set(key, films, timeout)
return films
def render(self, context):
key = cache.Key("all-comments-tag", self.object.resolve(context))
query = cache.get(key)
if query is None:
query = ThreadedComment.objects.select_related().\
filter(object_id=self.object.resolve(context),
status=ThreadedComment.PUBLIC_STATUS).\
order_by('date_submitted')
cache.set(key, query)
context[self.context_name] = query
return ''
else:
context[self.context_name] = query
return ''
def selected_by(self, user, type=TYPE_CINEMA):
if not user.is_authenticated():
return ()
profile = user.get_profile()
if profile.country not in settings.COUNTRIES_WITH_SHOWTIMES:
return ()
key = cache.Key("user_channels", user)
channels = cache.get(key)
if channels is None:
channels = Channel.objects.filter(selected_by=user, is_active=True, country__code=profile.country)
channels = channels.order_by('type', 'userchannel__distance', 'name')
channels = channels.extra(select={"distance":"showtimes_userchannel.distance"})
channels = channels.select_related('town')
cache.set(key, channels)
return [c for c in channels if (c.type & type)]
def get_country_tv_films(cls, country_id, date, to_date, tags=None):
extra = tags and (tags, ) or ()
key = cache.Key("showtimes_country_tv_films", date, to_date,
country_id, *extra)
films = cache.get(key)
if films is None:
s = cls.get_screenings(date, to_date, tags)
s = s.filter(film__film__isnull=False)
s = s.filter(channel__type=2)
s = s.filter(film__is_tv_series=False)
s = list(s.filter(channel__country=country_id))
films = cls._get_films(s)
timeout = not s and settings.SHOWTIMES_EMPTY_CACHE_TIMEOUT or None
cache.set(key, films, timeout)
return films
def top_personalized_recommendations(request):
user = request.user
has_location = user.is_authenticated() and user.get_profile().has_location()
cinema_films = []
tv_films = []
today = get_today(request.timezone)
a_day = datetime.timedelta(days=1)
key = cache.Key("top_personalized_recommendations", today, request.user)
films = cache.get(key)
if films is None:
cinemas = showtimes_helper.get_theaters(request)
tvs = showtimes_helper.get_tv_channels(request)
# How many days ahead we want to check
PERSONALIZED_CINEMA_DAYS = settings.PERSONALIZED_CINEMA_DAYS
PERSONALIZED_TV_DAYS = settings.PERSONALIZED_TV_DAYS
# How many films we want to get
PERS_CINEMA_NUMBER = settings.PERSONALIZED_CINEMA_FILMS_NUMBER
PERS_TV_NUMBER = settings.PERSONALIZED_TV_FILMS_NUMBER
# We get films sorted by personal taste of user
if cinemas:
cinema_films = showtimes_helper.collect_unique_films(
today, cinemas, PERS_CINEMA_NUMBER,
settings.PERSONALIZED_CINEMA_DAYS, user=user)
if tvs:
tv_films = showtimes_helper.collect_unique_films(
today, tvs, PERS_TV_NUMBER,
settings.PERSONALIZED_TV_DAYS, user=user)
films = (cinema_films, tv_films)
cache.set(key, films)
(cinema_films, tv_films) = films
display = (not has_location) | bool(tv_films) | bool(cinema_films)
return {
'display': display,
'has_location': has_location,
'tv_films': tv_films,
'cinema_films': cinema_films,
}
def random_top_movie():
"""Displays some random popular movie on Filmaster."""
key = cache.Key("popular_films")
popular_films = cache.get(key)
if popular_films is None:
# Get most popular films
fhelper = FilmHelper()
popular_films = list(fhelper.get_popular_films(
exclude_nonEnglish=True))
cache.set(key, popular_films)
random.shuffle(popular_films)
if len(popular_films) > 0:
return {'movie': popular_films[0]}
else:
return {'movie': None}
def random_top_movie():
"""Displays some random popular movie on Filmaster."""
key = cache.Key("popular_films")
popular_films = cache.get(key)
if popular_films is None:
# Get most popular films
fhelper = FilmHelper()
popular_films = list(
fhelper.get_popular_films(exclude_nonEnglish=True))
cache.set(key, popular_films)
random.shuffle(popular_films)
if len(popular_films) > 0:
return {'movie': popular_films[0]}
else:
return {'movie': None}
def get_checkins(self):
date = self.utc_time.date()
to_date = date + datetime.timedelta(days=1)
if not hasattr(self, '_checkins'):
cache_key = cache.Key("checkins", date, self.channel_id)
self._checkins = cache.get(cache_key)
if self._checkins is None:
ss = ScreeningCheckIn.objects.filter(
screening__utc_time__gte=date,
screening__utc_time__lt=to_date).\
order_by('screening__id', 'created_at').select_related('screening', 'user')
self._checkins = dict(
(k, list(g))
for k, g in groupby(ss, lambda s: s.screening))
cache.set(cache_key, self._checkins)
return self._checkins.get(self, [])
def get_avatar_path(user, size, **kw):
url = None
is_username = isinstance(user, basestring)
if settings.CACHE_AVATARS:
key = cache.Key("avatar", str(user), str(size))
url = cache.get(key)
# FLM-694
if url is not None and not os.path.exists( os.path.join( settings.MEDIA_ROOT, url ) ):
logger.debug( "cached avatar %s does not exists ! [REMOVING]" % url )
url = None
cache.delete(key)
if not url:
avatar_path = DEFAULT_AVATAR
try:
# if is_username is True, user variable is username as text, used by
# useractivities
if is_username:
avatar = Avatar.objects.get(user__username=user, valid=True).image
else:
avatar = Avatar.objects.get(user=user, valid=True).image
if avatar:
path = os.path.join(settings.MEDIA_ROOT, unicode(avatar))
if os.path.isfile(path):
avatar_path = path
except Avatar.DoesNotExist:
pass
path, ext = os.path.splitext(avatar_path)
thumb_path = "%s.%s%s" % (path, size, ext)
valid = True
if not os.path.isfile(thumb_path):
try:
image = Image.open(avatar_path)
image.thumbnail((size, size), Image.ANTIALIAS)
image.save(thumb_path, "JPEG")
logger.debug("new avatar generated: %s", thumb_path)
except IOError, e:
logger.warning(e)
valid = False
url = thumb_path.replace(settings.MEDIA_ROOT, '')
# eventually cache (if caching allowed)
if settings.CACHE_AVATARS and valid and url:
cache.set(key, url)
logger.debug("Storing avatar in cache under %s" % key)
def top_recommendations_cinema(context, films_number=4):
"""
Displays user's top recommended movies in cinemas
(most popular for not logged in).
"""
request = context['request']
user = request.user
key = cache.Key("cinema_user_recommended", user)
films = cache.get(key)
if films is None:
channels = get_theaters(request)
now = get_today(request.timezone)
films = collect_unique_films(now, channels, films_number, days=3, user=user)
cache.set(key, films)
return films
def comment_form_url(activity, app_label, model):
"""
Returns url planet comment form
"""
key = cache.Key("planet-comment-form", app_label, model)
content_type = cache.get(key)
if content_type is None:
content_type = ContentType.objects.get(app_label=app_label, model=model).id
cache.set(key, content_type)
kwargs = {
'content_type' : content_type,
'object_id' : activity.object_id,
}
return reverse('tc_comment', kwargs=kwargs)
def users_shitlist(user):
""" Displays on sidebar, movies user doesn't want to watch."""
key = cache.Key("user_shitlist_sidebar", user)
movies = cache.get(key)
NUMBER_OF_MOVIES_SHITLIST_SIDEBAR = \
getattr(settings, 'NUMBER_OF_MOVIES_SHITLIST_SIDEBAR')
if not movies:
movies = [item.film for item in BasketItem.objects.filter(user=user,
wishlist=BasketItem.NOT_INTERESTED)\
[:NUMBER_OF_MOVIES_SHITLIST_SIDEBAR + 1]]
cache.set(key, movies, 3 * cache.CACHE_HOUR)
show_more = len(movies) == NUMBER_OF_MOVIES_SHITLIST_SIDEBAR + 1
movies = movies[:NUMBER_OF_MOVIES_SHITLIST_SIDEBAR]
return {'movies': movies, 'show_more': show_more, 'act_user': user}
def users_shitlist(user):
""" Displays on sidebar, movies user doesn't want to watch."""
key = cache.Key("user_shitlist_sidebar", user)
movies = cache.get(key)
NUMBER_OF_MOVIES_SHITLIST_SIDEBAR = \
getattr(settings, 'NUMBER_OF_MOVIES_SHITLIST_SIDEBAR')
if not movies:
movies = [item.film for item in BasketItem.objects.filter(user=user,
wishlist=BasketItem.NOT_INTERESTED)\
[:NUMBER_OF_MOVIES_SHITLIST_SIDEBAR + 1]]
cache.set(key, movies, 3 * cache.CACHE_HOUR)
show_more = len( movies ) == NUMBER_OF_MOVIES_SHITLIST_SIDEBAR + 1
movies = movies[:NUMBER_OF_MOVIES_SHITLIST_SIDEBAR]
return {'movies': movies, 'show_more': show_more, 'act_user': user }
def users_best_rated(user):
"""Displays user's top rated movies."""
cache_key = cache.Key("profile_page_best_films", user)
best_movies = cache.get(cache_key)
NUMBER_OF_USER_BEST_FILMS = \
getattr(settings, 'NUMBER_OF_USER_BEST_FILMS')
if not best_movies:
fhelper = FilmHelper()
best_movies = fhelper.get_users_best_films(user,
NUMBER_OF_USER_BEST_FILMS + 1)
cache.set(cache_key, best_movies)
show_more = len( best_movies ) == NUMBER_OF_USER_BEST_FILMS + 1
best_movies = best_movies[:NUMBER_OF_USER_BEST_FILMS]
return {'movies': best_movies, 'show_more': show_more, 'act_user': user }
def users_best_rated(user):
"""Displays user's top rated movies."""
cache_key = cache.Key("profile_page_best_films", user)
best_movies = cache.get(cache_key)
NUMBER_OF_USER_BEST_FILMS = \
getattr(settings, 'NUMBER_OF_USER_BEST_FILMS')
if not best_movies:
fhelper = FilmHelper()
best_movies = fhelper.get_users_best_films(
user, NUMBER_OF_USER_BEST_FILMS + 1)
cache.set(cache_key, best_movies)
show_more = len(best_movies) == NUMBER_OF_USER_BEST_FILMS + 1
best_movies = best_movies[:NUMBER_OF_USER_BEST_FILMS]
return {'movies': best_movies, 'show_more': show_more, 'act_user': user}
def selected_by(self, user, type=TYPE_CINEMA):
if not user.is_authenticated():
return ()
profile = user.get_profile()
if profile.country not in settings.COUNTRIES_WITH_SHOWTIMES:
return ()
key = cache.Key("user_channels", user)
channels = cache.get(key)
if channels is None:
channels = Channel.objects.filter(selected_by=user,
is_active=True,
country__code=profile.country)
channels = channels.order_by('type', 'userchannel__distance',
'name')
channels = channels.extra(
select={"distance": "showtimes_userchannel.distance"})
channels = channels.select_related('town')
cache.set(key, channels)
return [c for c in channels if (c.type & type)]
def top_recommendations_cinema(context, films_number=4):
"""
Displays user's top recommended movies in cinemas
(most popular for not logged in).
"""
request = context['request']
user = context.get('recommendations_user', context['request'].user)
key = cache.Key("cinema_user_recommended", user)
films = cache.get(key)
if films is None:
channels = get_theaters(request)
now = get_today(request.timezone)
films = collect_unique_films(now,
channels,
films_number,
days=3,
user=user)
cache.set(key, films)
return films
