def pack(request, username, pack_id):
try:
pack = Pack.objects.select_related().annotate(num_sounds=Count('sound')).get(user__username__iexact=username, id=pack_id)
except Pack.DoesNotExist:
raise Http404
qs = Sound.objects.select_related('pack', 'user', 'license', 'geotag').filter(pack=pack, moderation_state="OK", processing_state="OK")
num_sounds_ok = len(qs)
# TODO: refactor: This list of geotags is only used to determine if we need to show the geotag map or not
pack_geotags = Sound.public.select_related('license', 'pack', 'geotag', 'user', 'user__profile').filter(pack=pack).exclude(geotag=None).exists()
google_api_key = settings.GOOGLE_API_KEY
if num_sounds_ok == 0 and pack.num_sounds != 0:
messages.add_message(request, messages.INFO, 'The sounds of this pack have <b>not been moderated</b> yet.')
else :
if num_sounds_ok < pack.num_sounds :
messages.add_message(request, messages.INFO, 'This pack contains more sounds that have <b>not been moderated</b> yet.')
# If user is owner of pack, display form to add description
enable_description_form = False
if request.user.username == username:
enable_description_form = True
form = PackDescriptionForm(instance = pack)
# Manage POST info (if adding a description)
if request.method == 'POST':
form = PackDescriptionForm(request.POST, pack)
if form.is_valid():
pack.description = form.cleaned_data['description']
pack.save()
else:
pass
file_exists = os.path.exists(pack.locations("license_path"))
return render_to_response('sounds/pack.html', combine_dicts(locals(), paginate(request, qs, settings.SOUNDS_PER_PAGE)), context_instance=RequestContext(request))
def packs_for_user(request, username):
user = get_object_or_404(User, username__iexact=username)
order = request.GET.get("order", "name")
if order not in ["name", "-last_update", "-created", "-num_sounds", "-num_downloads"]:
order = "name"
qs = Pack.objects.select_related().filter(user=user, sound__moderation_state="OK", sound__processing_state="OK").annotate(num_sounds=Count('sound'), last_update=Max('sound__created')).filter(num_sounds__gt=0).order_by(order)
return render_to_response('sounds/packs.html', combine_dicts(paginate(request, qs, settings.PACKS_PER_PAGE), locals()), context_instance=RequestContext(request))
def read(self, request):
ip = get_client_ip(request)
min_lat = request.GET.get('min_lat', 0.0)
max_lat = request.GET.get('max_lat', 0.0)
min_lon = request.GET.get('min_lon', 0.0)
max_lon = request.GET.get('max_lon', 0.0)
if min_lat <= max_lat and min_lon <= max_lon:
raw_sounds = Sound.objects.select_related("geotag").exclude(geotag=None).filter(moderation_state="OK", processing_state="OK").filter(geotag__lat__range=(min_lat,max_lat)).filter(geotag__lon__range=(min_lon,max_lon))
elif min_lat > max_lat and min_lon <= max_lon:
raw_sounds = Sound.objects.select_related("geotag").exclude(geotag=None).filter(moderation_state="OK", processing_state="OK").exclude(geotag__lat__range=(max_lat,min_lat)).filter(geotag__lon__range=(min_lon,max_lon))
elif min_lat <= max_lat and min_lon > max_lon:
raw_sounds = Sound.objects.select_related("geotag").exclude(geotag=None).filter(moderation_state="OK", processing_state="OK").filter(geotag__lat__range=(min_lat,max_lat)).exclude(geotag__lon__range=(max_lon,min_lon))
elif min_lat > max_lat and min_lon > max_lon:
raw_sounds = Sound.objects.select_related("geotag").exclude(geotag=None).filter(moderation_state="OK", processing_state="OK").exclude(geotag__lat__range=(max_lat,min_lat)).exclude(geotag__lon__range=(max_lon,min_lon))
else:
return ReturnError(400, "BadRequest", {"explanation": "Parameters min_lat, max_lat, min_long and max_log are not correctly defined."})
paginator = paginate(request, raw_sounds, min(int(request.GET.get('sounds_per_page', settings.SOUNDS_PER_API_RESPONSE)),settings.MAX_SOUNDS_PER_API_RESPONSE), 'p')
page = paginator['page']
if int(request.GET.get("p", "1")) <= paginator['paginator'].num_pages: # This is to mimic solr paginator behavior
sounds = [prepare_collection_sound(sound, include_user=True, include_geotag=True, custom_fields = request.GET.get('fields', False)) for sound in page.object_list]
else:
sounds = []
result = {'sounds': sounds, 'num_results': paginator['paginator'].count, 'num_pages': paginator['paginator'].num_pages}
if int(request.GET.get("p", "1")) <= paginator['paginator'].num_pages: # This is to mimic solr paginator behavior
if page.has_other_pages():
if page.has_previous():
result['previous'] = self.__construct_pagination_link(page.previous_page_number(), min_lon, max_lon, min_lat, max_lat, request.GET.get('sounds_per_page',None), request.GET.get('fields', False))
if page.has_next():
result['next'] = self.__construct_pagination_link(page.next_page_number(), min_lon, max_lon, min_lat, max_lat, request.GET.get('sounds_per_page',None), request.GET.get('fields', False))
add_request_id(request,result)
logger.info("Geotags search,min_lat=" + str(min_lat) + ",max_lat=" + str(max_lat) + ",min_lon=" + str(min_lon) + ",max_lon=" + str(max_lon) + ",api_key=" + request.GET.get("api_key", False) + ",api_key_username="******",ip=" + ip)
return result
def packs_for_user(request, username):
user = get_object_or_404(User, username__iexact=username)
order = request.GET.get("order", "name")
if order not in ["name", "-last_updated", "-created", "-num_sounds", "-num_downloads"]:
order = "name"
qs = Pack.objects.select_related().filter(user=user, num_sounds__gt=0).exclude(is_deleted=True).order_by(order)
return render_to_response('sounds/packs.html', combine_dicts(paginate(request, qs, settings.PACKS_PER_PAGE), locals()), context_instance=RequestContext(request))
def read(self, request, username):
ip = get_client_ip(request)
try:
user = User.objects.get(username__iexact=username)
except User.DoesNotExist:
raise ReturnError(404, "NotFound", {"explanation": "User (%s) does not exist." % username})
paginator = paginate(request, Sound.public.filter(user=user, processing_state="OK", moderation_state="OK"), min(int(request.GET.get('sounds_per_page', settings.SOUNDS_PER_API_RESPONSE)),settings.MAX_SOUNDS_PER_API_RESPONSE), 'p')
page = paginator['page']
if int(request.GET.get("p", "1")) <= paginator['paginator'].num_pages: # This is to mimic solr paginator behavior
sounds = [prepare_collection_sound(sound, include_user=True, custom_fields = request.GET.get('fields', False)) for sound in page.object_list]
else:
sounds = []
result = {'sounds': sounds, 'num_results': paginator['paginator'].count, 'num_pages': paginator['paginator'].num_pages}
if int(request.GET.get("p", "1")) <= paginator['paginator'].num_pages: # This is to mimic solr paginator behavior
if page.has_other_pages():
if page.has_previous():
result['previous'] = self.__construct_pagination_link(username, page.previous_page_number(), request.GET.get('sounds_per_page',None), request.GET.get('fields', False))
if page.has_next():
result['next'] = self.__construct_pagination_link(username, page.next_page_number(), request.GET.get('sounds_per_page',None), request.GET.get('fields', False))
add_request_id(request,result)
logger.info("User sounds,username="******",api_key=" + request.GET.get("api_key", False) + ",api_key_username="******",ip=" + ip)
return result
def bookmarks(request, username, category_id=None):
user = get_object_or_404(User, username__iexact=username)
is_owner = request.user.is_authenticated and user == request.user
n_uncat = Bookmark.objects.select_related("sound").filter(user=user, category=None).count()
if not category_id:
category = None
bookmarked_sounds = Bookmark.objects.select_related("sound").filter(user=user, category=None)
else:
category = get_object_or_404(BookmarkCategory, id=category_id, user=user)
bookmarked_sounds = category.bookmarks.select_related("sound").all()
bookmark_categories = BookmarkCategory.objects.filter(user=user)
tvars = {'user': user,
'is_owner': is_owner,
'n_uncat': n_uncat,
'bookmarked_sounds': bookmarked_sounds,
'category': category,
'bookmark_categories': bookmark_categories}
tvars.update(paginate(request, bookmarked_sounds, 30))
return render(request, 'bookmarks/bookmarks.html', tvars)
def thread(request, forum_name_slug, thread_id):
forum = get_object_or_404(Forum, name_slug=forum_name_slug)
thread = get_object_or_404(Thread, forum=forum, id=thread_id, first_post__moderation_state="OK")
paginator = paginate(request, Post.objects.select_related('author', 'author__profile').filter(
thread=thread, moderation_state="OK"), settings.FORUM_POSTS_PER_PAGE)
has_subscription = False
# a logged in user watching a thread can activate his subscription to that thread!
# we assume the user has seen the latest post if he is browsing the thread
# this is not entirely correct, but should be close enough
if request.user.is_authenticated:
try:
subscription = Subscription.objects.get(thread=thread, subscriber=request.user)
if not subscription.is_active:
subscription.is_active = True
subscription.save()
has_subscription = True
except Subscription.DoesNotExist:
pass
tvars = {'thread': thread,
'forum': forum,
'has_subscription': has_subscription}
tvars.update(paginator)
return render(request, 'forum/thread.html', tvars)
def pack(request, username, pack_id):
try:
pack = Pack.objects.select_related().get(id=pack_id)
if pack.user.username.lower() != username.lower():
raise Http404
except Pack.DoesNotExist:
raise Http404
if pack.is_deleted:
return render(request, 'sounds/deleted_pack.html')
qs = Sound.objects.only('id').filter(pack=pack, moderation_state='OK', processing_state='OK')
paginator = paginate(request, qs, settings.SOUNDS_PER_PAGE)
sound_ids = [sound_obj.id for sound_obj in paginator['page']]
pack_sounds = Sound.objects.ordered_ids(sound_ids)
num_sounds_ok = len(qs)
if num_sounds_ok == 0 and pack.num_sounds != 0:
messages.add_message(request, messages.INFO, 'The sounds of this pack have <b>not been moderated</b> yet.')
else:
if num_sounds_ok < pack.num_sounds:
messages.add_message(request, messages.INFO, 'This pack contains more sounds that have <b>not been moderated</b> yet.')
tvars = {'pack': pack,
'num_sounds_ok': num_sounds_ok,
'pack_sounds': pack_sounds
}
tvars.update(paginator)
return render(request, 'sounds/pack.html', tvars)
def bookmarks(request, username, category_id = None):
user = get_object_or_404(User, username__iexact=username)
is_owner = request.user.is_authenticated and user == request.user
'''
if is_owner and request.POST and "create_cat" in request.POST:
form_bookmark_category = BookmarkCategoryForm(request.POST, instance=BookmarkCategory(user=user))
if form_bookmark_category.is_valid():
form_bookmark_category.save()
form_bookmark_category = BookmarkCategoryForm()
form_bookmark_category = BookmarkCategoryForm()
'''
n_uncat = Bookmark.objects.select_related("sound").filter(user=user,category=None).count()
if not category_id:
bookmarked_sounds = Bookmark.objects.select_related("sound").filter(user=user,category=None)
else:
category = get_object_or_404(BookmarkCategory,id=category_id,user=user)
bookmarked_sounds = category.bookmarks.select_related("sound").all()
bookmark_categories = BookmarkCategory.objects.filter(user=user)
return render_to_response('bookmarks/bookmarks.html', combine_dicts(locals(),paginate(request, bookmarked_sounds, 30)), context_instance=RequestContext(request))
def attribution(request):
qs = Download.objects.select_related(
"sound", "sound__user__username", "sound__license", "pack", "pack__user__username"
).filter(user=request.user)
tvars = {"format": request.GET.get("format", "regular")}
tvars.update(paginate(request, qs, 40))
return render(request, "accounts/attribution.html", tvars)
def downloaders(request, username, sound_id):
sound = get_object_or_404(Sound, id=sound_id)
# Retrieve all users that downloaded a sound
qs = Download.objects.filter(sound=sound_id)
pagination = paginate(request, qs, 32, object_count=sound.num_downloads)
page = pagination["page"]
# Get all users+profiles for the user ids
sounds = list(page)
userids = [s.user_id for s in sounds]
users = User.objects.filter(pk__in=userids).select_related("profile")
user_map = {}
for u in users:
user_map[u.id] = u
download_list = []
for s in page:
download_list.append({"created":s.created, "user": user_map[s.user_id]})
download_list = sorted(download_list, key=itemgetter("created"), reverse=True)
tvars = {"sound": sound,
"username": username,
"download_list": download_list}
tvars.update(pagination)
return render(request, 'sounds/downloaders.html', tvars)
def pending_tickets_per_user(request, username):
user = get_object_or_404(User, username=username)
tickets_sounds = get_pending_sounds(user)
pendings = []
for ticket, sound in tickets_sounds:
last_comments = ticket.get_n_last_non_moderator_only_comments(3)
pendings.append( (ticket, sound, last_comments) )
show_pagination = len(pendings) > settings.SOUNDS_PENDING_MODERATION_PER_PAGE
n_unprocessed_sounds = Sound.objects.select_related().filter(user=user).exclude(processing_state="OK").count()
if n_unprocessed_sounds:
messages.add_message(request, messages.WARNING,
"""%i of %s's recently uploaded sounds are still in processing
phase and therefore are not yet ready for moderation. These
sounds won't appear in this list until they are successfully
processed.""" % (n_unprocessed_sounds, user.username))
moderators_version = True
own_page = user == request.user
paginated = paginate(request, pendings, settings.SOUNDS_PENDING_MODERATION_PER_PAGE)
tvars = {"show_pagination": show_pagination,
"moderators_version": moderators_version,
"user": user,
"own_page": own_page}
tvars.update(paginated)
return render(request, 'accounts/pending.html', tvars)
def read(self, request, username, category_id = None):
ip = get_client_ip(request)
try:
user = User.objects.get(username__iexact=username)
if category_id:
category = BookmarkCategory.objects.get(user__username__iexact=username, id=category_id )
except BookmarkCategory.DoesNotExist:
raise ReturnError(404, "NotFound", {"explanation": "Bookmark category with id %s does not exist." % category_id})
except User.DoesNotExist:
raise ReturnError(404, "NotFound", {"explanation": "User (%s) does not exist." % username})
if category_id:
bookmarked_sounds = category.bookmarks.select_related("sound").all()
else:
bookmarked_sounds = Bookmark.objects.select_related("sound").filter(user=user,category=None)
paginator = paginate(request, bookmarked_sounds, min(int(request.GET.get('sounds_per_page', settings.SOUNDS_PER_API_RESPONSE)),settings.MAX_SOUNDS_PER_API_RESPONSE), 'p')
page = paginator['page']
if int(request.GET.get("p", "1")) <= paginator['paginator'].num_pages: # This is to mimic solr paginator behavior
sounds = [prepare_collection_sound(bookmark.sound, include_user=True, custom_fields = request.GET.get('fields', False), extra_properties={'bookmark_name':bookmark.name}) for bookmark in page.object_list]
else:
sounds = []
result = {'sounds': sounds, 'num_results': paginator['paginator'].count, 'num_pages': paginator['paginator'].num_pages}
if int(request.GET.get("p", "1")) <= paginator['paginator'].num_pages: # This is to mimic solr paginator behavior
if page.has_other_pages():
if page.has_previous():
result['previous'] = self.__construct_pagination_link(username, category_id, page.previous_page_number())
if page.has_next():
result['next'] = self.__construct_pagination_link(username, category_id, page.next_page_number())
add_request_id(request,result)
logger.info("User bookmarks for category,username="******",category_id=" + str(category_id) + ",api_key=" + request.GET.get("api_key", False) + ",api_key_username="******",ip=" + ip)
return result
def remixed(request):
# TODO: this doesn't return the right results after remix_group merge
qs = RemixGroup.objects.all().order_by("-group_size")
return render_to_response(
"sounds/remixed.html",
combine_dicts(locals(), paginate(request, qs, settings.SOUND_COMMENTS_PER_PAGE)),
context_instance=RequestContext(request),
)
def latest_posts(request):
paginator = paginate(request,
Post.objects.select_related('author', 'author__profile', 'thread', 'thread__forum')
.filter(moderation_state="OK").order_by('-created').all(), settings.FORUM_POSTS_PER_PAGE)
hide_search = True
tvars = {'hide_search': hide_search}
tvars.update(paginator)
return render(request, 'forum/latest_posts.html', tvars)
def packs(request):
order = request.GET.get("order", "name")
if order not in ["name", "-last_updated", "-created", "-num_sounds", "-num_downloads"]:
order = "name"
qs = Pack.objects.select_related().filter(num_sounds__gt=0).order_by(order)
tvars = {"order": order}
tvars.update(paginate(request, qs, settings.PACKS_PER_PAGE, cache_count=True))
return render(request, "sounds/browse_packs.html", tvars)
def moderation_tary_users_sounds(request):
if request.user.id :
sounds_in_moderators_queue_count = Ticket.objects.select_related().filter(assignee=request.user.id).exclude(status='closed').exclude(content=None).order_by('status', '-created').count()
else :
sounds_in_moderators_queue_count = -1
tardy_user_tickets = list(__get_tardy_user_tickets_all())
return render_to_response('tickets/moderation_tardy_users.html', combine_dicts(paginate(request, tardy_user_tickets, 10), locals()), context_instance=RequestContext(request))
def forum(request, forum_name_slug):
try:
forum = Forum.objects.get(name_slug=forum_name_slug)
except Forum.DoesNotExist: #@UndefinedVariable
raise Http404
paginator = paginate(request, Thread.objects.filter(forum=forum, first_post__moderation_state="OK").select_related('last_post', 'last_post__author'), settings.FORUM_THREADS_PER_PAGE)
return render_to_response('forum/threads.html', combine_dicts(locals(), paginator), context_instance=RequestContext(request))
def moderation_tardy_moderators_sounds(request):
sounds_in_moderators_queue_count = _get_sounds_in_moderators_queue_count(request.user)
tardy_moderators_tickets = list(_get_tardy_moderator_tickets())
paginated = paginate(request, tardy_moderators_tickets, 10)
tvars = {"sounds_in_moderators_queue_count": sounds_in_moderators_queue_count,
"tardy_moderators_tickets": tardy_moderators_tickets}
tvars.update(paginated)
return render(request, 'tickets/moderation_tardy_moderators.html', tvars)
def downloaded_sounds(request, username):
user = get_object_or_404(User, username__iexact=username)
qs = Download.objects.filter(user_id=user.id, sound_id__isnull=False)
paginator = paginate(request, qs, settings.SOUNDS_PER_PAGE)
page = paginator["page"]
sound_ids = [d.sound_id for d in page]
sounds = Sound.objects.ordered_ids(sound_ids)
tvars = {"username": username, "user": user, "sounds": sounds}
tvars.update(paginator)
return render(request, "accounts/downloaded_sounds.html", tvars)
def downloaded_packs(request, username):
user = get_object_or_404(User, username__iexact=username)
qs = Download.objects.filter(user=user.id, pack__isnull=False)
paginator = paginate(request, qs, settings.PACKS_PER_PAGE)
page = paginator["page"]
pack_ids = [d.pack_id for d in page]
packs = Pack.objects.ordered_ids(pack_ids, select_related="user__username")
tvars = {"username": username, "packs": packs}
tvars.update(paginator)
return render(request, "accounts/downloaded_packs.html", tvars)
def for_user(request, username):
sound_user = get_object_or_404(User, username__iexact=username)
paginator = paginate(request, Sound.public.only('id').filter(user=sound_user), settings.SOUNDS_PER_PAGE)
sound_ids = [sound_obj.id for sound_obj in paginator['page']]
user_sounds = Sound.objects.ordered_ids(sound_ids)
tvars = {'sound_user': sound_user,
'user_sounds': user_sounds}
tvars.update(paginator)
return render(request, 'sounds/for_user.html', tvars)
def for_user(request, username):
user = get_object_or_404(User, username__iexact=username)
qs = Sound.public.only("id").filter(user=user)
paginate_data = paginate(request, qs, settings.SOUNDS_PER_PAGE)
paginator = paginate_data["paginator"]
current_page = paginate_data["current_page"]
page = paginate_data["page"]
sound_ids = [sound_obj.id for sound_obj in page]
user_sounds = Sound.objects.ordered_ids(sound_ids)
return render_to_response("sounds/for_user.html", locals(), context_instance=RequestContext(request))
def pack_downloaders(request, username, pack_id):
pack = get_object_or_404(Pack, id=pack_id)
# Retrieve all users that downloaded a sound
qs = Download.objects.filter(pack=pack_id)
return render_to_response(
"sounds/pack_downloaders.html",
combine_dicts(paginate(request, qs, 32, object_count=pack.num_downloads), locals()),
context_instance=RequestContext(request),
)
def packs(request):
order = request.GET.get("order", "name")
if order not in ["name", "-last_updated", "-created", "-num_sounds", "-num_downloads"]:
order = "name"
qs = Pack.objects.select_related() \
.filter(num_sounds__gt=0) \
.order_by(order)
return render_to_response('sounds/browse_packs.html',
combine_dicts(paginate(request, qs, settings.PACKS_PER_PAGE, cache_count=True), locals()),
context_instance=RequestContext(request))
def all(request):
""" Display all comments """
qs = Comment.objects.select_related("user", "user__profile")
paginator = paginate(request, qs, 30)
comments = paginator["page"].object_list
tvars = {
"comments": comments,
"mode": "latest"
}
tvars.update(paginator)
return render(request, 'sounds/comments.html', tvars)
def moderation_tardy_users_sounds(request):
sounds_in_moderators_queue_count = _get_sounds_in_moderators_queue_count(request.user)
tardy_user_tickets = _get_tardy_user_tickets()
paginated = paginate(request, tardy_user_tickets, 10)
tvars = {"moderator_tickets_count": sounds_in_moderators_queue_count,
"tardy_user_tickets": tardy_user_tickets,
"selected": "assigned"}
tvars.update(paginated)
return render(request, 'tickets/moderation_tardy_users.html', tvars)
def pack_downloaders(request, username, pack_id):
pack = get_object_or_404(Pack, id=pack_id)
# Retrieve all users that downloaded a sound
qs = PackDownload.objects.filter(pack_id=pack_id)
paginator = paginate(request, qs, 32, object_count=pack.num_downloads)
tvars = {'username': username,
'pack': pack}
tvars.update(paginator)
return render(request, 'sounds/pack_downloaders.html', tvars)
def packs_for_user(request, username):
user = get_object_or_404(User, username__iexact=username)
order = request.GET.get("order", "name")
if order not in ["name", "-last_updated", "-created", "-num_sounds", "-num_downloads"]:
order = "name"
qs = Pack.objects.select_related().filter(user=user, num_sounds__gt=0).exclude(is_deleted=True).order_by(order)
paginator = paginate(request, qs, settings.PACKS_PER_PAGE)
tvars = {'user': user,
'order': order}
tvars.update(paginator)
return render(request, 'sounds/packs.html', tvars)
def forum(request, forum_name_slug):
try:
forum = Forum.objects.get(name_slug=forum_name_slug)
except Forum.DoesNotExist:
raise Http404
tvars = {'forum': forum}
paginator = paginate(request, Thread.objects.filter(forum=forum, first_post__moderation_state="OK")
.select_related('last_post', 'last_post__author'), settings.FORUM_THREADS_PER_PAGE)
tvars.update(paginator)
return render(request, 'forum/threads.html', tvars)
def forum(request, forum_name_slug):
try:
forum = Forum.objects.get(name_slug=forum_name_slug)
except Forum.DoesNotExist:
raise Http404
tvars = {'forum': forum}
paginator = paginate(
request,
Thread.objects.filter(
forum=forum, first_post__moderation_state="OK").select_related(
'last_post', 'last_post__author'),
settings.FORUM_THREADS_PER_PAGE)
tvars.update(paginator)
return render(request, 'forum/threads.html', tvars)
def forum(request, forum_name_slug):
try:
forum = Forum.objects.get(name_slug=forum_name_slug)
except Forum.DoesNotExist: #@UndefinedVariable
raise Http404
paginator = paginate(
request,
Thread.objects.filter(
forum=forum, first_post__moderation_state="OK").select_related(
'last_post', 'last_post__author'),
settings.FORUM_THREADS_PER_PAGE)
return render_to_response('forum/threads.html',
combine_dicts(locals(), paginator),
context_instance=RequestContext(request))
def packs(request):
order = request.GET.get("order", "name")
if order not in [
"name", "-last_updated", "-created", "-num_sounds",
"-num_downloads"
]:
order = "name"
qs = Pack.objects.select_related() \
.filter(num_sounds__gt=0) \
.order_by(order)
return render_to_response('sounds/browse_packs.html',
combine_dicts(
paginate(request,
qs,
settings.PACKS_PER_PAGE,
cache_count=True), locals()),
context_instance=RequestContext(request))
def all(request):
""" This is all very hacky because GenericRelations don't allow you to span
relations with select_related... hence we get the content_objects and then
load all the sounds related to those in a big lookup. If we don't do this
the page generates about 90+ queries, with it we only generate 4 queries :-) """
sound_type = ContentType.objects.get_for_model(Sound)
qs = Comment.objects.filter(content_type=sound_type).select_related(
"user", "user__profile")
paginator_obj = paginate(request, qs, 30)
comments = paginator_obj["page"].object_list
sound_ids = set([comment.object_id for comment in comments])
sound_lookup = dict([(sound.id, sound) for sound in list(
Sound.objects.filter(id__in=sound_ids).select_related("user"))])
for comment in comments:
comment.sound_object = sound_lookup[comment.object_id]
return render_to_response('sounds/comments.html',
combine_dicts(paginator_obj, locals()),
context_instance=RequestContext(request))
def test_url_with_non_ascii_characters(self):
"""Paginator objects are passed a request object which includes a list of request GET parameters and values.
The paginator uses this object to get parameters like the current page that is requested, and also to construct
pagination links which contain all the same GET parameters as the initial request so that whatever things
are determined there, will be preserved when moving to the next page. To do that the paginator iterates over
all GET parameters and values. This test checks that if non-ascii characters are passed as GET parameter names
or values, paginator does not break.
"""
context = {'media_url': 'fake URL'}
text_with_non_ascii = u'�textèé'
dummy_request = RequestFactory().get(
reverse('sounds'), {
text_with_non_ascii: '1',
'param_name': text_with_non_ascii,
'param2_name': 'ok_value',
})
paginator = paginate(dummy_request, Sound.objects.all(), 10)
show_paginator(context, paginator['paginator'], paginator['page'],
paginator['current_page'], dummy_request)
def pending_tickets_per_user(request, username):
user = get_object_or_404(User, username=username)
tickets_sounds = get_pending_sounds(user)
pendings = []
mods = set()
for ticket, sound in tickets_sounds:
last_comments = ticket.get_n_last_non_moderator_only_comments(3)
pendings.append((ticket, sound, last_comments))
mods.add(ticket.assignee)
show_pagination = len(
pendings) > settings.SOUNDS_PENDING_MODERATION_PER_PAGE
n_unprocessed_sounds = Sound.objects.select_related().filter(
user=user).exclude(processing_state="OK").count()
if n_unprocessed_sounds:
messages.add_message(
request, messages.WARNING,
"""%i of %s's recently uploaded sounds are still in processing
phase and therefore are not yet ready for moderation. These
sounds won't appear in this list until they are successfully
processed.""" %
(n_unprocessed_sounds, user.username))
moderators_version = True
own_page = user == request.user
no_assign_button = len(mods) == 0 or (len(mods) == 1
and request.user in mods)
paginated = paginate(request, pendings,
settings.SOUNDS_PENDING_MODERATION_PER_PAGE)
tvars = {
"show_pagination": show_pagination,
"moderators_version": moderators_version,
"user": user,
"own_page": own_page,
"no_assign_button": no_assign_button
}
tvars.update(paginated)
return render(request, 'accounts/pending.html', tvars)
def pending_tickets_per_user(request, username):
user = get_object_or_404(User, username=username)
tickets_sounds = get_pending_sounds(user)
pendings = []
for ticket, sound in tickets_sounds:
last_comments = ticket.get_n_last_non_moderator_only_comments(3)
pendings.append( (ticket, sound, last_comments) )
show_pagination = len(pendings) > settings.SOUNDS_PENDING_MODERATION_PER_PAGE
n_unprocessed_sounds = Sound.objects.select_related().filter(user=user).exclude(processing_state="OK").count()
if n_unprocessed_sounds:
messages.add_message(request, messages.WARNING, '%i of %s\'s recently uploaded sounds are still in processing '
'phase and therefore are not yet ready for moderation. These '
'sounds won\'t appear in this list until they are successfully '
'processed.' % (n_unprocessed_sounds, user.username))
moderators_version = True
return render_to_response('accounts/pending.html', combine_dicts(paginate(request, pendings, settings.SOUNDS_PENDING_MODERATION_PER_PAGE), locals()), context_instance=RequestContext(request))
def pending(request):
user = request.user
tickets_sounds = TicketViews.get_pending_sounds(user)
pendings = []
for ticket, sound in tickets_sounds:
last_comments = ticket.get_n_last_non_moderator_only_comments(3)
pendings.append((ticket, sound, last_comments))
show_pagination = len(pendings) > settings.SOUNDS_PENDING_MODERATION_PER_PAGE
n_unprocessed_sounds = Sound.objects.select_related().filter(user=user).exclude(processing_state="OK").count()
if n_unprocessed_sounds:
messages.add_message(request, messages.WARNING,
'%i of your recently uploaded sounds are still in processing' % n_unprocessed_sounds)
moderators_version = False
tvars = {
'user': user,
'show_pagination': show_pagination,
'moderators_version': moderators_version,
}
tvars.update(paginate(request, pendings, settings.SOUNDS_PENDING_MODERATION_PER_PAGE))
return render(request, 'accounts/pending.html', tvars)
def thread(request, forum_name_slug, thread_id):
forum = get_object_or_404(Forum, name_slug=forum_name_slug)
thread = get_object_or_404(Thread, forum=forum, id=thread_id, first_post__moderation_state="OK")
paginator = paginate(request, Post.objects.select_related('author', 'author__profile').filter(
thread=thread, moderation_state="OK"), settings.FORUM_POSTS_PER_PAGE)
has_subscription = False
# a logged in user watching a thread can activate his subscription to that thread!
# we assume the user has seen the latest post if he is browsing the thread
# this is not entirely correct, but should be close enough
if request.user.is_authenticated:
try:
subscription = Subscription.objects.get(thread=thread, subscriber=request.user)
if not subscription.is_active:
subscription.is_active = True
subscription.save()
has_subscription = True
except Subscription.DoesNotExist:
pass
return render(request, 'forum/thread.html', combine_dicts(locals(), paginator))
def by_user(request, username):
""" This is all very hacky because GenericRelations don't allow you to span
relations with select_related... hence we get the content_objects and then
load all the sounds related to those in a big lookup. If we don't do this
the page generates about 90+ queries, with it we only generate 4 queries :-) """
user = get_object_or_404(User, username__iexact=username)
sound_type = ContentType.objects.get_for_model(Sound)
qs = Comment.objects.filter(content_type=sound_type,
user=user).select_related(
"user", "user__profile")
paginator = paginate(request, qs, 30)
comments = paginator["page"].object_list
sound_ids = set([comment.object_id for comment in comments])
sound_lookup = dict([
(sound.id, sound)
for sound in list(Sound.objects.filter(id__in=sound_ids))
])
for comment in comments:
comment.sound_object = sound_lookup[comment.object_id]
tvars = {"user": user, "comments": comments, "mode": "by_user"}
tvars.update(paginator)
return render(request, 'sounds/comments.html', tvars)
def pack(request, username, pack_id):
try:
pack = Pack.objects.select_related().get(id=pack_id)
if pack.user.username.lower() != username.lower():
raise Http404
except Pack.DoesNotExist:
raise Http404
if pack.is_deleted:
return render(request, 'sounds/deleted_pack.html')
qs = Sound.objects.only('id').filter(pack=pack,
moderation_state='OK',
processing_state='OK')
paginator = paginate(request, qs, settings.SOUNDS_PER_PAGE)
sound_ids = [sound_obj.id for sound_obj in paginator['page']]
pack_sounds = Sound.objects.ordered_ids(sound_ids)
num_sounds_ok = len(qs)
if num_sounds_ok == 0 and pack.num_sounds != 0:
messages.add_message(
request, messages.INFO,
'The sounds of this pack have <b>not been moderated</b> yet.')
else:
if num_sounds_ok < pack.num_sounds:
messages.add_message(
request, messages.INFO,
'This pack contains more sounds that have <b>not been moderated</b> yet.'
)
tvars = {
'pack': pack,
'num_sounds_ok': num_sounds_ok,
'pack_sounds': pack_sounds
}
tvars.update(paginator)
return render(request, 'sounds/pack.html', tvars)
def pack(request, username, pack_id):
try:
pack = Pack.objects.select_related().get(id=pack_id)
if pack.user.username.lower() != username.lower():
raise Http404
except Pack.DoesNotExist:
raise Http404
qs = Sound.objects.select_related('pack', 'user', 'license', 'geotag').filter(pack=pack, moderation_state="OK", processing_state="OK")
num_sounds_ok = len(qs)
# TODO: refactor: This list of geotags is only used to determine if we need to show the geotag map or not
pack_geotags = Sound.public.select_related('license', 'pack', 'geotag', 'user', 'user__profile').filter(pack=pack).exclude(geotag=None).exists()
google_api_key = settings.GOOGLE_API_KEY
if num_sounds_ok == 0 and pack.num_sounds != 0:
messages.add_message(request, messages.INFO, 'The sounds of this pack have <b>not been moderated</b> yet.')
else :
if num_sounds_ok < pack.num_sounds :
messages.add_message(request, messages.INFO, 'This pack contains more sounds that have <b>not been moderated</b> yet.')
# If user is owner of pack, display form to add description
enable_description_form = False
if request.user.username == username:
enable_description_form = True
form = PackDescriptionForm(instance = pack)
# Manage POST info (if adding a description)
if request.method == 'POST':
form = PackDescriptionForm(request.POST, pack)
if form.is_valid():
pack.description = form.cleaned_data['description']
pack.save()
else:
pass
file_exists = os.path.exists(pack.locations("license_path"))
return render_to_response('sounds/pack.html', combine_dicts(locals(), paginate(request, qs, settings.SOUNDS_PER_PAGE)), context_instance=RequestContext(request))
def thread(request, forum_name_slug, thread_id):
forum = get_object_or_404(Forum, name_slug=forum_name_slug)
thread = get_object_or_404(Thread,
forum=forum,
id=thread_id,
first_post__moderation_state="OK")
paginator = paginate(
request,
Post.objects.select_related('author', 'author__profile').filter(
thread=thread, moderation_state="OK"),
settings.FORUM_POSTS_PER_PAGE)
# a logged in user watching a thread can activate his subscription to that thread!
# we assume the user has seen the latest post if he is browsing the thread
# this is not entirely correct, but should be close enough
if request.user.is_authenticated():
Subscription.objects.filter(thread=thread,
subscriber=request.user,
is_active=False).update(is_active=True)
return render_to_response('forum/thread.html',
combine_dicts(locals(), paginator),
context_instance=RequestContext(request))
def bookmarks(request, username, category_id=None):
user = request.parameter_user
is_owner = request.user.is_authenticated and user == request.user
n_uncat = Bookmark.objects.select_related("sound").filter(user=user, category=None).count()
if not category_id:
category = None
bookmarked_sounds = Bookmark.objects.select_related("sound", "sound__user").filter(user=user, category=None)
else:
category = get_object_or_404(BookmarkCategory, id=category_id, user=user)
bookmarked_sounds = category.bookmarks.select_related("sound", "sound__user").all()
bookmark_categories = BookmarkCategory.objects.filter(user=user).annotate(num_bookmarks=Count('bookmarks'))
tvars = {'user': user,
'is_owner': is_owner,
'n_uncat': n_uncat,
'category': category,
'bookmark_categories': bookmark_categories}
tvars.update(paginate(request, bookmarked_sounds, 30))
return render(request, 'bookmarks/bookmarks.html', tvars)
def remixed(request):
qs = RemixGroup.objects.all().order_by('-group_size')
tvars = dict()
tvars.update(paginate(request, qs, settings.SOUND_COMMENTS_PER_PAGE))
return render(request, 'sounds/remixed.html', tvars)
def pack_downloaders(request, username, pack_id):
pack = get_object_or_404(Pack, id = pack_id)
# Retrieve all users that downloaded a sound
qs = Download.objects.filter(pack=pack_id)
return render_to_response('sounds/pack_downloaders.html', combine_dicts(paginate(request, qs, 32, object_count=pack.num_downloads), locals()), context_instance=RequestContext(request))
def moderation_assigned(request, user_id):
can_view_moderator_only_messages = _can_view_mod_msg(request)
clear_forms = True
if request.method == 'POST':
mod_sound_form = SoundModerationForm(request.POST)
msg_form = ModerationMessageForm(request.POST)
if mod_sound_form.is_valid() and msg_form.is_valid():
ticket = Ticket.objects.get(
id=mod_sound_form.cleaned_data.get("ticket", False))
invalidate_template_cache("user_header", ticket.sender.id)
invalidate_all_moderators_header_cache()
action = mod_sound_form.cleaned_data.get("action")
msg = msg_form.cleaned_data.get("message", False)
moderator_only = msg_form.cleaned_data.get("moderator_only", False)
if msg:
tc = TicketComment(sender=ticket.assignee,
text=msg,
ticket=ticket,
moderator_only=moderator_only)
tc.save()
if action == "Approve":
ticket.status = TICKET_STATUS_CLOSED
ticket.content.content_object.change_moderation_state(
"OK") # change_moderation_state does the saving
ticket.save()
ticket.content.content_object.mark_index_dirty()
if msg:
ticket.send_notification_emails(
Ticket.NOTIFICATION_APPROVED_BUT, Ticket.USER_ONLY)
else:
ticket.send_notification_emails(
Ticket.NOTIFICATION_APPROVED, Ticket.USER_ONLY)
elif action == "Defer":
ticket.status = TICKET_STATUS_DEFERRED
ticket.save()
# only send a notification if a message was added
if msg:
ticket.send_notification_emails(
Ticket.NOTIFICATION_QUESTION, Ticket.USER_ONLY)
elif action == "Return":
ticket.assignee = None
ticket.status = TICKET_STATUS_NEW
# no notification here
ticket.save()
elif action == "Delete":
ticket.send_notification_emails(Ticket.NOTIFICATION_DELETED,
Ticket.USER_ONLY)
# to prevent a crash if the form is resubmitted
if ticket.content:
ticket.content.content_object.delete()
ticket.content.delete()
ticket.content = None
ticket.status = TICKET_STATUS_CLOSED
ticket.save()
elif action == "Whitelist":
th = Thread(target=call_command,
args=(
'whitelist_user',
"%i" % ticket.id,
))
th.start()
ticket.send_notification_emails(
Ticket.NOTIFICATION_WHITELISTED, Ticket.USER_ONLY)
messages.add_message(
request, messages.INFO,
"""User %s has been whitelisted but some of their tickets might
still appear on this list for some time. Please reload the page in a few
seconds to see the updated list of pending tickets"""
% ticket.sender.username)
else:
clear_forms = False
if clear_forms:
mod_sound_form = SoundModerationForm(initial={'action': 'Approve'})
msg_form = ModerationMessageForm()
qs = Ticket.objects.select_related() \
.filter(assignee=user_id) \
.exclude(status=TICKET_STATUS_CLOSED) \
.exclude(content=None) \
.order_by('status', '-created')
pagination_response = paginate(
request, qs, settings.MAX_TICKETS_IN_MODERATION_ASSIGNED_PAGE)
pagination_response['page'].object_list = list(
pagination_response['page'].object_list)
# Because some tickets can have linked content which has disappeared or on deletion time the ticket
# has not been properly updated, we need to check whether the sound that is linked does in fact exist. If it does
# not, we set the linked content to None and the status of the ticket to closed as should have been set at sound
# deletion time.
for ticket in pagination_response['page'].object_list:
sound_id = ticket.content.object_id
try:
Sound.objects.get(id=sound_id)
except Sound.DoesNotExist:
pagination_response['page'].object_list.remove(ticket)
ticket.content = None
ticket.status = TICKET_STATUS_CLOSED
ticket.save()
moderator_tickets_count = qs.count()
moderation_texts = MODERATION_TEXTS
show_pagination = moderator_tickets_count > settings.MAX_TICKETS_IN_MODERATION_ASSIGNED_PAGE
tvars = locals()
tvars.update(pagination_response)
return render(request, 'tickets/moderation_assigned.html', tvars)
if sound.user in users_following:
is_following = True
is_explicit = sound.is_explicit and (not request.user.is_authenticated() \
or not request.user.profile.is_adult)
tvars = {
'sound': sound,
'username': username,
'tags': tags,
'form': form,
'display_random_link': display_random_link,
'do_log': do_log,
'is_following': is_following,
'is_explicit': is_explicit
}
tvars.update(paginate(request, qs, settings.SOUND_COMMENTS_PER_PAGE))
return render(request, 'sounds/sound.html', tvars)
def sound_download(request, username, sound_id):
if not request.user.is_authenticated():
return HttpResponseRedirect(
'%s?next=%s' % (reverse("accounts-login"),
reverse("sound", args=[username, sound_id])))
if settings.LOG_CLICKTHROUGH_DATA:
click_log(request, click_type='sounddownload', sound_id=sound_id)
sound = get_object_or_404(Sound,
id=sound_id,
moderation_state="OK",
processing_state="OK")
def archived_messages(request):
qs = base_qs.filter(user_to=request.user, is_archived=True, is_sent=False)
return render(request, 'messages/archived.html', paginate(request, qs))
def archived_messages(request):
qs = base_qs.filter(user_to=request.user, is_archived=True, is_sent=False)
return render_to_response('messages/archived.html',
paginate(request, qs),
context_instance=RequestContext(request))
def latest_posts(request):
paginator = paginate(request,
Post.objects.select_related('author', 'author__profile', 'thread', 'thread__forum')
.filter(moderation_state="OK").order_by('-created').all(), settings.FORUM_POSTS_PER_PAGE)
hide_search = True
return render(request, 'forum/latest_posts.html', combine_dicts(locals(), paginator))
def moderation_assigned(request, user_id):
can_view_moderator_only_messages = __can_view_mod_msg(request)
clear_forms = True
if request.method == 'POST':
mod_sound_form = SoundModerationForm(request.POST)
msg_form = ModerationMessageForm(request.POST)
if mod_sound_form.is_valid() and msg_form.is_valid():
ticket = Ticket.objects.get(
id=mod_sound_form.cleaned_data.get("ticket", False))
invalidate_template_cache("user_header", ticket.sender.id)
invalidate_all_moderators_header_cache()
action = mod_sound_form.cleaned_data.get("action")
msg = msg_form.cleaned_data.get("message", False)
moderator_only = msg_form.cleaned_data.get("moderator_only", False)
if msg:
tc = TicketComment(sender=ticket.assignee,
text=msg,
ticket=ticket,
moderator_only=moderator_only)
tc.save()
if action == "Approve":
ticket.status = TICKET_STATUS_CLOSED
ticket.content.content_object.moderation_state = "OK"
ticket.content.content_object.save()
ticket.save()
ticket.content.content_object.mark_index_dirty()
if msg:
ticket.send_notification_emails(
Ticket.NOTIFICATION_APPROVED_BUT, Ticket.USER_ONLY)
else:
ticket.send_notification_emails(
Ticket.NOTIFICATION_APPROVED, Ticket.USER_ONLY)
elif action == "Defer":
ticket.status = TICKET_STATUS_DEFERRED
ticket.save()
# only send a notification if a message was added
if msg:
ticket.send_notification_emails(
Ticket.NOTIFICATION_QUESTION, Ticket.USER_ONLY)
elif action == "Return":
ticket.assignee = None
ticket.status = TICKET_STATUS_NEW
# no notification here
ticket.save()
elif action == "Delete":
ticket.send_notification_emails(Ticket.NOTIFICATION_DELETED,
Ticket.USER_ONLY)
# to prevent a crash if the form is resubmitted
if ticket.content:
ticket.content.content_object.delete()
ticket.content.delete()
ticket.content = None
ticket.status = TICKET_STATUS_CLOSED
ticket.save()
elif action == "Whitelist":
th = Thread(target=call_command,
args=(
'whitelist_user',
ticket.id,
))
th.start()
ticket.send_notification_emails(
Ticket.NOTIFICATION_WHITELISTED, Ticket.USER_ONLY)
messages.add_message(
request, messages.INFO,
'User %s has been whitelisted but some of his tickets might '
'still appear on this list for some time. Please reload the page in a few '
'seconds to see the updated list of pending tickets' %
ticket.sender.username)
else:
clear_forms = False
if clear_forms:
mod_sound_form = SoundModerationForm(initial={'action': 'Approve'})
msg_form = ModerationMessageForm()
qs = Ticket.objects.select_related() \
.filter(assignee=user_id) \
.exclude(status=TICKET_STATUS_CLOSED) \
.exclude(content=None) \
.order_by('status', '-created')
paginaion_response = paginate(request, qs,
MAX_TICKETS_IN_MODERATION_ASSIGNED_PAGE)
paginaion_response['page'].object_list = list(
paginaion_response['page'].object_list)
for ticket in paginaion_response['page'].object_list:
sound_id = ticket.content.object_id
try:
Sound.objects.get(id=sound_id)
except:
paginaion_response['page'].object_list.remove(ticket)
try:
# Try to delete ticket so error does not happen again
ticket.delete()
except:
pass
moderator_tickets_count = qs.count()
moderation_texts = MODERATION_TEXTS
show_pagination = moderator_tickets_count > MAX_TICKETS_IN_MODERATION_ASSIGNED_PAGE
return render_to_response('tickets/moderation_assigned.html',
combine_dicts(paginaion_response, locals()),
context_instance=RequestContext(request))
def sound(request, username, sound_id):
try:
sound = Sound.objects.prefetch_related("tags__tag")\
.select_related("license", "user", "user__profile", "pack")\
.get(id=sound_id, user__username=username)
user_is_owner = request.user.is_authenticated and \
(sound.user == request.user or request.user.is_superuser or request.user.is_staff or
Group.objects.get(name='moderators') in request.user.groups.all())
# If the user is authenticated and this file is his, don't worry about moderation_state and processing_state
if user_is_owner:
if sound.moderation_state != "OK":
messages.add_message(
request, messages.INFO,
'Be advised, this file has <b>not been moderated</b> yet.')
if sound.processing_state != "OK":
messages.add_message(
request, messages.INFO,
'Be advised, this file has <b>not been processed</b> yet.')
else:
if sound.moderation_state != 'OK' or sound.processing_state != 'OK':
raise Http404
except Sound.DoesNotExist:
if DeletedSound.objects.filter(sound_id=sound_id).exists():
return render(request, 'sounds/deleted_sound.html')
else:
raise Http404
if request.method == "POST":
form = CommentForm(request, request.POST)
if request.user.is_authenticated:
if request.user.profile.is_blocked_for_spam_reports():
messages.add_message(
request, messages.INFO,
"You're not allowed to post the comment because your "
"account has been temporaly blocked after multiple spam "
"reports")
else:
if form.is_valid():
comment_text = form.cleaned_data["comment"]
sound.add_comment(request.user, comment_text)
sound.invalidate_template_caches()
send_mail_template(
u'You have a new comment.',
'sounds/email_new_comment.txt', {
'sound': sound,
'user': request.user,
'comment': comment_text
},
user_to=sound.user,
email_type_preference_check="new_comment")
return HttpResponseRedirect(sound.get_absolute_url())
else:
form = CommentForm(request)
qs = Comment.objects.select_related("user", "user__profile")\
.filter(sound_id=sound_id)
display_random_link = request.GET.get('random_browsing', False)
is_following = False
if request.user.is_authenticated:
users_following = follow_utils.get_users_following(request.user)
if sound.user in users_following:
is_following = True
is_explicit = sound.is_explicit and (not request.user.is_authenticated
or not request.user.profile.is_adult)
tvars = {
'sound': sound,
'username': username,
'form': form,
'display_random_link': display_random_link,
'is_following': is_following,
'is_explicit':
is_explicit, # if the sound should be shown blurred, already checks for adult profile
'sizes': settings.IFRAME_PLAYER_SIZE,
}
tvars.update(paginate(request, qs, settings.SOUND_COMMENTS_PER_PAGE))
return render(request, 'sounds/sound.html', tvars)
def get_all_rol_cn(page: int, db: Session):
rol = paginate(db.query(Rol), page)
return rol
def sent_messages(request):
qs = base_qs.filter(user_from=request.user,
is_archived=False,
is_sent=True)
return render(request, 'messages/sent.html', paginate(request, qs))
def get_all_user_cn(page, db: Session):
user = paginate(db.query(User), page, 100)
return user
def attribution(request):
qs = Download.objects.select_related('sound', 'sound__user__username', 'sound__license', 'pack',
'pack__user__username').filter(user=request.user)
tvars = {'format': request.GET.get("format", "regular")}
tvars.update(paginate(request, qs, 40))
return render(request, 'accounts/attribution.html', tvars)
def moderation_assigned(request, user_id):
clear_forms = True
mod_sound_form = None
msg_form = None
if request.method == 'POST':
mod_sound_form = SoundModerationForm(request.POST)
msg_form = ModerationMessageForm(request.POST)
if mod_sound_form.is_valid() and msg_form.is_valid():
ticket_ids = mod_sound_form.cleaned_data.get("ticket",
'').split('|')
tickets = Ticket.objects.filter(id__in=ticket_ids)
msg = msg_form.cleaned_data.get("message", False)
action = mod_sound_form.cleaned_data.get("action")
notification = None
users_to_update = set()
packs_to_update = set()
if action == "Approve":
tickets.update(status=TICKET_STATUS_CLOSED)
sounds_update_params = {
'is_index_dirty': True,
'moderation_state': 'OK',
'moderation_date': datetime.datetime.now()
}
is_explicit_choice_key = mod_sound_form.cleaned_data.get(
"is_explicit")
if is_explicit_choice_key == IS_EXPLICIT_ADD_FLAG_KEY:
sounds_update_params['is_explicit'] = True
elif is_explicit_choice_key == IS_EXPLICIT_REMOVE_FLAG_KEY:
sounds_update_params['is_explicit'] = False
# Otherwise is_explicit_choice_key = IS_EXPLICIT_KEEP_USER_PREFERENCE_KEY, don't update the
# 'is_explicit' field and leave it as the user originally set it
Sound.objects.filter(ticket__in=tickets).update(
**sounds_update_params)
if msg:
notification = Ticket.NOTIFICATION_APPROVED_BUT
else:
notification = Ticket.NOTIFICATION_APPROVED
elif action == "Defer":
tickets.update(status=TICKET_STATUS_DEFERRED)
# only send a notification if a message was added
if msg:
notification = Ticket.NOTIFICATION_QUESTION
elif action == "Return":
tickets.update(status=TICKET_STATUS_NEW, assignee=None)
# no notification here
elif action == "Delete":
# to prevent a crash if the form is resubmitted
tickets.update(status=TICKET_STATUS_CLOSED)
# if tickets are being deleted we have to fill users_to_update
# and sounds_to_update before we delete the sounds and they dissapear
# from the ticket (thus losing reference)
for ticket in tickets:
users_to_update.add(ticket.sound.user.profile)
if ticket.sound.pack:
packs_to_update.add(ticket.sound.pack)
Sound.objects.filter(ticket__in=tickets).delete()
# After we delete sounds that these tickets are associated with,
# we refresh the ticket list so that sound_id is null and this does
# not affect the TicketComment post_save trigger
tickets = Ticket.objects.filter(id__in=ticket_ids)
notification = Ticket.NOTIFICATION_DELETED
elif action == "Whitelist":
ticket_ids = list(tickets.values_list('id', flat=True))
_whitelist_gearman(ticket_ids)
notification = Ticket.NOTIFICATION_WHITELISTED
users = set(tickets.values_list('sender__username', flat=True))
messages.add_message(
request, messages.INFO,
"""User(s) %s has/have been whitelisted. Some of tickets might
still appear on this list for some time. Please reload the
page in a few seconds to see the updated list of pending
tickets""" % ", ".join(users))
for ticket in tickets:
if action != "Delete":
# We only fill here users_to_update and packs_to_update if action is not
# "Delete". See comment in "Delete" action case some lines above
users_to_update.add(ticket.sound.user.profile)
if ticket.sound.pack:
packs_to_update.add(ticket.sound.pack)
invalidate_template_cache("user_header", ticket.sender.id)
invalidate_all_moderators_header_cache()
moderator_only = msg_form.cleaned_data.get(
"moderator_only", False)
if msg:
tc = TicketComment(sender=ticket.assignee,
text=msg,
ticket=ticket,
moderator_only=moderator_only)
tc.save()
# Send emails
if notification:
ticket.send_notification_emails(notification,
Ticket.USER_ONLY)
# Update number of sounds for each user
for profile in users_to_update:
profile.update_num_sounds()
# Process packs
for pack in packs_to_update:
pack.process()
else:
clear_forms = False
if clear_forms:
mod_sound_form = SoundModerationForm(initial={'action': 'Approve'})
msg_form = ModerationMessageForm()
qs = Ticket.objects.select_related('sound') \
.filter(assignee=user_id) \
.exclude(status=TICKET_STATUS_CLOSED) \
.exclude(sound=None) \
.order_by('status', '-created')
pagination_response = paginate(
request, qs, settings.MAX_TICKETS_IN_MODERATION_ASSIGNED_PAGE)
pagination_response['page'].object_list = list(
pagination_response['page'].object_list)
# Because some tickets can have related sound which has disappeared or on deletion time the ticket
# has not been properly updated, we need to check whether the sound that is related does in fact
# exist. If it does not, we set the related sound to None and the status of the ticket to closed
# as should have been set at sound deletion time.
for ticket in pagination_response['page'].object_list:
if not ticket.sound:
pagination_response['page'].object_list.remove(ticket)
ticket.status = TICKET_STATUS_CLOSED
ticket.save()
moderator_tickets_count = qs.count()
show_pagination = moderator_tickets_count > settings.MAX_TICKETS_IN_MODERATION_ASSIGNED_PAGE
tvars = {
"moderator_tickets_count": moderator_tickets_count,
"moderation_texts": MODERATION_TEXTS,
"page": pagination_response['page'],
"paginator": pagination_response['paginator'],
"current_page": pagination_response['current_page'],
"show_pagination": show_pagination,
"max_selected_tickets_in_right_panel":
settings.MAX_TICKETS_IN_MODERATION_ASSIGNED_PAGE_SELECTED_COLUMN,
"mod_sound_form": mod_sound_form,
"msg_form": msg_form,
"default_autoplay": request.GET.get('autoplay', 'on') == 'on',
"default_include_deferred": request.GET.get('include_d', '') == 'on',
}
return render(request, 'tickets/moderation_assigned.html', tvars)
def sound(request, username, sound_id):
try:
sound = Sound.objects.select_related("license", "user",
"user__profile",
"pack").get(id=sound_id)
if sound.user.username.lower() != username.lower():
raise Http404
user_is_owner = request.user.is_authenticated and \
(sound.user == request.user or request.user.is_superuser or request.user.is_staff or
Group.objects.get(name='moderators') in request.user.groups.all())
# If the user is authenticated and this file is his, don't worry about moderation_state and processing_state
if user_is_owner:
if sound.moderation_state != "OK":
messages.add_message(
request, messages.INFO,
'Be advised, this file has <b>not been moderated</b> yet.')
if sound.processing_state != "OK":
messages.add_message(
request, messages.INFO,
'Be advised, this file has <b>not been processed</b> yet.')
else:
if sound.moderation_state != 'OK' or sound.processing_state != 'OK':
raise Http404
except Sound.DoesNotExist:
if DeletedSound.objects.filter(sound_id=sound_id).exists():
return render(request, 'sounds/deleted_sound.html')
else:
raise Http404
if request.method == "POST":
form = CommentForm(request, request.POST)
if request.user.is_authenticated:
if request.user.profile.is_blocked_for_spam_reports():
messages.add_message(
request, messages.INFO,
"You're not allowed to post the comment because your account "
"has been temporaly blocked after multiple spam reports")
else:
if form.is_valid():
comment_text = form.cleaned_data["comment"]
sound.add_comment(request.user, comment_text)
try:
if request.user.profile.email_not_disabled(
"new_comment"):
# Send the user an email to notify him of the new comment!
logger.debug(
"Notifying user %s of a new comment by %s" %
(sound.user.username, request.user.username))
send_mail_template(
u'You have a new comment.',
'sounds/email_new_comment.txt', {
'sound': sound,
'user': request.user,
'comment': comment_text
}, None, sound.user.email)
except Exception as e:
# If the email sending fails, ignore...
logger.error(
"Problem sending email to '%s' about new comment: %s"
% (request.user.email, e))
return HttpResponseRedirect(sound.get_absolute_url())
else:
form = CommentForm(request)
qs = Comment.objects.select_related("user", "user__profile")\
.filter(sound_id=sound_id)
display_random_link = request.GET.get('random_browsing')
is_following = False
if request.user.is_authenticated:
users_following = follow_utils.get_users_following(request.user)
if sound.user in users_following:
is_following = True
is_explicit = sound.is_explicit and (not request.user.is_authenticated \
or not request.user.profile.is_adult)
tvars = {
'sound': sound,
'username': username,
'form': form,
'display_random_link': display_random_link,
'is_following': is_following,
'is_explicit': is_explicit,
'sizes': settings.IFRAME_PLAYER_SIZE,
}
tvars.update(paginate(request, qs, settings.SOUND_COMMENTS_PER_PAGE))
return render(request, 'sounds/sound.html', tvars)
def inbox(request):
qs = base_qs.filter(user_to=request.user, is_archived=False, is_sent=False)
return render(request, 'messages/inbox.html', paginate(request, qs))
