Exemplo n.º 1
0
    def test_cursor_caching(self):
        paginator = GaeNdbPaginator(GaeNdbPaginationModel.query().order(
            GaeNdbPaginationModel.field1),
                                    5,
                                    batch_size=2)

        paginator.page(3)

        self.assertFalse(paginator.has_cursor_for_page(2))
        self.assertFalse(paginator.has_cursor_for_page(3))
        self.assertTrue(paginator.has_cursor_for_page(5))

        paginator.page(1)
        self.assertFalse(paginator.has_cursor_for_page(2))
        self.assertTrue(paginator.has_cursor_for_page(3))
        self.assertTrue(paginator.has_cursor_for_page(5))

        with mock.patch(
                "potatopage.paginator.GaeNdbPaginator._process_batch_hook"
        ) as mock_obj:
            #Should now use the cached cursor
            page3 = paginator.page(3)
            #Should have been called with a cursor as the 3rd argument
            self.assertTrue(mock_obj.call_args[0][2])

        self.assertEqual(2, len(page3.object_list))
        self.assertEqual(10, page3.object_list[0].field1)
Exemplo n.º 2
0
    def test_basic_usage(self):
        paginator = GaeNdbPaginator(
            GaeNdbPaginationModel.query().order(GaeNdbPaginationModel.field1),
            5)

        page1 = paginator.page(1)
        self.assertEqual(5, len(page1.object_list))
        self.assertEqual(0, page1.object_list[0].field1)
        self.assertTrue(page1.has_next())
        self.assertFalse(page1.has_previous())
        self.assertEqual([1, 2], page1.available_pages())

        page2 = paginator.page(2)
        self.assertEqual(5, len(page2.object_list))
        self.assertEqual(5, page2.object_list[0].field1)
        self.assertTrue(page2.has_next())
        self.assertTrue(page2.has_previous())
        self.assertEqual([1, 2, 3], page2.available_pages())

        page3 = paginator.page(3)
        self.assertEqual(2, len(page3.object_list))
        self.assertEqual(10, page3.object_list[0].field1)
        self.assertFalse(page3.has_next())
        self.assertTrue(page3.has_previous())
        self.assertEqual([2, 3], page3.available_pages())

        self.assertRaises(EmptyPage, paginator.page, 4)
Exemplo n.º 3
0
    def test_basic_usage(self):
        paginator = GaeNdbPaginator(GaeNdbPaginationModel.query().order(GaeNdbPaginationModel.field1), 5)

        page1 = paginator.page(1)
        self.assertEqual(5, len(page1.object_list))
        self.assertEqual(0, page1.object_list[0].field1)
        self.assertTrue(page1.has_next())
        self.assertFalse(page1.has_previous())
        self.assertEqual([1, 2], page1.available_pages())

        page2 = paginator.page(2)
        self.assertEqual(5, len(page2.object_list))
        self.assertEqual(5, page2.object_list[0].field1)
        self.assertTrue(page2.has_next())
        self.assertTrue(page2.has_previous())
        self.assertEqual([1, 2, 3], page2.available_pages())

        page3 = paginator.page(3)
        self.assertEqual(2, len(page3.object_list))
        self.assertEqual(10, page3.object_list[0].field1)
        self.assertFalse(page3.has_next())
        self.assertTrue(page3.has_previous())
        self.assertEqual([2, 3], page3.available_pages())

        self.assertRaises(EmptyPage, paginator.page, 4)
Exemplo n.º 4
0
    def test_cursor_caching(self):
        paginator = GaeNdbPaginator(GaeNdbPaginationModel.query().order(GaeNdbPaginationModel.field1), 5, batch_size=2)

        paginator.page(3)

        self.assertFalse(paginator.has_cursor_for_page(2))
        self.assertFalse(paginator.has_cursor_for_page(3))
        self.assertTrue(paginator.has_cursor_for_page(5))

        paginator.page(1)
        self.assertFalse(paginator.has_cursor_for_page(2))
        self.assertTrue(paginator.has_cursor_for_page(3))
        self.assertTrue(paginator.has_cursor_for_page(5))

        with mock.patch("potatopage.paginator.GaeNdbPaginator._process_batch_hook") as mock_obj:
            #Should now use the cached cursor
            page3 = paginator.page(3)
            #Should have been called with a cursor as the 3rd argument
            self.assertTrue(mock_obj.call_args[0][2])

        self.assertEqual(2, len(page3.object_list))
        self.assertEqual(10, page3.object_list[0].field1)
Exemplo n.º 5
0
def item_list(request):
    '''
    Displays the list of pages. We did not bother with pagination in the good old days
    then potato page came in. Now if we get a request that has a page number we send
    only that bit, which also means we use basic template that only contains table
    rows
    '''
    if is_authorized_user():
        t = request.GET.get('type')

        if t == 'blog':
            pages = Page.query().filter(
                Page.blog == True).order(-Page.timestamp)
        else:
            if t == 'faq':
                pages = Faq.query().filter()
            else:
                pages = Page.query().filter(Page.blog == False)

        paginator = GaeNdbPaginator(pages, 25, batch_size=2)
        pagenum = request.GET.get('page', 1)

        if pagenum == 1:
            template = 'admin/object-list.html'
        else:
            template = 'admin/_objects.html'

        return render(request, template, {
            'pages': paginator.page(pagenum),
            'obj_type': t,
            'pagenum': pagenum
        })

    else:
        return HttpResponse("<a href='{}'>login</a>".format(
            users.create_login_url('/list/')))
Exemplo n.º 6
0
def archives(request, year=None, month=None, day=None, page=None):
    '''
    Archives is a bit tricky before there are all, yearly and monthly archives
    '''
    resp = get_page_from_cache(request)
    if not resp:  
        if year == None:
            pages = []
            for arch in Archive.query().order(-Archive.dt) : 
                pages.append('<li><a href="/blog/%d/%.2d/">%s %d</a></li>' % (arch.year, arch.month,
                                                datetime.datetime.strftime(arch.dt, '%B'), arch.year))
            n = len(pages)
            if n % 2 :
                part1 = pages[0:n/2+1]
                part2 = pages[n/2+1:]
    
            else :
                part1 = pages[0:n/2]
                part2 = pages[n/2:]
                
            return render(request, 'archives.html', 
                                  {'posts': [part1, part2] } )
            
        else :
            year = int(year)
            
            if month :
                month = int(month)
                # archives for a whole month. Finding the end of the month is 
                # tricky.
                dt_start = datetime.date(year, month, 1)
                if month == 12 :
                    dt_end = datetime.date(year +1 , 1, 1)
                else :
                    dt_end = datetime.date(year, month+1, 1)
            else : 
                # yearly archives.
                dt_start = datetime.date(year, 1, 1)
                dt_end = datetime.date(year + 1, 1, 1)
            
            pages = Page.query().filter( 
                            ndb.AND( Page.timestamp >= int(time.mktime(dt_start.timetuple()) * 1000) ,
                                     Page.timestamp < int(time.mktime(dt_end.timetuple()) * 1000),
                                     Page.draft == False )
                                      ).order(-Page.timestamp)
            
            if month :
                month = datetime.datetime.strftime(dt_start, '%B')
        
        paginator = GaeNdbPaginator(
            pages,
            per_page=settings.ITEMS_PER_PAGE,
            batch_size=2)
        pagenum = request.GET.get('page', 1)
        resp = render(request, 'archives.html',
                                  {'posts': paginator.page(pagenum),
                                   'pagenum': pagenum,
                                   'year': year,
                                   'month': month,
                                   'day': day},
                                  )
        return send_response(request, resp)

    return resp