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).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 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 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 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 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 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 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 moderation_tary_moderators_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_moderators_tickets = list(__get_tardy_moderator_tickets_all())
return render_to_response('tickets/moderation_tardy_moderators.html', combine_dicts(paginate(request, tardy_moderators_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 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 moderation_tary_moderators_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_moderators_tickets = list(__get_tardy_moderator_tickets_all())
return render_to_response('tickets/moderation_tardy_moderators.html', combine_dicts(paginate(request, tardy_moderators_tickets, 10), locals()), context_instance=RequestContext(request))
def for_user(request, username):
user = get_object_or_404(User, username__iexact=username)
qs = Sound.public.filter(user=user)
return render_to_response('sounds/for_user.html',
combine_dicts(
paginate(request,
qs, settings.SOUNDS_PER_PAGE),
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 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 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 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 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(
request, 'sounds/pack_downloaders.html',
combine_dicts(
paginate(request, qs, 32, object_count=pack.num_downloads),
locals()))
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 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 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)
return render_to_response('sounds/downloaders.html',
combine_dicts(
paginate(request,
qs,
32,
object_count=sound.num_downloads),
locals()),
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 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(
request, 'sounds/packs.html',
combine_dicts(paginate(request, qs, settings.PACKS_PER_PAGE),
locals()))
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 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 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 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 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_to_response('forum/latest_posts.html', combine_dicts(locals(), paginator), context_instance=RequestContext(request))
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)
return render_to_response('sounds/downloaders.html', combine_dicts(paginate(request, qs, 32), locals()), context_instance=RequestContext(request))
def for_user(request, username):
user = get_object_or_404(User, username__iexact=username)
qs = Sound.public.filter(user=user)
return render_to_response('sounds/for_user.html', combine_dicts(paginate(request, qs, settings.SOUNDS_PER_PAGE), locals()), context_instance=RequestContext(request))
qs = Comment.objects.select_related("user", "user__profile").filter(
content_type=sound_content_type, object_id=sound_id
)
display_random_link = request.GET.get("random_browsing")
do_log = settings.LOG_CLICKTHROUGH_DATA
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
# facebook_like_link = urllib.quote_plus('http://%s%s' % (Site.objects.get_current().domain, reverse('sound', args=[sound.user.username, sound.id])))
return render_to_response(
"sounds/sound.html",
combine_dicts(locals(), paginate(request, qs, settings.SOUND_COMMENTS_PER_PAGE)),
context_instance=RequestContext(request),
)
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")
if sound.user.username.lower() != username.lower():
raise Http404
return HttpResponseRedirect(sound.get_absolute_url())
else:
form = CommentForm(request)
qs = Comment.objects.select_related("user", "user__profile").filter(content_type=sound_content_type, object_id=sound_id)
display_random_link = request.GET.get('random_browsing')
do_log = settings.LOG_CLICKTHROUGH_DATA
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
#facebook_like_link = urllib.quote_plus('http://%s%s' % (Site.objects.get_current().domain, reverse('sound', args=[sound.user.username, sound.id])))
return render_to_response('sounds/sound.html', combine_dicts(locals(), paginate(request, qs, settings.SOUND_COMMENTS_PER_PAGE)), context_instance=RequestContext(request))
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")
if sound.user.username.lower() != username.lower():
raise Http404
Download.objects.get_or_create(user=request.user, sound=sound)
return sendfile(sound.locations("path"), sound.friendly_filename(), sound.locations("sendfile_url"))
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, 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(content_type=sound_content_type, object_id=sound_id)
display_random_link = request.GET.get('random_browsing')
#facebook_like_link = urllib.quote_plus('http://%s%s' % (Site.objects.get_current().domain, reverse('sound', args=[sound.user.username, sound.id])))
return render_to_response('sounds/sound.html', combine_dicts(locals(), paginate(request, qs, settings.SOUND_COMMENTS_PER_PAGE)), context_instance=RequestContext(request))
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])))
sound = get_object_or_404(Sound, user__username__iexact=username, id=sound_id, moderation_state="OK", processing_state="OK")
Download.objects.get_or_create(user=request.user, sound=sound)
return sendfile(sound.locations("path"), sound.friendly_filename(), sound.locations("sendfile_url"))
def pack_download(request, username, pack_id):
from django.http import HttpResponse
if not request.user.is_authenticated():
def downloaded_packs(request, username):
user=get_object_or_404(User, username__iexact=username)
qs = Download.objects.filter(user=user.id, pack__isnull=False)
return render_to_response('accounts/downloaded_packs.html', combine_dicts(paginate(request, qs, settings.PACKS_PER_PAGE), locals()), context_instance=RequestContext(request))
def attribution(request):
qs = Download.objects.filter(user=request.user)
format = request.GET.get("format", "regular")
return render_to_response('accounts/attribution.html', combine_dicts(paginate(request, qs, 40), 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', 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, settings.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 > settings.MAX_TICKETS_IN_MODERATION_ASSIGNED_PAGE
return render_to_response('tickets/moderation_assigned.html',
combine_dicts(paginaion_response, locals()),
context_instance=RequestContext(request))
qs = Comment.objects.select_related("user", "user__profile").filter(
content_type=sound_content_type, object_id=sound_id)
display_random_link = request.GET.get('random_browsing')
do_log = settings.LOG_CLICKTHROUGH_DATA
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
#facebook_like_link = urllib.quote_plus('http://%s%s' % (Site.objects.get_current().domain, reverse('sound', args=[sound.user.username, sound.id])))
return render_to_response('sounds/sound.html',
combine_dicts(
locals(),
paginate(request, qs,
settings.SOUND_COMMENTS_PER_PAGE)),
context_instance=RequestContext(request))
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",
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))
