python类EmptyPage()的实例源码

def list_vulns(request, vuln_list):
    myList = []
    for vt in vuln_list:
        positives = VulnerabilityResult.objects.all().filter(name=vt)
        apps = set(App.objects.filter(vulnerabilityresult__name=vt))
        myList.append({"name":vt, "count":positives.count, "appcount":len(apps)})
        myList.sort(key= lambda vt:vt['appcount'], reverse=True)
    paginator = Paginator(myList,20)
    page = request.GET.get('page')
    try:
        vulns = paginator.page(page)
    except PageNotAnInteger:
        vulns = paginator.page(1)
    except EmptyPage:
        vulns = paginator.page(paginator.num_pages)
    context = {'vulns':vulns}
    return render_to_response('frontpage/static_vulns.html', RequestContext(request, context))

def movie_list(request):
    paginator = Paginator(TOP_MOVIE_LIST, 25)

    page_number = request.GET.get("page")
    try:
        page = paginator.page(page_number)
    except PageNotAnInteger:
        # If page is not an integer, show first page.
        page = paginator.page(1)
    except EmptyPage:
        # If page is out of range, show last existing page.
        page = paginator.page(paginator.num_pages)

    context = {
        "object_list": page,
    }
    return render(request, "movies/movie_list.html", context)

def list_guazi(request):
    after_range_num = 5
    before_range_num = 4
    page_size = 20
    Guazi_list = GuaziCar.objects.all().order_by('-id')
    paginator = Paginator(Guazi_list, page_size)
    try:
        page = int(request.GET.get('page','1'))
        if page < 1:
            page=1
    except ValueError:
        page=1
    try:
        carlist = paginator.page(page)
    except (EmptyPage,InvalidPage,PageNotAnInteger):
        carlist = paginator.page(1)
    if page >= after_range_num:
        page_range = list(paginator.page_range)[page-after_range_num:page+before_range_num]
    else:
        page_range = list(paginator.page_range)[0:int(page)+before_range_num]
    return render(request, 'guazi.html', {'guazi_list': carlist, 'page_range': page_range})

def view_station(request, station_id):
    station = get_object_or_404(Station, abbreviation=station_id)
    incidents = Incident.objects.filter(
        station__id=station.id,
    ).order_by('-incident_dt')
    incidents_count = len(incidents)
    paginator = Paginator(incidents, 25)

    page = request.GET.get('page')
    try:
        incidents = paginator.page(page)
    except PageNotAnInteger:
        incidents = paginator.page(1)
    except EmptyPage:
        incidents = paginator.page(paginator.num_pages)

    return render(request, 'station.html', {'incidents_count': incidents_count,
                                            'station': station,
                                            'incidents': incidents})

def incidents_for_tag(request, slug):
    tag = get_object_or_404(Tag, slug=slug)
    incidents = Incident.objects.filter(
        tags__id=tag.id,
    ).order_by('-incident_dt')
    incidents_count = len(incidents)
    paginator = Paginator(incidents, 25)

    page = request.GET.get('page')
    try:
        incidents = paginator.page(page)
    except PageNotAnInteger:
        incidents = paginator.page(1)
    except EmptyPage:
        incidents = paginator.page(paginator.num_pages)

    return render(request, 'tag.html', {'tag': tag, 'incidents': incidents,
                                        'incidents_count': incidents_count})


# pylint: disable=too-many-ancestors

def results(request, template_name="search/results.html"):
    """ template for displaying settings.PRODUCTS_PER_PAGE paginated product results """
    # get current search phrase
    q = request.GET.get('q', '')
    # get current page number. Set to 1 is missing or invalid
    try:
        page = int(request.GET.get('page', 1))
    except ValueError:
        page = 1

    matching = search.products(q).get('products', [])
    # generate the pagintor object
    paginator = Paginator(matching, 
                          settings.PRODUCTS_PER_PAGE)
    try:
        results = paginator.page(page).object_list
    except (InvalidPage, EmptyPage):
        results = paginator.page(1).object_list

    search.store(request, q)

    page_title = 'Search Results for: ' + q
    return render_to_response(template_name, locals(), context_instance=RequestContext(request))

def paginate(request, qs):
    try:
        limit = int(request.GET.get('limit', 10))
    except ValueError:
        limit = 10
    if limit > 100:
        limit = 10

    try:
        page = int(request.GET.get('page', 1))
    except ValueError:
        raise Http404

    paginator = Paginator(qs, limit)

    try:
        page = paginator.page(page)
    except EmptyPage:
        page = paginator.page(paginator.num_pages)
    return page, paginator

def get_context(self, request):
        context = super(HutIndexPage, self).get_context(request)
        page = request.GET.get('page')
        tag = request.GET.get('tag')
        pages = HutPage.objects.child_of(self).live()
        if tag:
            pages = pages.filter(facilities__slug__iexact=tag)
            context['tag'] = Tag.objects.get(slug__iexact=tag)
        paginator = Paginator(pages, 10)  # Show 10 huts per page
        try:
            pages = paginator.page(page)
        except PageNotAnInteger:
            pages = paginator.page(1)
        except EmptyPage:
            pages = paginator.page(paginator.num_pages)
        context['children'] = pages
        return context

def index(request):
    template = get_template('index.html')

    attractions_data = Attractions.objects.all()
    paginator = Paginator(attractions_data, 5) # Show 10 content per page
    page = request.GET.get('page')

    try:
        content = paginator.page(page)
    except PageNotAnInteger:
    # If page is not an integer, deliver first page.
        content = paginator.page(1)
    except EmptyPage:
        # If page is out of range (e.g. 9999), deliver last page of results.
        content = paginator.page(paginator.num_pages)

    index = content.number
    max_index = len(paginator.page_range)
    start_index = max_index - 7 if index >= max_index - 5 else index - 1 if index != 1 else 1
    end_index = max_index + 1 if index >= max_index - 6 else index + 7 if index != 1 else index + 8
    page_range = range(start_index, end_index)

    html = template.render(locals())
    return HttpResponse(html)

def post_list(request, tag_slug=None):
    object_list = Post.published.all()
    tag = None

    if tag_slug:
        tag = get_object_or_404(Tag, slug=tag_slug)
        object_list = object_list.filter(tags__in=[tag])

    paginator = Paginator(object_list, 3) # 3 posts in each page
    page = request.GET.get('page')
    try:
        posts = paginator.page(page)
    except PageNotAnInteger:
        # If page is not an integer deliver the first page
        posts = paginator.page(1)
    except EmptyPage:
        # If page is out of range deliver last page of results
        posts = paginator.page(paginator.num_pages)
    return render(request,'blog/post/list.html',{'page': page, 'posts': posts, 'tag':tag})

def image_list(request):
    images = Image.objects.all()
    paginator = Paginator(images, 8)
    page = request.GET.get('page')
    try:
        images = paginator.page(page)
        images_by_popularity = Image.objects.order_by('-total_likes')

    except PageNotAnInteger:
        if request.is_ajax():
            # If page is not an integer deliver the first page
            images = paginator.page(1)

    except EmptyPage:
        if request.is_ajax():
            # If the request AJAX and the page is out of range
            # return an empty page
            return HttpResponse('')
        # If page is out of range deliver last page of results
        images = paginator.page(paginator.num_pages)

    if request.is_ajax():
        return render(request, 'images/image/list_ajax.html',{'section': 'images', 'images': images})

    return render(request, 'images/image/list.html', {'section': 'images', 'images': images})

def album_detail(request, pk):
    album = get_object_or_404(Album, pk=pk)
    photo_list = album.photo_set.all()
    paginator = Paginator(photo_list, 4)

    page = request.GET.get('page')
    try:
        photos = paginator.page(page)
    except PageNotAnInteger:
        photos = paginator.page(1)
    except EmptyPage:
        photos = paginator.page(paginator.num_pages)

    context = {
        'album': album,
        'photos': photos,
    }
    # template_file = 'photo/album_detail.html'
    template_file = 'photo/ajax_album_detail.html'
    return render(request, template_file, context)

def html_page(request):
    service_name  = request.GET.get('service_name')
    log_path = dao_config.log_dir_master
    service_name_path = log_path + service_name
    all_file = []
    for i in os.listdir(service_name_path):
        file_path = service_name_path +'/' + i
        if os.path.isfile(file_path):
            all_file.append([i,file_path])
    print(all_file)
    all_file = sorted(all_file, key=lambda file_name: file_name[1])
    paginator = Paginator(all_file, 10)  # Show 25 contacts per page
    page = request.GET.get('page')
    try:
        contacts = paginator.page(page)
    except PageNotAnInteger:
        contacts = paginator.page(1)
    except EmptyPage:
        contacts = paginator.page(paginator.num_pages)
    return render(request, 'cat_down_log.html', {"contacts": contacts,'service_name':[service_name]})

def home(request):
    # TODO: Order by groupname
    group_objs = list(Group.objects.all())

    paginator = Paginator(group_objs, 10)
    page = request.GET.get('page')
    try:
        groups = paginator.page(page)
    except PageNotAnInteger:
        # If page is not an integer, deliver first page.
        groups = paginator.page(1)
    except EmptyPage:
        # If page is out of range (e.g. 9999), deliver last page of results.
        groups = paginator.page(paginator.num_pages)

    ctx = {
        "user": request.user,
        "groups": groups,
        "group_count": len(group_objs)
    }
    return render(request, 'groups/index.html', ctx)

def home(request):
    # TODO: Order by username
    user_objs = list(User.objects.all())

    paginator = Paginator(user_objs, 10)
    page = request.GET.get('page')
    try:
        users = paginator.page(page)
    except PageNotAnInteger:
        # If page is not an integer, deliver first page.
        users = paginator.page(1)
    except EmptyPage:
        # If page is out of range (e.g. 9999), deliver last page of results.
        users = paginator.page(paginator.num_pages)

    ctx = {
        "user": request.user,
        "users": users,
        "user_count": len(user_objs)
    }
    return render(request, 'users/index.html', ctx)

def get_pager(request, qs, per_page=25, page=None):
    """
    Return django paginator for queryset.
    """
    paginator = Paginator(qs, per_page)

    if page is None:
        page = request.GET.get('page', 1)

    try:
        pager = paginator.page(page)
    except PageNotAnInteger:
        pager = paginator.page(1)
    except EmptyPage:
        pager = paginator.page(paginator.num_pages)

    return pager

def campaign_detail(request, pk):
    ''' Renders a template showing the photo results of the campaign. 20 results per page,
    with pagination capabilities at the bottom of each page.''' 

    campaign = get_object_or_404(Campaign, pk=pk)

    # Query the DB to find all Photo records associated with this campaign
    results = Photo.objects.filter(campaign_number=pk)

    # Set up the pagination of the results
    paginator = Paginator(results, 20) # Show 20 contacts per page
    page = request.GET.get('page')

    try:
        page_content = paginator.page(page)
    except PageNotAnInteger:
        # If page is not an integer, deliver first page.
        page_content = paginator.page(1)
    except EmptyPage:
        # If page is out of range (e.g. 9999), deliver last page of results.
        page_content = paginator.page(paginator.num_pages)

    return render(request, 'ig_miner_app/campaign_detail.html', {'campaign': campaign,
                                                                'results':results,
                                                                'page_content': page_content})

def simple_paging(request, qs, limit, custom_render=False):
    pager = Paginator(qs, limit)
    try: 
        page_obj = pager.page(request.page)
        qs = page_obj.object_list
    except EmptyPage:
        page_obj = {}
        qs = qs.none()

    pages = pager.page_range
    count = pager.count

    if custom_render:
        return qs, count, pages

    paginate = render_paging(request, pages, page_obj, count, limit)

    return qs, count, paginate

def project_list(request, language):
    """ Returns the projects list for a given language """
    language = get_object_or_404(Language, name=language)
    paginator = Paginator(language.project_set.order_by('-publish_date'), 6)

    if 'page' not in request.GET:
        page = 1
    else:
        page = request.GET['page']
    try:
        projects = paginator.page(page)
    except PageNotAnInteger:
        projects = paginator.page(1)
    except EmptyPage:
        projects = paginator.page(paginator.num_pages)

    context = {
        'projects': projects,
        'language': language,
    }
    return render(request, 'projects_page.html', context)

def matrix(request):
    queue_matrix = OrmQ.objects.all().order_by('lock')
    complete_matrix = Task.objects.all().filter(
        func__exact='nimbus.tasks.crawler_matrix_job',
    )
    paginator = Paginator(complete_matrix, 6) # Show 6 contacts per page
    page = request.GET.get('page')
    try:
        complete_matrix = paginator.page(page)
    except PageNotAnInteger:
        # If page is not an integer, deliver first page.
        complete_matrix = paginator.page(1)
    except EmptyPage:
        # If page is out of range (e.g. 9999), deliver last page of results.
        complete_matrix = paginator.page(paginator.num_pages)

    return render(request, 'nimbus/task_matrix_list.html', {
            'queue_matrix': queue_matrix,
            'complete_matrix': complete_matrix
    })