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))