def edit_location(request):
"""
Location selection of the user profile
"""
profile = request.user.get_profile()
if request.method == "POST":
form = LocationForm(request.POST, instance=profile)
if form.is_valid():
form.save()
if profile.any_field_changed('latitude', 'longitude'):
messages.add_message(request, messages.INFO,
_("Your new location has been set"))
# invalidate personalized recommendations in area cache
cache.delete(
cache.Key("top_personalized_recommendations", request.user))
cache.delete(cache.Key("tv_user_recommended", request.user))
cache.delete(cache.Key("cinema_user_recommended", request.user))
next = request.GET.get('next')
if next:
return HttpResponseRedirect(next)
else:
form = LocationForm(instance=profile)
template = "usersettings/edit_location.html"
data = {
'section': 'location',
'form': form,
}
return render(request, template, data)
def post(self, *args, **kw):
key = cache.Key("questions_", self.request.unique_user)
questions = cache.get(key)
if "start" not in self.request.POST:
self.check_answer(time.time())
if not questions:
return self.on_end_questions()
question = questions.pop()
if question:
cache.delete(key) # delete cache for questions
cache.set(key, questions) # set cache for questions-1
key = cache.Key("answer_", self.request.unique_user)
cache.set(key, question) # set cache for user answer
context = self.get_context_data()
context.update({
'question': question or [],
'tstamp': time.time(),
'progress': (100-len(questions)*10),
'answered': 10-len(questions)
})
return render(self.request, self.template_name, context )
def invalidate_cache(self):
cache.delete(cache.Key("open_festivals"))
cache.delete(cache.Key("festival_theaters", self))
cache.delete(cache.Key("festival_screening_dates", self))
cache.delete(cache.Key("festival_participants", self))
cache.delete(cache.Key("festival_films", self))
cache.delete(cache.Key("festival_screening_set", self))
cache.delete(cache.Key("festival_screening_set", self, True))
cache.delete(cache.Key("festival_screening_set", self, False))
for date in self.get_screening_dates():
cache.delete(cache.Key("festival_screenings", self, date))
def get_screening_set(self, past=False):
key = cache.Key("festival_screening_set", self, past)
screening_set = cache.get(key)
if screening_set is None:
screening_set = FestivalScreeningSet(self, past=past)
cache.set(key, screening_set)
return screening_set
def get_country_and_tz_by_lat_lng(lat, lng):
key = cache.Key('country_tz', lat, lng)
data = cache.get(key)
if data is None:
data = _get_country_and_tz_by_lat_lng(lat, lng)
cache.set(key, data)
return data
def latest_checkins():
"""
Widget for main page (for unregistered users) displaying X
random check-ins by Filmaster users.
"""
key = cache.Key("latest-checkins")
latest = cache.get(key)
NUMBER_OF_LATEST_CHECKINS = getattr(settings, 'NUMBER_OF_LATEST_CHECKINS',
10)
NUMBER_OF_CHECKINS_AT_MAIN_PAGE = getattr(
settings, 'NUMBER_OF_CHECKINS_AT_MAIN_PAGE', 4)
if not latest:
now = datetime.now()
ago = now - timedelta(hours=3)
checkins = UserActivity.objects.all_checkins().order_by('-created_at')
latest = list(
checkins.filter(created_at__gte=ago)[:NUMBER_OF_LATEST_CHECKINS])
if len(latest) < NUMBER_OF_CHECKINS_AT_MAIN_PAGE:
latest = list(checkins)[:NUMBER_OF_LATEST_CHECKINS]
cache.set(key, latest, cache.CACHE_HOUR * 3)
try:
latest = random.sample(latest, NUMBER_OF_CHECKINS_AT_MAIN_PAGE)
except ValueError:
latest = latest[:NUMBER_OF_CHECKINS_AT_MAIN_PAGE]
return {
'activities': latest,
}
def latest_ratings():
"""
Widget for main page (for unregistered users)
displaying X random ratings by Filmaster users.
"""
key = cache.Key("latest_ratings")
ratings = cache.get(key)
NUMBER_OF_LATEST_RATINGS = getattr(settings, 'NUMBER_OF_LATEST_RATINGS',
10)
NUMBER_OF_RATINGS_AT_MAIN_PAGE = getattr(settings,
'NUMBER_OF_RATINGS_AT_MAIN_PAGE',
4)
if not ratings:
ratings = UserActivity.objects.all_ratings().\
order_by('-created_at')[:NUMBER_OF_LATEST_RATINGS]
cache.set(key, ratings, cache.A_DAY)
try:
ratings = random.sample(ratings, NUMBER_OF_RATINGS_AT_MAIN_PAGE)
except ValueError:
ratings = ratings[:NUMBER_OF_RATINGS_AT_MAIN_PAGE]
return {
'activities': ratings,
}
def regional_info(context):
"""
Display local info
"""
slug_city = None
slug_region = None
request = context['request']
user = request.user
if user.is_authenticated():
profile = user.get_profile()
try:
slug_city = slughifi(profile.location)
except AttributeError:
slug_city = None
if not slug_city:
try:
city = request.city
except AttributeError:
city = None
slug_city = city and slughifi(city) or None
key = cache.Key(CACHE_REGIONAL_INFO, slug_city)
regional_info_obj = cache.get(key)
if regional_info_obj is None and slug_city is not None:
regional_info_obj = get_regional_info_obj(slug_city)
cache.set(key, regional_info_obj)
return {
'regional_info': regional_info_obj,
}
def get_films_to_rate(self, number_of_films=1, tag=None):
key = cache.Key("vue_rater_user_films", self.user)
user_films = cache.get(key)
if user_films is None:
user_films = vue.get_ordered_known_film_ids()
if self.SHUFFLE_BLOCK_SIZE:
shuffled = []
while user_films:
block = user_films[:self.SHUFFLE_BLOCK_SIZE]
user_films = user_films[self.SHUFFLE_BLOCK_SIZE:]
random.shuffle(block)
shuffled.extend(block)
user_films = shuffled
cache.set(key, user_films)
excluded = self.get_excluded_films()
out = []
for film_id in user_films:
if film_id not in excluded:
out.append(film_id)
if len(out) >= number_of_films:
break
out = [Film.get(id=id) for id in out]
return out
def clear_filmaster_recommends_cache(sender, instance, **kw):
"""
If flat page is saved clear filmaster_recommends cache
"""
if instance.url == FLATPAGE_FILMASTER_RECOMMENDS:
key = cache.Key(FLATPAGE_FILMASTER_RECOMMENDS)
cache.delete(key)
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
def change_user_display_name(user):
logger.info("check display name for user %s" % user)
from film20.core.models import Profile
profile = Profile.objects.get(user = user)
logger.info("get profile: %s" % profile)
key = cache.Key("display_name_profile", user.id)
cache.delete(key)
logger.info("end of username changes")
def get_fragments(self):
key = cache.Key("fragments-set-%s" % self.key)
fragments = cache.get(key)
if fragments is None:
fragments = Fragment.objects.filter(key=self.key)
cache.set(key, fragments, cache.A_MONTH)
return fragments
def get_open_festivals(self):
key = cache.Key("open_festivals")
festivals = cache.get(key)
if festivals is None:
festivals = Festival.objects.filter(event_status=self.STATUS_OPEN)
festivals = list(festivals)
cache.set(key, festivals)
return festivals
def __init__(self, queryset, page_size):
self.queryset = queryset.order_by('id')
key = cache.Key("sitemap_paginator", str(self.queryset.query))
self.ids = cache.get(key)
if self.ids is None:
self.ids = list(self.queryset.values_list('id',
flat=True))[::page_size]
cache.set(key, self.ids)
self.num_pages = len(self.ids)
def get_films(self):
key = cache.Key("festival_films", self)
films = cache.get(key)
if films is None:
films = Film.objects.tagged(self.tag.lower())
films = list(films[:1000])
Film.update_ranking(films)
cache.set(key, films)
return films
def get_theaters(self):
key = cache.Key("festival_theaters", self)
theaters = cache.get(key)
if theaters is None:
from film20.tagging.models import TaggedItem
channels = self.theaters.all()
theaters = list(Channel.objects.theaters().filter(id__in=channels))
cache.set(key, theaters)
return theaters
def get_user(self, user_id):
key = cache.Key("user", user_id)
user = settings.CACHED_USERS and cache.get(key) or None
if not user:
try:
user = super(CachedModelBackend, self).get_user(user_id)
if settings.CACHED_USERS:
cache.set(key, user)
except User.DoesNotExist, e:
pass
def matching_film_ids(self, include_ids, exclude_ids):
key = cache.Key("features_film_ids", include_ids, exclude_ids)
film_ids = cache.get(key)
if film_ids is None:
film_ids = Film.objects.filter(features__type__in=include_ids)
if exclude_ids:
film_ids = film_ids.exclude(features__type__in=exclude_ids)
film_ids = set(film_ids.values_list('id', flat=True))
cache.set(key, film_ids)
return film_ids
def get_unliked_film_ids(cls, user):
if not user.id:
return ()
key = cache.Key("unliked_recommendations", user.id)
ret = cache.get(key)
if ret is None:
ret = cls.objects.filter(user=user, vote=0).values_list('film_id',
flat=True)
cache.set(key, ret)
return ret
def tvchannels(request):
"""
user TVChannel selection view
"""
from forms import TVChannelsForm
from film20.showtimes.models import TYPE_TV_CHANNEL, UserChannel
profile = request.user.get_profile()
user_channels = list(
u.pk
for u in request.user.selected_channels.filter(type=TYPE_TV_CHANNEL))
queryset = Channel.objects.tv().filter(is_active=True)
if profile.country:
queryset = queryset.filter(country__code=profile.country)
is_post = request.method == 'POST'
form = TVChannelsForm(request.POST if is_post else None,
initial={'channels': user_channels})
form.fields['channels'].choices = [(c.id, c.name) for c in queryset]
if is_post:
if form.is_valid():
channels = form.cleaned_data['channels']
UserChannel.objects.filter(
user=request.user,
channel__type=TYPE_TV_CHANNEL,
channel__country__code=profile.country,
).delete()
logger.info(channels)
for c in channels:
UserChannel(user=request.user, channel_id=c).save()
# invalidate personalized recommendations in area cache
cache.delete(
cache.Key("top_personalized_recommendations", request.user))
cache.delete(cache.Key("tv_user_recommended", request.user))
cache.delete(cache.Key("cinema_user_recommended", request.user))
ctx = dict(
form=form,
channels=list(queryset),
)
return render(request, "usersettings/tvchannels.html", ctx)
def compute_guess_score_for_all_films(user):
if not hasattr(user, '_guess_score'):
key = cache.Key("guess_score", user.id)
user._guess_score = cache.get(key)
if user._guess_score is None:
from film20.core.models import Recommendation
items = Recommendation.objects.filter(user=user.id)
items = items.values_list('film_id', 'guess_rating_alg2')
user._guess_score = dict((r[0], float(r[1])) for r in items)
cache.set(key, user._guess_score)
return user._guess_score
def check_answer(self, serv_tstamp):
question_key = cache.Key("answer_", self.request.unique_user)
question = cache.get(question_key)
if question:
answer = question.get('answer', '')
choice = int(self.request.POST.get('choice', 0))
user_tstamp = float(self.request.POST.get('tstamp'))
if answer == choice:
self.count_points(user_tstamp, serv_tstamp)
cache.delete(question_key)
def to_recommend_ids(self, request):
tag = request.GET.get('tag')
key = cache.Key('saas_to_recommend_ids', tag)
film_ids = cache.get(key)
if film_ids is None:
if tag:
film_ids = Film.objects.tagged(tag)
else:
film_ids = Film.objects.filter(popularity__gt=20)
film_ids = list(film_ids.values_list('id', flat=True))
cache.set(key, film_ids)
return film_ids
def count_points(self, user_tstamp, serv_tstamp):
quiz_points_key = cache.Key("points_", self.request.unique_user)
quiz_points = cache.get(quiz_points_key)
cache.delete(quiz_points_key)
if not quiz_points:
quiz_points = 0
tdelta = serv_tstamp - user_tstamp
tdelta = int(round(tdelta))
quiz_points += settings.FBAPP.get('points').get('seconds').get(tdelta, 0)
cache.set(quiz_points_key, quiz_points)
return quiz_points
def get(self, *args, **kw):
context = self.get_context_data()
contest = self.get_contest()
participant = ContestParticipation.objects.get(user=self.request.unique_user, contest=contest)
if participant.state >= ContestParticipation.STATE_QUIZ:
return http.HttpResponseRedirect(self.get_next_step())
key = cache.Key("questions_", self.request.unique_user)
questions = cache.get(key)
if not questions:
questions = self.quiz_mixer()
cache.set(key, questions)
return render(self.request, self.on_start, context)
def add_points(self):
quiz_points_key = cache.Key("points_", self.request.unique_user)
quiz_points = cache.get(quiz_points_key)
contest = self.get_contest()
participant = ContestParticipation.objects.get(user=self.request.unique_user, contest=contest)
if participant.state == ContestParticipation.STATE_TICKET:
participant.quiz_count = quiz_points
participant.score += quiz_points
participant.state = ContestParticipation.STATE_QUIZ
participant.save()
cache.delete(quiz_points_key)
return participant.score
def get_contest( self ):
contest_key = cache.Key("contest")
contest = cache.get(contest_key)
if not contest:
try:
contest = Contest.objects.get(state=Contest.STATE_OPEN)
except Contest.DoesNotExist:
contest = Contest.objects.all().order_by('-final_date')[0]
if contest.final_date < datetime.date.today():
contest.state = Contest.STATE_CLOSED
contest.save()
contest = Contest.objects.get(id=contest.id)
cache.set(contest_key, contest)
return contest
def get_vue_recommendations(user, mood=None, similar=True, limit=True):
from film20.new_recommendations.rateless_alg import rec_engine
if not user.id:
return ()
ratings = rating_helper.get_user_ratings(user.id)
unliked = RecommendationVote.get_unliked_film_ids(user)
recommendations = rec_engine.get_recommendations(ratings.items(), 1000)
key = cache.Key("user_vue_recommendations", user.id)
cache.set(key, recommendations, cache.A_WEEK)
return RecommendationsWrapper(recommendations,
ratings,
mood,
similar=similar,
limit=limit,
exclude=unliked)
def filmaster_recommends():
"""
A widget displaying HTML from a selected flat page.
Define this page in settings.py to FLATPAGE_FILMASTER_RECOMMENDS
"""
key = cache.Key(FLATPAGE_FILMASTER_RECOMMENDS)
flat_page = cache.get(key)
if flat_page is None:
try:
flat_page = FlatPage.objects.get(url=FLATPAGE_FILMASTER_RECOMMENDS)
except FlatPage.DoesNotExist:
flat_page = False
cache.set(key, flat_page, cache.A_DAY)
return {'flat_page': flat_page}
