Python pagination.paginate函数代码示例

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 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 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=" + username + ",category_id=" + str(category_id) + ",api_key=" + request.GET.get("api_key", False) + ",api_key_username=" + request.user.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
    
    '''
    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 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

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