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 recompute_recommendations(user):
engine.compute_user_features(user, save=True)
key = cache_key("top_film_ids", MAX_RECOMMENDATIONS_NUMBER)
film_ids = cache.get(key)
if film_ids is None:
film_ids = Film.objects.filter(popularity__gte=MIN_POPULARITY)
film_ids = film_ids.with_poster().with_description().values_list(
'id', flat=True)
film_ids = film_ids.exclude(
production_country_list__icontains='Poland').exclude(
production_country_list__icontains='Polska')
film_ids = film_ids.order_by(
'-popularity')[:MAX_RECOMMENDATIONS_NUMBER]
film_ids = list(film_ids)
cache.set(key, film_ids)
recommendations = [
s
for s in engine.compute_guess_score_for_films(user, film_ids).items()
if s[1]
]
recommendations = sorted(recommendations, key=lambda s: -s[1])
return recommendations
def recompute_recommendations(user):
engine.compute_user_features(user, save=True)
key = cache_key("top_film_ids", MAX_RECOMMENDATIONS_NUMBER)
film_ids = cache.get(key)
if film_ids is None:
film_ids = Film.objects.filter(popularity__gte=MIN_POPULARITY)
film_ids = film_ids.with_poster().with_description().values_list('id', flat=True)
film_ids = film_ids.exclude(production_country_list__icontains='Poland').exclude(production_country_list__icontains='Polska')
film_ids = film_ids.order_by('-popularity')[:MAX_RECOMMENDATIONS_NUMBER]
film_ids = list(film_ids)
cache.set(key, film_ids)
recommendations = [s for s in engine.compute_guess_score_for_films(user, film_ids).items() if s[1]]
recommendations = sorted(recommendations, key=lambda s:-s[1])
return recommendations
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
