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 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 clear_regional_info_cache(sender, instance, **kw):
"""
If regional info object is saved clear regional_info cache
"""
slug_city = slughifi(instance.town)
slug_region = slughifi(instance.region)
delete_cache(CACHE_REGIONAL_INFO,\
"%s_%s" % (slug_city, slug_region))
def clear_regional_info_cache(sender, instance, **kw):
"""
If regional info object is saved clear regional_info cache
"""
slug_city = slughifi(instance.town)
slug_region = slughifi(instance.region)
delete_cache(CACHE_REGIONAL_INFO,\
"%s_%s" % (slug_city, slug_region))
def delete(self):
from film20.utils.slughifi import slughifi
if self.town=="":
slug_town = None
else:
slug_town = slughifi(self.town)
if self.region=="":
slug_region = None
else:
slug_region = slughifi(self.region)
delete_cache(CACHE_REGIONAL_INFO, "%s_%s" % (slug_town, slug_region))
super(RegionalInfo, self).delete()
def delete(self):
from film20.utils.slughifi import slughifi
if self.town == "":
slug_town = None
else:
slug_town = slughifi(self.town)
if self.region == "":
slug_region = None
else:
slug_region = slughifi(self.region)
delete_cache(CACHE_REGIONAL_INFO, "%s_%s" % (slug_town, slug_region))
super(RegionalInfo, self).delete()
def regional_info_args(request, town, region):
from film20.utils.slughifi import slughifi
if town is not None:
slug_town = slughifi(town)
else:
slug_town = None
if region is not None:
slug_region = slughifi(region)
else:
slug_region = None
# try to retrieve from cache
regional_info_contents = get_cache(CACHE_REGIONAL_INFO,
"%s_%s" % (slug_town, slug_region))
# regional_info_contents = None
if regional_info_contents == None:
regional_info_object = None
try:
regional_info_object = RegionalInfo.objects.get(
Q(town=town) | Q(region=region))
except:
try:
logger.info("No regional info for town %s and region %s" %
(town, region))
regional_info_object = RegionalInfo.objects.get(town=town,
region="")
except:
try:
logger.info("No regional info for town %s" % (town))
regional_info_object = RegionalInfo.objects.get(
region=region, town="")
except:
logger.info("No regional info for region %s" % (region))
if regional_info_object == None:
regional_info_contents = "NONE"
else:
regional_info_contents = regional_info_object.contents
# store in cache
set_cache(CACHE_REGIONAL_INFO, "%s_%s" % (slug_town, slug_region),
regional_info_contents)
data = {
'town': town,
'region': region,
'contents': regional_info_contents,
}
return json_return(data)
def clean_title(self):
if not self.instance.pk:
permalink = slughifi(self.cleaned_data['title'])
if Post.objects.filter(Q(user=self.user), Q(permalink=permalink), Q(status = Post.PUBLIC_STATUS)|Q(status = Post.DRAFT_STATUS)).count():
raise forms.ValidationError(_('Title must be unique!'))
return self.cleaned_data['title']
try:
permalink = slughifi(self.cleaned_data['title'])
post = Post.objects.get(Q(user=self.user), Q(permalink=permalink), Q(status = Post.PUBLIC_STATUS)|Q(status = Post.DRAFT_STATUS))
if post != self.instance:
raise forms.ValidationError(_('Title must be unique!'))
except Post.DoesNotExist:
pass
return self.cleaned_data['title']
def save_movie_to_db(movie):
movie_title = unescape_imdb_text(movie.get('title'))
if len(movie_title)>128:
movie_title_old = movie_title
movie_title = movie_title_old[0:123] + "..."
#yy = movie.get('year')
movie_link = slughifi.slughifi(movie_title)
films = Film.objects.filter(title__iexact = movie_title)
status = None
if films.count() > 0:
for film in films:
movie_link = movie_link + "-" + str(movie.get('year'))
try:
film = Film.objects.get(title__iexact = movie_title, release_year=movie.get('year'), imdb_code = movie.movieID)
logger.warning("movie %r - %r already in db", movie_title, movie.get('year'))
if not film.imdb_code:
film.imdb_code = movie.movieID
film.save()
status = FilmToImport.ALREADY_IN_DB
return film, status
except Film.DoesNotExist:
saved_film = save_movie(movie, movie_link)
status = FilmToImport.ACCEPTED
return saved_film, status
except Exception, e:
logger.exception(e)
return False, status
def add_person( request ):
if request.method == "POST":
form = PersonForm( request.POST )
if form.is_valid():
person = form.save( commit=False )
person.permalink = slughifi( "%s %s" % ( person.name, person.surname ) )
try:
# if person with same permalink already exist
# we should return this person silent.
person = Person.objects.get( permalink = person.permalink )
except Person.DoesNotExist:
person.type = Person.TYPE_PERSON
person.save()
if person:
return http.HttpResponse(
'<script type="text/javascript">opener.dismissAddAnotherPopup( window, "%s", "%s" );</script>' % (
person.pk, escape( person )
))
else:
form = PersonForm()
return render_to_response( "person/add-person-popup.html", {
'form': form
})
def save_movie_to_db(movie):
movie_title = unescape_imdb_text(movie.get("title"))
if len(movie_title) > 128:
movie_title_old = movie_title
movie_title = movie_title_old[0:123] + "..."
# yy = movie.get('year')
movie_link = slughifi.slughifi(movie_title)
films = Film.objects.filter(title__iexact=movie_title)
status = None
if films.count() > 0:
for film in films:
movie_link = movie_link + "-" + str(movie.get("year"))
try:
film = Film.objects.get(
title__iexact=movie_title, release_year=movie.get("year"), imdb_code=movie.movieID
)
logger.warning("movie %r - %r already in db", movie_title, movie.get("year"))
if not film.imdb_code:
film.imdb_code = movie.movieID
film.save()
status = FilmToImport.ALREADY_IN_DB
return film, status
except Film.DoesNotExist:
saved_film = save_movie(movie, movie_link)
status = FilmToImport.ACCEPTED
return saved_film, status
except Exception, e:
logger.exception(e)
return False, status
def save(self, permalink=None, *args, **kwargs):
self.updated_at = datetime.now()
self.type = Object.TYPE_POST
if self.permalink is None or self.permalink == '':
self.permalink = slughifi(self.title) # FLM-164
# case: we're publishing the article, i.e. making it publicly visible
if self.is_public == False and self.status == Post.PUBLIC_STATUS:
self.is_public = True
# only update published date if this hasn't been published before
if self.publish is None:
self.publish = datetime.now()
# PingbackNote(note=self).save()
# case: we're unpublishing the article, i.e. making it invisible again
elif self.is_public == True and self.status == Post.DRAFT_STATUS:
self.is_public = False
# case: we're updating an already public article
elif self.is_public == True:
pass
# case: we're updating a draft article, no need to create/update activity
else:
pass
# fetch from post changes: featured, published or status
try:
orig = Post.objects.get(id=self.pk)
featured_note = orig.featured_note
is_published = orig.is_published
status = orig.status
except:
featured_note = None
is_published = None
status = None
# if we have featured or publish post check it status changes
status_featured_changed = False
status_published_changed = False
if self.featured_note:
if self.status != status:
status_featured_changed = True
if self.is_published:
if self.status != status:
status_published_changed = True
# invalidate cache
if self.featured_note != featured_note or status_featured_changed:
cache.delete_cache(CACHE_ACTIVITIES, KEY_FEATURED)
if self.is_published != is_published or status_published_changed:
cache.delete_cache(CACHE_ACTIVITIES, KEY_RECENT)
super(Post, self).save(*args, **kwargs)
self.tags = self.tag_list
if self.status == Post.DELETED_STATUS:
from film20.threadedcomments.models import ThreadedComment
ThreadedComment.objects.delete_for_object(self.id)
self.save_activity()
def regional_info_args(request, town, region):
from film20.utils.slughifi import slughifi
if town is not None:
slug_town = slughifi(town)
else:
slug_town = None
if region is not None:
slug_region = slughifi(region)
else:
slug_region = None
# try to retrieve from cache
regional_info_contents = get_cache(CACHE_REGIONAL_INFO, "%s_%s" % (slug_town, slug_region))
# regional_info_contents = None
if regional_info_contents == None:
regional_info_object = None
try:
regional_info_object = RegionalInfo.objects.get(Q(town=town) | Q(region=region))
except:
try:
logger.info("No regional info for town %s and region %s" % ( town, region ))
regional_info_object = RegionalInfo.objects.get(town=town, region="")
except:
try:
logger.info("No regional info for town %s" % ( town ))
regional_info_object = RegionalInfo.objects.get(region=region, town="")
except:
logger.info("No regional info for region %s" % ( region ))
if regional_info_object == None:
regional_info_contents = "NONE"
else:
regional_info_contents = regional_info_object.contents
# store in cache
set_cache(CACHE_REGIONAL_INFO, "%s_%s" % (slug_town, slug_region), regional_info_contents)
data = {
'town': town,
'region': region,
'contents': regional_info_contents,
}
return json_return(data)
def add_super_form_note(request, ajax=None):
if request.method == 'POST':
blog_object = Blog.objects.select_related().get_or_create(user=request.user)
form = SuperForm(request.POST)
if form.is_valid():
post = Post()
post.author = blog_object[0]
post.body = form.cleaned_data["body"]
txt = " ".join(post.body.split(' '))[:50]
if form.cleaned_data["related_film"]:
post.title = _('Review') + ": " + form.cleaned_data["related_film"][0].title
post.title = post.title[:200]
permalink = slughifi(post.title + " " + txt)
else:
post.title = _('Review') +": " + txt
post.title = post.title[:200]
permalink = slughifi(post.title[:128])
post.type = Post.TYPE_POST
post.status = Post.PUBLIC_STATUS
post.save(permalink=permalink)
for film in form.cleaned_data["related_film"]:post.related_film.add(film)
if ajax=="json":
context = {
'success': True,
'data': post.id,
}
return json_return(context)
else:
return HttpResponseRedirect(full_url("PLANET"))
else:
if ajax == "json":
context = {
'success': False,
'errors': str(form.errors),
}
return JSONResponse(context, is_iterable=False)
else:
return HttpResponseRedirect(full_url("PLANET"))
def save_shortreview_as_post(shortreview, object, user):
blogs = Blog.objects.select_related().get_or_create(user=user)
blog = blogs[0]
title = object.get_localized_title()
if not title : title = object.title
post = Post(title = _('Review') + ": " + title,\
body = shortreview, author = blog,\
permalink = slughifi(title + " " + " ".join((shortreview.split(' ')[:9])))[:128],\
type = Post.TYPE_POST,\
status = Post.PUBLIC_STATUS)
post.save()
post.related_film.add(object)
return post
def get_film_permalink( film, attempts=100 ):
permalink = slughifi( film.title )
if is_good_film_permalink( permalink ):
return permalink
root_permalink = "%s-%s" % ( permalink, film.release_year )
if is_good_film_permalink( root_permalink ):
return root_permalink
for i in range( 1, attempts ):
permalink = "%s-%s" % ( root_permalink, i )
if is_good_film_permalink( permalink ):
return permalink
return None # O_O
def save_writers(film, writers):
for writer in writers:
name_surname = unescape_imdb_text(writer.get("name"))
writer_link = slughifi.slughifi(name_surname)
writer_imdb = writer.personID
writer_name, writer_surname = save_name_surname(name_surname)
dbdir = Person.objects.filter(permalink=writer_link)
if len(writer_name) > 50:
writer_name = writer_name[0:50]
if len(writer_surname) > 50:
writer_surname = writer_surname[0:50]
if dbdir.count() == 0:
try:
person = Person.objects.get(imdb_code=writer_imdb, verified_imdb_code=False)
person.imdb_code = None
person.save()
except Person.DoesNotExist:
pass
person = Person(
name=writer_name,
surname=writer_surname,
is_writer=True,
status=1,
version=1,
type=2,
permalink=writer_link,
imdb_code=writer_imdb,
actor_popularity=0,
director_popularity=0,
actor_popularity_month=0,
director_popularity_month=0,
writer_popularity=0,
writer_popularity_month=0,
verified_imdb_code=True,
)
person.save(saved_by=2)
film.writers.add(person)
logger.debug("Saving Writer. ID=" + unicode(person))
else:
person = dbdir[0]
person.is_writer = True
person.save(saved_by=2)
film.writers.add(person)
logger.debug("Saving Writer. ID=" + unicode(person))
logger.debug("Saved writers for film: " + unicode(film.title))
def new_article(request):
"""
Save new article
"""
user = request.user
if request.method == "POST":
form = BlogPostForm(request.user, request.POST)
if form.is_valid() == True:
article = form.save(commit=False)
article.user = user
article.slug = slughifi(article.title)
article.creator_ip = request.META['REMOTE_ADDR']
article.type = Post.TYPE_POST
article.temp_related_film = form.cleaned_data['related_film']
if "save" in request.POST:
article.status = Post.DRAFT_STATUS
article.save()
form.save_m2m()
request.user.message_set.create(message=_(
"Successfully saved post '%s'. You have saved the review as draft. If you want to make it visible to others, you need to publish it."
) % article.title)
elif "publish" in request.POST:
article.status = Post.PUBLIC_STATUS
article.save()
form.save_m2m()
# FLM-1596 save again to use m2m in model
article.save()
request.user.message_set.create(
message=_("Successfully published post '%s'.") %
article.title)
else:
raise Http404
return HttpResponseRedirect("/" + urls.urls["ARTICLES"] + "/")
else:
form = BlogPostForm()
data = {
'form': form,
}
return render(request, templates['NEW_ARTICLE'], data)
def imdb_movie_to_film( movie ):
movie_title = unescape_imdb_text( movie.get( 'title' ) )
if len( movie_title ) > 128:
movie_title = movie_title[0:123] + "..."
movie_link = slughifi.slughifi( movie_title )
films = Film.objects.filter( title__iexact = movie_title )
if films.count() > 0:
for film in films:
movie_link = movie_link + "-" + str( movie.get( 'year' ) )
try:
return Film.objects.get( title__iexact = movie_title, release_year = movie.get( 'year' ), imdb_code = movie.movieID )
except Film.DoesNotExist:
pass
else:
try:
return Film.objects.get( permalink = movie_link )
except Film.DoesNotExist:
pass
def clean_related_film(self):
related = []
related_film_form_data = self.cleaned_data['related_film']
if isinstance(related_film_form_data, (list, tuple)):
return related_film_form_data
if len(related_film_form_data) ==0:
self.cleaned_data['related_film'] == ""
return self.cleaned_data['related_film']
else:
for related_film in comma_split(related_film_form_data):
related_permalink = slughifi(related_film)
search_helper = Search_Helper()
search_results = search_helper.search_film(title=related_film)
best_results = list(search_results['best_results'])
other_results = list(search_results['results'])
films = best_results + other_results
def match_film(film):
localized_title = film.get_localized_title()
return related_film in [film.title,
localized_title,
u"%s [%d]"%(film.title, film.release_year),
u"%s [%d]"%(localized_title, film.release_year)]
if films:
matches = filter(match_film, films)
if not matches or len(matches)>1:
msg = []
if not matches:
msg.append(_('Movie') + " " + related_film + " " + _('is not present in the database!'))
msg.append(_('Maybe you were looking for these movies') + ": ")
msg.extend(u"%s [%d]"%(unicode(f), f.release_year) for f in films)
self._errors["related_film"] = ErrorList(msg)
else:
related.append(matches[0])
else:
msg = _('Movie') +" "+ related_film +" "+ _('is not present in the database')
self._errors["related_film"] = ErrorList([msg])
return related
def add_person(request):
if request.method == "POST":
form = PersonForm(request.POST)
if form.is_valid():
person = form.save(commit=False)
person.permalink = slughifi("%s %s" %
(person.name, person.surname))
try:
# if person with same permalink already exist
# we should return this person silent.
person = Person.objects.get(permalink=person.permalink)
except Person.DoesNotExist:
person.type = Person.TYPE_PERSON
person.save()
if person:
return http.HttpResponse(
'<script type="text/javascript">opener.dismissAddAnotherPopup( window, "%s", "%s" );</script>'
% (person.pk, escape(person)))
else:
form = PersonForm()
return render_to_response("person/add-person-popup.html", {'form': form})
def save_actors(actors, film):
for index, actor in enumerate(actors):
name_surname = unescape_imdb_text(actor.get("name"))
actor_imdb = actor.personID
character_name = unescape_imdb_text(unicode(actor.currentRole))
if len(character_name) > 255:
character_name = character_name[0:254]
importance_ind = index
actor_link = slughifi.slughifi(name_surname)
actor_name, actor_surname = save_name_surname(name_surname)
if len(actor_name) > 50:
actor_name = actor_name[0:50]
if len(actor_surname) > 50:
actor_surname = actor_surname[0:50]
dbdir = Person.objects.filter(permalink=actor_link)
if dbdir.count() == 0:
try:
person = Person.objects.get(imdb_code=actor_imdb, verified_imdb_code=False)
person.imdb_code = None
person.save()
except Person.DoesNotExist:
pass
person = Person(
name=actor_name,
surname=actor_surname,
is_actor=True,
version=1,
type=2,
permalink=actor_link,
status=1,
actor_popularity=0,
imdb_code=actor_imdb,
director_popularity=0,
actor_popularity_month=0,
director_popularity_month=0,
writer_popularity=0,
writer_popularity_month=0,
verified_imdb_code=True,
)
person.save(saved_by=2)
character = Character(
film=film, person=person, importance=importance_ind, character=character_name, LANG="en"
)
character.save()
# TODO: apply mapping for common character names
character_pl = Character(
film=film, person=person, importance=importance_ind, character=character_name, LANG="pl"
)
character_pl.save()
else:
person = dbdir[0]
person.is_actor = True
person.save(saved_by=2)
character = Character(
film=film, person=person, importance=importance_ind, character=character_name, LANG="en"
)
character.save()
# TODO: apply mapping for common character names
character_pl = Character(
film=film, person=person, importance=importance_ind, character=character_name, LANG="pl"
)
character_pl.save()
logger.debug("Saved actors for film: " + unicode(film.title))
def edit_article(request, id):
"""
Save edited article
"""
user = request.user
article = None
try:
article = Post.objects.get(id=id, user=request.user)
except Post.DoesNotExist:
raise Http404
next = request.REQUEST.get('next', '')
if request.method == "POST":
form = BlogPostForm(request.user, request.POST, instance=article)
if form.is_valid() == True:
article = form.save(commit=False)
article.user = user
article.slug = slughifi(article.title)
article.creator_ip = request.META['REMOTE_ADDR']
article.type = Post.TYPE_POST
article.temp_related_film = form.cleaned_data['related_film']
if "save" in request.POST:
article.status = Post.DRAFT_STATUS
article.save()
request.user.message_set.create(message=_(
"Successfully saved post '%s'. You have saved the review as draft. If you want to make it visible to others, you need to publish it."
) % article.title)
form.save_m2m()
article.save_activity()
return HttpResponseRedirect(next if next else "/" +
urls.urls["ARTICLES"] + "/?" +
_("drafts"))
elif "publish" in request.POST:
article.status = Post.PUBLIC_STATUS
article.save()
request.user.message_set.create(
message=_("Successfully published post '%s'.") %
article.title)
form.save_m2m()
article.save_activity()
return HttpResponseRedirect(next if next else "/" +
urls.urls["ARTICLES"] + "/")
else:
new_related_film = []
def comma_escape(s):
return s.replace('\\', '\\\\').replace(',', '\\,')
related_movies = article.related_film.select_related()
related_people = article.related_person.select_related()
related_names = ', '.join(
comma_escape(unicode(m)) for m in related_people)
related_film = ', '.join(
comma_escape(unicode(m)) for m in related_movies)
form = BlogPostForm(instance=article,
initial={
'related_film': related_film,
'related_person': related_names
})
data = {
'form': form,
'next': next,
'article': article,
'film': article.get_main_related_film()
}
return render(request, templates['EDIT_ARTICLE'], data)
def pickle_movie(movie):
movie_title = unescape_imdb_text(movie.get('title'))
filename = slughifi.slughifi(movie_title)
filepath = MOVIE_DIRECTORY + filename + '.pickle'
f = open(filepath, 'w')
pickle.dump(movie, f)
def get_rating_tuple(type):
label = rating_helper.get_rating_type_label(type)
return (slughifi(str(label)), str(label))
def get_slug( self ):
return slughifi.slughifi( self.get_full_name() )
def get_rating_tuple(type):
label = rating_helper.get_rating_type_label(type)
return (slughifi(str(label)), str(label))
def save(self, permalink=None, *args, **kwargs):
self.updated_at = datetime.now()
self.type = Object.TYPE_POST
if self.permalink is None or self.permalink == '':
self.permalink = slughifi(self.title) # FLM-164
# case: we're publishing the article, i.e. making it publicly visible
if self.is_public == False and self.status == Post.PUBLIC_STATUS:
self.is_public = True
# only update published date if this hasn't been published before
if self.publish is None:
self.publish = datetime.now()
# PingbackNote(note=self).save()
# case: we're unpublishing the article, i.e. making it invisible again
elif self.is_public == True and self.status == Post.DRAFT_STATUS:
self.is_public = False
# case: we're updating an already public article
elif self.is_public == True:
pass
# case: we're updating a draft article, no need to create/update activity
else:
pass
# fetch from post changes: featured, published or status
try:
orig = Post.objects.get(id=self.pk)
featured_note = orig.featured_note
is_published = orig.is_published
status = orig.status
except:
featured_note = None
is_published = None
status = None
# if we have featured or publish post check it status changes
status_featured_changed = False
status_published_changed = False
if self.featured_note:
if self.status != status:
status_featured_changed = True
if self.is_published:
if self.status != status:
status_published_changed = True
# invalidate cache
if self.featured_note != featured_note or status_featured_changed:
cache.delete_cache(CACHE_ACTIVITIES, KEY_FEATURED)
if self.is_published != is_published or status_published_changed:
cache.delete_cache(CACHE_ACTIVITIES, KEY_RECENT)
super(Post, self).save(*args, **kwargs)
self.tags = self.tag_list
if self.status == Post.DELETED_STATUS:
from film20.threadedcomments.models import ThreadedComment
ThreadedComment.objects.delete_for_object(self.id)
self.save_activity()
def pickle_movie(movie):
movie_title = unescape_imdb_text(movie.get("title"))
filename = slughifi.slughifi(movie_title)
filepath = MOVIE_DIRECTORY + filename + ".pickle"
f = open(filepath, "w")
pickle.dump(movie, f)
