Esempio n. 1
0
def SelfPaginator(request,List,Limit):
    '''分页模块,用法:
        1.view中引入:
        ex:from website.common.CommonPaginator import SelfPaginator
        
        2.SelfPaginator需要传入三个参数
            (1).request:获取请求数据
            (2).List:为需要分页的数据(一般为*.objects.all()取出来数据)
            (3).Limit:为每页显示的条数
        ex:lst = SelfPaginator(request,mList, 5)
        
        3.view需要获取SelfPaginator return的lst,并把lst返回给前端模板
        ex:kwvars = {'lPage':lst,}
        
        4.前端需要for循环lPage也就是lst读取每页内容
        ex:{% for i in lPage %} ... {% endfor %}
        
        5.模板页引入paginator.html
        ex:{% include "common/paginator.html" %}
    '''

    paginator = Paginator(List, int(Limit))

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

    return lst
Esempio n. 2
0
def paginacion(request,tab,modulo,url):
    if request.GET.get('pag'):
        pag=request.GET.get('pag')
        pag=int(pag)
    else:
        pag=3
    paginator = Paginator(tab,pag)
    page = 1
    if request.is_ajax():  
        query = request.GET.get('page')
        if query is not None:
            page = query
    try:
        lista = paginator.page(page)
    except (EmptyPage, InvalidPage):
        lista = paginator.page(paginator.num_pages)

    r = lista.paginator.num_pages
    p = 1
    if r >=30:
        p = 1
        r = 30

    if int(page)>30:
        s= 30*((int(page)-1)/30)
        p += s
        r += s

    nroP = (int(page)-1)*pag
    modulo.update({'lista':lista,'range':range(p,r+1),'nroP':nroP,'pag':pag})

    return render(request,url,modulo)
Esempio n. 3
0
def get_new_book(request):
    C = {}
    if request.method == 'GET':
        new_book_log = NewBookLog.objects.all()
        # books 分页
        p = Paginator(new_book_log, 15)
        try:
            page = p.page(int(request.GET.get('p', 1)))
        except:
            page = p.page(1)
        object_list = page.object_list
        C['object_list'] = object_list
        C['pagination'] = page
        return render(request, 'background/get_new_book.html', C)
    if request.method != 'POST':
        return HttpResponseBadRequest()
    book_title = request.GET.get('book_title')
    if not book_title:
        return render(request, 'background/get_new_book.html', {'no_title': True})
    try:
        book_log = NewBookLog.objects.get(book_title=book_title)
    except NewBookLog.DoesNotExist:
        pass
    else:
        return render(request, 'background/get_new_book.html', {'error': u'已经获取过了'})
    exists_book = Book.objects.filter(title=book_title)
    if exists_book:
        return render(request, 'background/get_new_book.html', {'error': u'书籍已存在!', 'books': exists_book})
    try:
        task_result = get_new_book_with_book_name.delay(book_title)
    except UserWarning as e:
        return render(request, 'background/get_new_book.html', {'error': e})
    NewBookLog.objects.create(book_title=book_title, task_id=str(task_result.id))
    return render(request, 'background/get_new_book.html', {'success': True, 'book_title': book_title})
Esempio n. 4
0
def news_list(request):

    object_list = News.objects.filter(status__exact='published').order_by('-created',)

    for obj in object_list:
        try:
            trans = obj.translations.get(language__iexact=request.LANGUAGE_CODE)
        except NewsTranslation.DoesNotExist:
            trans = None

        if trans:
            if trans.title:
                obj.title = trans.title
            if trans.text:
                obj.text = trans.text

    # pagination
    paginator = Paginator(object_list, getattr(settings, 'PAGINATOR_CT_PER_PAGE', 10))

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

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

    return render_to_response('reviewapp/news_list.html', {
                              'objects': objects,
                              'page': page,
                              'paginator': paginator, },
                               context_instance=RequestContext(request))
Esempio n. 5
0
def page(request, page_id=1, node_id=0, popular=False):
    nav_name = ''
    topics = Topic.objects.order_by('-last_reply_time')
    if popular:
        topics = topics.order_by('-reply_count', '-last_reply_time')
        nav_name = 'Popular'
    elif node_id:
        node = Node.objects.get(id=node_id)
        topics = topics.filter(node=node)
        count = topics.count()
        nav_name = node.title

    # Pagination
    limit = 10
    paginator = Paginator(topics, limit)
    try:
        topics = paginator.page(page_id)
    except EmptyPage:
        topics = paginator.page(paginator.num_pages)

    user = request.user
    context = {
        'topics': topics,
        'user': user,
        'node_id': node_id,
        'nav_name': nav_name,
    }

    return render_to_response('index.html', context,
                              context_instance=RequestContext(request))
Esempio n. 6
0
def _list_groups(request, template, query):
    """Lists groups from given query."""

    sort_form = SortForm(request.GET)
    show_pagination = False

    if sort_form.is_valid():
        query = query.order_by(sort_form.cleaned_data['sort'], 'name')
    else:
        query = query.order_by('name')

    paginator = Paginator(query, settings.ITEMS_PER_PAGE)

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

    if paginator.count > settings.ITEMS_PER_PAGE:
        show_pagination = True

    data = dict(groups=groups, page=page, sort_form=sort_form, show_pagination=show_pagination)
    return render(request, template, data)
Esempio n. 7
0
def view_members_api(request):
    from django.contrib.auth.models import User
    from users.models import Account, Character

    corporation_id = request.user.get_profile().main_char.corporation_id
    characters = Character.objects.filter(corporation_id=corporation_id)
    acounts = Account.objects.filter(id__in=characters.values_list('account').distinct())
    users = User.objects.filter(id__in=characters.values_list('account__user_name').distinct()).order_by('username')
    paginator = Paginator(users, 10)
    try:
        users_list = paginator.page(request.GET.get('page'))
    except PageNotAnInteger:
        users_list = paginator.page(1)
    except EmptyPage:
        users_list = paginator.page(paginator.num_pages)
    nesty_api_keys = dict()
    for user in users_list:
        nesty_api_keys[user] = acounts.filter(user_name=user)
    return render_to_response(
        'corp/view_api.html',
        {
            'users_and_keys': nesty_api_keys,
            'pagination': users_list
        },
        context_instance=RequestContext(request)
    )
Esempio n. 8
0
def get_paginator(objects, page, limit):
    """
    Create and return a Paginator filled with the objects and paginated
    at the given page.

    Args:
        ``objects`` (list): A list of objects to be paginated.

        ``page`` (int): The current page of the pagination. If it is not
        a valid integer, the first page is used. If the page provided is
        bigger than the nuber of pages available, the last page is
        returned.

        ``limit`` (int): The number of items per page.

    Returns:
        ``django.core.paginator.Page``. The paginated data.

        ``django.core.paginator.Paginator``. The Paginator object.
    """
    paginator = Paginator(objects, limit)
    try:
        paginated = paginator.page(page)
    except PageNotAnInteger:
        # If page is not an integer, deliver first page.
        paginated = paginator.page(1)
    except EmptyPage:
        # If page is out of range (e.g. 9999), deliver last page of results.
        paginated = paginator.page(paginator.num_pages)
    return paginated, paginator
Esempio n. 9
0
def dashboard(request):
    if request.user.is_authenticated():
        try:
            me = UserProfile.objects.get(user=request.user)
        except UserProfile.DoesNotExist:
            display_name = request.user
            return redirect('/register/')
    neos = Neo.objects.all().extra(
           select={
               'display_name': 'SELECT display_name FROM neo_userprofile WHERE neo_userprofile.id = neo_neo.user_id'
           },
        )

    paginator = Paginator(neos, 50)
    # Make sure page request is an int. If not, deliver first page.
    try:
        page = int(request.GET.get('page', '1'))
    except ValueError:
        page = 1
    # If page request (9999) is out of range, deliver last page of results.
    try:
        neo_list = paginator.page(page)
    except (EmptyPage, InvalidPage):
        neo_list = paginator.page(paginator.num_pages)

    if request.user.is_authenticated():
        return render(request, 'dashboard.html', {'neo_list': neo_list, 'page': page, 'me': me})
    return render(request, 'dashboard.html', {'neo_list': neo_list, 'page': page})
Esempio n. 10
0
def visual_index(request, **kwargs):

    all_neurons, search_form = get_form_and_neurons( request,
                                                     kwargs['project_id'],
                                                     kwargs )

    # From: http://docs.djangoproject.com/en/1.0/topics/pagination/
    paginator = Paginator(all_neurons, 5)
    if 'page' in kwargs:
        page = kwargs['page'] or 1
    else:
        try:
            page = int(request.GET.get('page', '1'))
        except ValueError:
            page = 1

    # If page request (9999) is out of range, deliver last page of results.
    try:
        neurons = paginator.page(page)
    except (EmptyPage, InvalidPage):
        neurons = paginator.page(paginator.num_pages)

    return my_render_to_response(request,
                                 'vncbrowser/visual_index.html',
                                 {'sorted_neurons': neurons.object_list,
                                  'sorted_neurons_page' : neurons,
                                  'project_id': kwargs['project_id'],
                                  'catmaid_url': settings.CATMAID_URL,
                                  'user': kwargs['logged_in_user'],
                                  'search_form': search_form })
Esempio n. 11
0
def user_list(request):
    context = RequestContext(request)

    if request.method == 'POST':
        form = forms.FindUserForm(request.POST)
        if form.is_valid():
            username = form.cleaned_data.get('username')
            try:
                user = models.User.objects.get(username=username)
                return redirect('kegadmin-edit-user', user.id)
            except models.User.DoesNotExist:
                messages.error(request, 'User "%s" does not exist.' % username)

    users = models.User.objects.exclude(username='******').order_by('-id')
    paginator = Paginator(users, 25)

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

    context['users'] = users
    return render_to_response('kegadmin/user_list.html', context_instance=context)
Esempio n. 12
0
    def post(self, request, *args, **kwargs):
        template_name = "drinkersList.html"
        http_method_names = ['get', 'post']
        user = self.request.user
        models = locateDrinkers
        form = forms.LocateDrinkersForm(request.POST)
        if form.is_valid():
          # The form is valid and can be saved to the database
          # by calling the 'save()' method of the ModelForm instance.
          searchAttributes = form.save(commit=False)
          print "searchAttributes.boozshopaddress", searchAttributes.boozshopaddress
          #searchResults = boozProfiles.objects.filter(Booz_shop_location__icontains=searchAttributes.boozshopaddress)
          searchResults = boozProfiles.objects.all()
          paginator = Paginator(searchResults, 25) # Show 25 contacts per page
          page = request.GET.get('page')
          print "searchResults.query", searchResults.query
          print "searchResults::" ,str(searchResults)
          try:
              profilePerPages = paginator.page(page)
          except PageNotAnInteger:
              profilePerPages = paginator.page(1)
          except EmptyPage:
              profilePerPages = paginator.page(paginator.num_pages)

          return render_to_response("drinkersList.html", {"profilePerPages": profilePerPages})


          # This means that the request is a GET request. So we need to
          # create an instance of the TShirtRegistrationForm class and render it in
          # the template
        else:
            form = forms.LocateDrinkersForm(request.POST)
            return render(request, "locatedrinkers.html", { 'form' : form })
Esempio n. 13
0
def view_groups(request):
    """
    Django View. List all groups.

    @type request: C{django.http.HttpRequest}
    @param request: Client Request object
    """

    groups_list = models.BookiGroup.objects.all().extra(select={'lower_name': 'lower(name)'}).order_by('lower_name')

    paginator = Paginator(groups_list, 50) 

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

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

    return render_to_response('portal/groups.html', {"request": request, 
                                                     "title": "Booki groups", 
                                                     "groups": groups })
Esempio n. 14
0
def _list(request, is_active, is_formal):
    potential_list = Potential.objects.filter(is_active=is_active, is_formal=is_formal)
    paginator = Paginator(potential_list, 6) # 6 records / per page

    page = request.GET.get('page') # pageNo

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

    list = []
    for potential in potentials:
        list.append(potential.tojson())

    response_data = {}
    response_data['potentials'] = list
    response_data['paginator.num_pages'] = potentials.paginator.num_pages
    response_data['number'] = potentials.number

    return response_data
Esempio n. 15
0
def profile_search_id(request):

    queryset = profiles.objects.all().order_by('-timestamp')
    for object in queryset:
        if object.pId == "TMG":
            object.pId = "TMG00" + str(object.tmId)
            object.save()

    query = request.GET.get('pid')

    if query:
        instance = get_object_or_404(profiles,pId=str(query))
        return HttpResponseRedirect(instance.get_absolute_url())

    paginator = Paginator(queryset, 5)  # Show 5 contacts per page

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

    content = {
        "objectset": queryset1,
        "title": "list"
    }
    return render(request, "profile_search_id.html", content)
Esempio n. 16
0
def adminInsumoDetail(request, insumo):
	insumo = get_object_or_404(Insumo, pk = insumo) 
	entradas = Entrada.objects.filter(insumo=insumo)
	salidas = Salida.objects.filter(insumo=insumo)
	template =  get_template("admininsumodetail.html")
	sort = request.GET.get('o') #orden del query filter
	if sort == None: #si no hay orden en URL se refiere a -fecha 
		sort = '-fecha'
	filters = EntradasFilter(request.GET, queryset=Entrada.objects.filter(insumo=insumo))
	paginator = Paginator(filters, 10)
	page = request.GET.get('page')
	try:
		entradas= paginator.page(page)
	except PageNotAnInteger:
        # Si la pagina no es un entero muestra la primera pagina
		entradas = paginator.page(1)
	except EmptyPage:
        # si la pagina esta fuera de rango, muestra la ultima pagina
		entradas = paginator.page(paginator.num_pages)


	context = {
        'insumo': insumo, 'entradas': entradas,'filters': filters,'sort':sort,
    }
	return HttpResponse(template.render(context, request))
Esempio n. 17
0
def system_install_record(request):
    """
    List all operating system installation records
    """
    
    user = request.user 
    if request.method == 'POST':
        search_fields = request.POST.get('search')
    else:
        try:
            search_fields = request.GET.get('search','none')
        except ValueError:
            search_fields = 'none'
    if search_fields == 'none':
        record = InstallRecord.objects.all().order_by('-id')       
    else:
        record = InstallRecord.objects.filter(hostname__contains=search_fields).order_by('-id')   
    paginator = Paginator(record,12)

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

    try:
        record = paginator.page(page)
    except :
        record = paginator.page(paginator.num_pages)
 
    return render_to_response('install_record_list.html', {'record': record, 'page': page, 'paginator':paginator,'search':search_fields,'request':request},context_instance=RequestContext(request))
Esempio n. 18
0
def content_type_use(request, content_type_app_name, content_type_model_name):
    try:
        content_type = ContentType.objects.get_by_natural_key(content_type_app_name, content_type_model_name)
    except ContentType.DoesNotExist:
        raise Http404

    p = request.GET.get("p", 1)

    page_class = content_type.model_class()

    # page_class must be a Page type and not some other random model
    if not issubclass(page_class, Page):
        raise Http404

    pages = page_class.objects.all()

    paginator = Paginator(pages, 10)

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

    return render(request, 'wagtailadmin/pages/content_type_use.html', {
        'pages': pages,
        'app_name': content_type_app_name,
        'content_type': content_type,
        'page_class': page_class,
    })
Esempio n. 19
0
def view_members_numbers(request):
    from corp.models import CorporationMemberNumber

    corporation = Corporation.objects.get(corp_id=request.user.get_profile().main_char.corporation_id)
    paginator = Paginator(corporation.all_users(), 10)
    try:
        users = paginator.page(request.GET.get('page'))
    except PageNotAnInteger:
        users = paginator.page(1)
    except EmptyPage:
        users = paginator.page(paginator.num_pages)
    users_dict = {
        u: {
            a: [
                c for c in a.char_by_corp(corporation_id=corporation.corp_id)
            ] for a in u.get_accounts_by_corp(corporation_id=corporation.corp_id)
        } for u in users.object_list
    }
    return render_to_response(
        'corp/view_numbers.html',
        {
            'pagination': users,
            'ticker': corporation.ticker,
            'corporation_id': corporation.corp_id,
            'users': users_dict
        },
        context_instance=RequestContext(request)
    )
Esempio n. 20
0
def index(request, parent_page_id=None):
    if parent_page_id:
        parent_page = get_object_or_404(Page, id=parent_page_id)
    else:
        parent_page = Page.get_first_root_node()

    pages = parent_page.get_children().prefetch_related('content_type')

    # Get page ordering
    ordering = request.GET.get('ordering', '-latest_revision_created_at')
    if ordering not in ['title', '-title', 'content_type', '-content_type', 'live', '-live', 'latest_revision_created_at', '-latest_revision_created_at', 'ord']:
        ordering = '-latest_revision_created_at'

    # Pagination
    if ordering != 'ord':
        ordering_no_minus = ordering
        if ordering_no_minus.startswith('-'):
            ordering_no_minus = ordering[1:]
        pages = pages.order_by(ordering).annotate(null_position=Count(ordering_no_minus)).order_by('-null_position', ordering)

        p = request.GET.get('p', 1)
        paginator = Paginator(pages, 50)
        try:
            pages = paginator.page(p)
        except PageNotAnInteger:
            pages = paginator.page(1)
        except EmptyPage:
            pages = paginator.page(paginator.num_pages)

    return render(request, 'wagtailadmin/pages/index.html', {
        'parent_page': parent_page,
        'ordering': ordering,
        'pagination_query_params': "ordering=%s" % ordering,
        'pages': pages,
    })
Esempio n. 21
0
def subsection_item(request, forum_subsection_id):
    subsection = ForumSubSection.objects.get(id = forum_subsection_id)
    forum_section = subsection.forum_section
    subsections = forum_section.forumsubsection_set.all()
    kong_threads_list = subsection.threads.order_by('-last_modified')
    search_form = SearchForm()
    
    # Show 25 kong threads per page
    paginator = Paginator(kong_threads_list, 25)

    # Make sure page request is an int. If not, deliver first page.
    try:
        page = int(request.GET.get('page', 1))
    except ValueError:
        page = 1

    # If page request (9999) is out of range, deliver last page of results.
    try:
        kong_threads = paginator.page(page)
    except (EmptyPage, InvalidPage):
        kong_threads = paginator.page(paginator.num_pages)

    
    return direct_to_template(request,  'subsection_item.html',  {'kong_threads' : kong_threads,  
                                                                                                    'current_forum_section' : forum_section, 
                                                                                                    'forum_sections' : ForumSection.objects.order_by('title'),
                                                                                                    'subsections' : subsections, 
                                                                                                    'current_subsection' : subsection, 
                                                                                                'search_form' : search_form})
Esempio n. 22
0
 def get_context_data(self):
     paginator = Paginator(newest_posts(), 100)
     try:
         p = paginator.page(self.request.GET.get('page', '1'))
     except PageNotAnInteger:
         p = paginator.page('1')
     return dict(posts=p.object_list, paginator=p)
Esempio n. 23
0
def all(request):
    """
    Index page for authenticated user
    """
    return render(request, 'notifications/list.html', {
        'notifications': request.user.notifications.all()
    })
    actions = request.user.notifications.all()

    paginator = Paginator(actions, 16) # Show 16 notifications per page
    page = request.GET.get('p')

    try:
        action_list = paginator.page(page)
    except PageNotAnInteger:
        # If page is not an integer, deliver first page.
        action_list = paginator.page(1)
    except EmptyPage:
        # If page is out of range (e.g. 9999), deliver last page of results.
        action_list = paginator.page(paginator.num_pages)
        
    return render_to_response('notifications/list.html', {
        'member': request.user,
        'action_list': action_list,
    }, context_instance=RequestContext(request))
Esempio n. 24
0
def make_pages(form, page):
    paginator = Paginator(form, 10)
    try:
        form = paginator.page(page)
    except PageNotAnInteger:
        form = paginator.page(1)
    except EmptyPage:
        form = paginator.page(paginator.num_pages)
    
    for d in form: 
        try:
            docdata = MetaData.objects.get(link=d.url)
            reviewed = docdata.reviewed
            if reviewed == True:
                reviewed_true.append(str(docdata.link))
                
            processed = docdata.processed
            if processed == True:
                processed_true.append(str(docdata.link))

            notes[d.url] = docdata.notes
            
        except MetaData.DoesNotExist:
            continue
    
    for d in form:  
        try:
            debug(Registrant.objects.get(reg_id=int(d.reg_id)))
            reg = Registrant.objects.get(reg_id=d.reg_id)
            names[d.reg_id] = reg.reg_name
        except Registrant.DoesNotExist:
            continue
    
    return form 
Esempio n. 25
0
def index(request, pg=1):
    context = RequestContext(request)
    context_dict = {}

    allposts = BlogPost.objects.all().order_by("-created")
    p = Paginator(allposts, 5)
    try:
        recent_posts = p.page(pg).object_list
    except:  # no page exception - dont know what it is
        recent_posts = p.page(1).object_list
    posts = []

    for i in recent_posts:
        words = i.body.split(' ')
        if len(words) < 30:
            l = len(words)
        else:
            l = 30

        slug = ' '.join([x for x in words[0:l]]) + "..."
        posts.append({'title': i.title,
                    'slug': slug,
                    'pk': i.pk,
                    'object':i})

    context_dict['posts'] = posts
    context_dict['curr_page'] = int(pg)
    return render_to_response('blog/index.html', context_dict, context)
Esempio n. 26
0
def photo_review(request, instance):
    page_number = int(request.REQUEST.get('page', '1'))
    sort_order = request.REQUEST.get('sort', '-created_at')
    is_archived = request.REQUEST.get('archived', 'False') == 'True'

    photos = get_photos(instance, sort_order, is_archived)
    paginator = Paginator(photos, _PHOTO_PAGE_SIZE)

    try:
        paged_photos = paginator.page(page_number)
    except EmptyPage:
        # If the page number is out of bounds, return the last page
        paged_photos = paginator.page(paginator.num_pages)

    urlizer = UrlParams('photo_review', instance.url_name, page=page_number,
                        sort=sort_order, archived=is_archived)

    return {
        'photos': paged_photos,
        'sort_order': sort_order,
        'is_archived': is_archived,
        'is_archived_text': _("Archived") if is_archived else _("Active"),
        'is_archived_text_lower': (_("archived") if is_archived
                                   else _("active")),
        'url_for_pagination': urlizer.url('sort', 'archived'),
        'url_for_filter': urlizer.url('sort'),
        'url_for_sort': urlizer.url('archived'),
        'full_params': urlizer.params('page', 'sort', 'archived')
    }
Esempio n. 27
0
def serialy_index(request):
    o = TVSeries.objects.all().order_by('new_show__title')
    new = Episode.objects.all().order_by('-new_episode__date').select_related('partOfSeries')#.prefetch_related()
    unique = []
    a = []
    for item in new:
        if item.partOfSeries.id not in a:
            unique.append(item)
            a.append(item.partOfSeries.id)

    pagnation = Paginator(unique, 9)
    page = request.GET.get('page')
    try:
        newest = pagnation.page(page)
    except PageNotAnInteger:
        newest = pagnation.page(1)
    except EmptyPage:
        newest = pagnation.page(pagnation.num_pages)
    p = TVSeries.objects.all().annotate(num_views=Count('views')).order_by('num_views')[:10]

    pop_show = random.choice(p)
    recent_shows = TVSeries.objects.all().order_by('-new_show__date')[:2]


    return render(request, 'series/series.html',{'popular_show': pop_show,
        'recent_shows': recent_shows,
        'new_episodes': newest,
        'all_shows': o})
Esempio n. 28
0
 def render(self, context, instance, placeholder):
     feed = get_cached_or_latest_feed(instance)
     if not feed:
         entries = []
         is_paginated = False
     else:
         if instance.paginate_by:
             is_paginated = True
             request = context['request']
             feed_page_param = "feed_%s_page" % str(instance.id)
             feed_paginator = Paginator(
                 feed['entries'], instance.paginate_by)
             # Make sure page request is an int. If not, deliver first page.
             try:
                 page = int(request.GET.get(feed_page_param, '1'))
             except ValueError:
                 page = 1
             # If page request (9999) is out of range, deliver last page of
             # results.
             try:
                 entries = feed_paginator.page(page)
             except (EmptyPage, InvalidPage):
                 entries = feed_paginator.page(feed_paginator.num_pages)
         else:
             entries = feed["entries"]
             is_paginated = False
     context.update({
         'instance': instance,
         'feed_entries': entries,
         'is_paginated': is_paginated,
         'placeholder': placeholder,
     })
     return context
Esempio n. 29
0
def doctor(request):
    # 获取所有的医生
    doctorAll = models.Actor.objects.all()

    # 姓名模糊查询
    if request.GET.get("keyword", None):
        doctorAll = doctorAll.filter(name__contains=request.GET.get("keyword"))

    # 数据分页
    from django.core.paginator import Paginator
    # 实例化分页类
    paginator = Paginator(doctorAll, 10)

    # 获取当前页码
    p = int(request.GET.get('p', 1))

    # 获取分页数据对象[{id:1},{id:2}]  [{id:3},{id:4}]
    doctorAll = paginator.page(p)

    return render(request, "myadmin/doctor-list.html",
                  {"doctorAll": doctorAll})
Esempio n. 30
0
    def get(self, request):
        all_courses = Course.objects.all().order_by('-add_time')
        # 对课程排序
        sort = request.GET.get('sort', '')
        if sort:
            if sort == "students":
                all_courses = all_courses.order_by("-students")
            elif sort == "hot":
                all_orgs = all_courses.order_by("-click_nums")

        # 搜索关键词: 课程搜索
        search_keywords = request.GET.get('keywords', '')
        if search_keywords:
            # 根据课程名字、描述、详情搜索
            all_courses = all_courses.filter(
                Q(name__icontains=search_keywords)|
                Q(desc__icontains=search_keywords)|
                Q(detail__icontains=search_keywords)
            )

        # 对课程列表进行分页
        page_num = 1
        try:
            page_num = int(request.GET.get('page', '1'))
        except Exception:
            # 如果传来的page是个字符,就不能转成int
            page_num = 1
        p = Paginator(all_courses, 3)
        courses = p.page(page_num)

        # 热门课程
        hot_courses = all_courses.order_by('-click_nums')[:3]

        return render(request, 'course_list.html',{
            'all_courses': courses,
            "page_num_list": range(1, p.num_pages + 1),
            'sort': sort,
            'hot_courses': hot_courses,
            'search_keywords': search_keywords,
        })
Esempio n. 31
0
def ordinary_search(request):

    from django.db.models import Q

    search_keywords = request.GET.get('q', '')
    pindex = request.GET.get('pindex', 1)
    search_status = 1
    cart_num, guest_cart = 0, 0

    try:
        user_id = request.session['user_id']
    except:
        user_id = None

    if user_id:
        guest_cart = 1
        cart_num = CartInfo.objects.filter(user_id=int(user_id)).count()

    goods_list = GoodsInfo.objects.filter(
        Q(gtitle__icontains=search_keywords) |
        Q(gcontent__icontains=search_keywords) |
        Q(gjianjie__icontains=search_keywords)).order_by("gclick")

    if goods_list.count() == 0:
        # 商品搜索结果为空,返回推荐商品
        search_status = 0
        goods_list = GoodsInfo.objects.all().order_by("gclick")[:4]

    paginator = Paginator(goods_list, 4)
    page = paginator.page(int(pindex))

    context = {
        'title': '搜索列表',
        'search_status': search_status,
        'guest_cart': guest_cart,
        'cart_num': cart_num,
        'page': page,
        'paginator': paginator,
    }
    return render(request, 'df_goods/ordinary_search.html', context)
Esempio n. 32
0
 def get(self, request):  #按(提交人|提交结果|提交语言|提交问题)查询第page页的提交列表
     submit_UserName = request.GET.get('submit_UserName', '')
     judge_States = request.GET.get('judege_States', '')
     language = request.GET.get('language', '')
     problem_Id = request.GET.get('problem_Id', '')
     page_Num = request.GET.get('page', 1)
     query_Criteria = {}  # 创建一个多条件查询字典
     if submit_UserName != '':
         query_Criteria[
             'user__username__iregex'] = submit_UserName  #用户名不区分大小写
     if judge_States != '' and judge_States != '0':
         query_Criteria['result'] = judge_States
     if language != '' and language != 'All':  # 当值为C++时不知道为什么传不过来,推测可能是无法解析
         if language == 'Csrc':
             query_Criteria['language'] = 'C++'
         else:
             query_Criteria['language'] = language
     if problem_Id != '':
         try:
             query_Criteria['problem__no'] = int(problem_Id)
         except:
             pass
     submit_List = ProblemSubmit.objects.filter(**query_Criteria)
     submit_List = list(reversed(submit_List))  #反转 使最近提交在前
     change_status(submit_List)
     paginator_OfSubmitListAll = Paginator(submit_List, 25)  #分页
     paginator_OfSubmitListAll = paginator_OfSubmitListAll.page(page_Num)
     paginator_OfSubmitListAll = paginator_OfSubmitListAll.object_list
     paginator_OfSubmitListAll = ProblemSubmitListSerializer(
         paginator_OfSubmitListAll, many=True).data
     data = {'status': 200, 'msg': '获取成功', 'data': {}}
     data['data'] = {
         'statuses': paginator_OfSubmitListAll,
         'now_page': page_Num,
         'submit_user_name': submit_UserName,
         'judge_states': judge_States,
         'language': language,
         'problem_id': problem_Id
     }
     return JsonResponse(data)
Esempio n. 33
0
def customers_inline(request,
                     template_name="manage/customer/customers_inline.html"):
    """Displays carts overview.
    """
    customer_filters = request.session.get("customer-filters", {})
    ordering = request.session.get("customer-ordering", "id")

    temp = _get_filtered_customers(request, customer_filters)

    paginator = Paginator(temp, 30)

    page = request.REQUEST.get("page", 1)
    page = paginator.page(page)

    customers = []
    for customer in page.object_list:
        try:
            cart = Cart.objects.get(session=customer.session)
            cart_price = cart.get_price_gross(request, total=True)
        except Cart.DoesNotExist:
            cart_price = None

        orders = Order.objects.filter(session=customer.session)
        customers.append({
            "customer": customer,
            "orders": len(orders),
            "cart_price": cart_price,
        })

    return render_to_string(
        template_name,
        RequestContext(
            request, {
                "customers": customers,
                "page": page,
                "paginator": paginator,
                "start": customer_filters.get("start", ""),
                "end": customer_filters.get("end", ""),
                "ordering": ordering,
            }))
Esempio n. 34
0
    def get(self, request, category_id, page_num):
        try:
            category = GoodsCategory.objects.get(id=category_id)
        except GoodsCategory.DoesNotExist:
            return http.HttpResponseForbidden('category_id不存在')

        # 接收前端传入的sort = 'xxx'
        sort = request.GET.get('sort', 'default')

        if sort == 'price':
            sort_filed = '-price'
        elif sort == 'hot':
            sort_filed = '-sales'
        else:
            sort = 'default'
            sort_filed = 'create_time'


        # 把当前三级类型下的所有要上架的sku拿到
        sku_qs = category.sku_set.filter(is_launched=True).order_by(sort_filed)
        # 创建分页器 Paginator(要进行分页的所有数据, 指定每页显示多少条数据)
        paginator = Paginator(sku_qs, 5)
        try:
            # 获取指定页的数据  16 // 5   +  (1 if (16 % 5) else 0)
            page_skus = paginator.page(page_num)   #  (2 - 1) * 5:  5*2 - 1
        except EmptyPage:
            return http.HttpResponseForbidden('非法请求,不没指定页')
        # 获取总页数
        total_page = paginator.num_pages

        context = {
            'categories': get_categories(),  # 商品类别数据
            'breadcrumb': get_breadcrumb(category),  # 面包屑导航
            'sort': sort,  # 排序字段
            'category': category,  # 第三级分类
            'page_skus': page_skus,  # 分页后数据
            'total_page': total_page,  # 总页数
            'page_num': page_num,  # 当前页码
        }
        return render(request, 'list.html', context)
Esempio n. 35
0
    def create_list_dataset(self, querysets: list, serializers: list, page: int, page_length:int=25, context:dict={}):
        """Creates a formatted, paginated, standardized list dataset that we can return
        to the user

        Args:
            querysets (list): a list of querysets that will be returned in the dataset
            serializers (list): the list of serializers to use to serializer the querysets
            page (int): the page of the list
            page_length (int): The length of the page
            context (:obj:`dict`, optional): The context to hand to the serializers when they
                serializer the objects

        Returns:
            dict: A dictionary in the following format::
            {
                count: 100,
                page: 1,
                page_length: 15,
                items: []
            }

        """
        data = {"count": 0, "page_length": page_length, "items": []}

        count = 0
        obj_list = []
        for queryset, serializer in zip(querysets, serializers):
            count += len(queryset)
            obj_list.extend(serializer(queryset, context=context, many=True).data)

        paginator = Paginator(obj_list, page_length)
        try:
            p_page = paginator.page(page)
        except (InvalidPage, EmptyPage) as e:
            p_page = Page([], page, paginator)

        data["items"] = p_page.object_list
        data["count"] = count

        return data
Esempio n. 36
0
 def get(self, request, page):
     '''显示'''
     # 获取用户的订单信息
     user = request.user
     orders = OrderInfo.objects.filter(user=user).order_by('-create_time')
     # 遍历获取订单商品信息
     for order in orders:
         order_skus = OrderGoods.objects.filter(order_id=order.order_id)
         # 遍历计算小计
         for order_sku in order_skus:
             amount = order_sku.count * order_sku.price
             # 动态增加属性
             order_sku.amount = amount
         order.status_name = OrderInfo.ORDER_STATUS[order.order_status]
         order.order_skus = order_skus
     # 分页
     paginator = Paginator(orders, 3)
     # 获取指定页的内容
     try:
         page = int(page)
     except Exception as result:
         page = 1
     # 获取page页内容的Page对象
     order_page = paginator.page(page)
     # 进行页码的控制,使其只显示5个页码
     num_pages = paginator.num_pages
     # 总页数小于5,显示所有
     if num_pages < 5:
         pages = range(1, num_pages + 1)
     # 当前页小于3,显示前五页
     elif page <= 3:
         pages = range(1, 6)
     # 当前页大于3,显示后5页
     elif num_pages - page <= 2:
         pages = range(num_pages - 4, num_pages + 1)
     # 显示前两页,当前页,后两页
     else:
         pages = range(page - 2, page + 3)
     context = {'order_page': order_page, 'pages': pages, 'page': 'order'}
     return render(request, 'user_center_order.html', context)
Esempio n. 37
0
    def get(self, request):
        """提供首页广告界面"""
        # ?cat_id=xxx&page_num=xxx&page_size=xxx
        cat_id = request.GET.get('cat_id', 1)

        # 判断分类id
        try:
            category = ArticleCategory.objects.get(id=cat_id)
        except ArticleCategory.DoesNotExist:
            return HttpResponseNotFound('没有此分类')

        # 获取博客分类信息
        categories = ArticleCategory.objects.all()
        # 获取分页参数
        page_num = request.GET.get('page_num', 1)
        page_size = request.GET.get('page_size', 10)
        # 分页数据
        articles = Article.objects.filter(category=category)
        # 创建分页器
        from django.core.paginator import Paginator, EmptyPage
        paginator = Paginator(articles, per_page=page_size)
        # 进行分页处理
        try:
            page_articles = paginator.page(page_num)
        except EmptyPage:
            # 如果没有分页数据,默认给用户404
            return HttpResponseNotFound('empty page')
        # 总页数
        total_page = paginator.num_pages

        context = {
            'categories': categories,
            'category': category,
            'articles': page_articles,
            'page_size': page_size,
            'total_page': total_page,
            'page_num': page_num,
        }

        return render(request, 'index.html', context=context)
Esempio n. 38
0
def paginate(request):
    page = int(request.GET.get('page', 1))
    list_sz = request.GET.get('size')
    p2_sz = request.GET.get('psize')
    select_sz = request.GET.get('select_size')

    try:
        queryset_list = Product.objects.all().order_by('-id')
        if list_sz:
            paginator = Paginator(queryset_list, int(list_sz))
            queryset_list = paginator.page(page)
            product_results = queryset_list
            data = {
                'product_results': product_results,
                'pn': paginator.num_pages,
                'sz': list_sz,
                'gid': 0
            }
            return TemplateResponse(request, 'dashboard/product/roles/p2.html',
                                    data)
        else:
            paginator = Paginator(queryset_list, 10)
            if p2_sz:
                paginator = Paginator(queryset_list, int(p2_sz))
            queryset_list = paginator.page(page)
            product_results = queryset_list
            data = {'product_results': product_results, 'sz': p2_sz}
            return TemplateResponse(request,
                                    'dashboard/product/roles/paginate.html',
                                    data)

        try:
            queryset_list = paginator.page(page)
        except PageNotAnInteger:
            queryset_list = paginator.page(1)
        except InvalidPage:
            queryset_list = paginator.page(1)
        except EmptyPage:
            queryset_list = paginator.page(paginator.num_pages)
        product_results = queryset_list
        return TemplateResponse(request,
                                'dashboard/product/roles/paginate.html', {
                                    'product_results': product_results,
                                    'sz': p2_sz
                                })
    except Exception, e:
        return HttpResponse()
Esempio n. 39
0
def display_hosts(request, current_page=1):
    user = UserProfile.objects.get(email=request.user)
    host_obj_list = user.bind_host.select_related()
    group_obj_list = user.host_groups.select_related()
    for group_obj in group_obj_list:
        host_obj_list = host_obj_list.union(
            group_obj.bind_hosts.select_related())

    # page paging
    page = Paginator(host_obj_list, PER_PAGE_COUNT)
    # print('page_list===',page.page(1).object_list)
    curr_page = page.page(current_page)
    curr_page_list = curr_page.object_list
    page_range = page.page_range
    page_has_nex = curr_page.has_next()
    page_has_pre = curr_page.has_previous()
    if page_has_pre:
        page_num_pre = curr_page.previous_page_number()
    if page_has_nex:
        page_num_nex = curr_page.next_page_number()

    return render(request, 'hosts.html', locals())
Esempio n. 40
0
def org_role_index(request, o_role=1, textfield23=1):
    """
    角色首页
    :param request:
    :return:
    """
    role_all = Role.objects.all()
    # role_all = RoleMenu.objects.all()
    paginator = Paginator(role_all, 5)  # 分页
    if o_role == '':
        o_role = 1
    else:
        o_role = int(o_role)
    page = paginator.page(o_role)
    textfield23 = request.POST.get('textfield23')
    print(paginator.page_range)  # 返回分页列表
    num = paginator.page_range
    # for i in num:
    #     if textfield23 == i:
    #         print(i)
    return render(request, 'pages/org/role/role-list.html',
                  {'role_all': page, 'count': paginator, })
Esempio n. 41
0
def contest_list_page(request, page=1):
    """
    所有比赛的列表页
    """
    # 正常情况
    contests = Contest.objects.filter(visible=True).order_by("-create_time")

    # 搜索的情况
    keyword = request.GET.get("keyword", None)
    if keyword:
        contests = contests.filter(Q(title__contains=keyword) | Q(description__contains=keyword))

    # 筛选我能参加的比赛
    join = request.GET.get("join", None)
    if request.user.is_authenticated and join:
        contests = contests.filter(Q(contest_type__in=[1, 2]) | Q(groups__in=request.user.group_set.all())). \
            filter(end_time__gt=datetime.datetime.now(), start_time__lt=datetime.datetime.now())
    paginator = Paginator(contests, 20)
    try:
        current_page = paginator.page(int(page))
    except Exception:
        return error_page(request, u"不存在的页码")

    previous_page = next_page = None

    try:
        previous_page = current_page.previous_page_number()
    except Exception:
        pass

    try:
        next_page = current_page.next_page_number()
    except Exception:
        pass

    return render(request, "oj/contest/contest_list.html",
                  {"contests": current_page, "page": int(page),
                   "previous_page": previous_page, "next_page": next_page,
                   "keyword": keyword, "join": join})
Esempio n. 42
0
def pos_list(request, pIndex):
    ge = ''
    gl = ''
    kw = 'position'
    lists = Jobs.objects.filter()
    if request.GET['edu'] != '':
        print('edu')
        ge = request.GET['edu']
        lists = Jobs.objects.filter(Q(edu__contains=ge))
    try:
        if request.GET['position'] != '':
            print('posi')
            kw = 'position'
            gl = request.GET['position']
            lists = lists.filter(Q(name__contains=gl) | Q(info__contains=gl))
    except:
        if request.GET['company'] != '':
            kw = 'company'
            gl = request.GET['company']
            lists = lists.filter(co_name__contains=gl)
    lists = lists[:150]
    p = Paginator(lists, 15)
    #处理当前页号信息
    if pIndex == "":
        pIndex = '1'
    pIndex = int(pIndex)
    #获取当前页数据
    lists2 = p.page(pIndex)
    plist = p.page_range
    # 下拉--月薪
    context = {
        'poslists': lists2,
        'pIndex': pIndex,
        'plist': plist,
        'gl': gl,
        'ge': ge,
        'kw': kw
    }
    return render(request, 'index.html', context)
Esempio n. 43
0
def orgs_funding(request):
    fundings = OrgFundingOpp.objects.filter(
        Q(publish=True)
        & Q(lang=request.LANGUAGE_CODE)).order_by('-created_at')

    myFilter = OrgsFundingFilter(request.GET, queryset=fundings)
    fundings = myFilter.qs

    # PAGINATEUR
    paginator = Paginator(fundings, 12)
    page = request.GET.get('page')
    try:
        fundings = paginator.get_page(page)
    except (EmptyPage, InvalidPage):
        fundings = paginator.page(paginator.num_pages)

    context = {
        'fundings': fundings,
        'myFilter': myFilter,
    }
    return render(request, 'orgs/funding_opport/orgs/org_funding.html',
                  context)
    def test_pagination_middle(self):

        numpages = 100
        begin_pages = 3
        end_pages = 6
        before_current_pages = 5
        after_current_pages = 6

        for x in range(0, numpages * self.perpage):
            get_user_model().objects.create(username="******" % x)

        paginator = Paginator(get_user_model().objects.all(), per_page=self.perpage)

        for x in range(numpages/2, numpages/2 + before_current_pages):
            page = paginator.page(x)
            context = pagination.pagination(page, begin_pages, end_pages, before_current_pages, after_current_pages)

            self.assertEqual(context['num_pages'], numpages)
            self.assertEqual(context['page'], page)
            self.assertEqual(context['begin'], range(1, begin_pages+1))
            self.assertEqual(context['middle'], range(max(x-before_current_pages, 0), x+after_current_pages+1))
            self.assertEqual(context['end'], range(numpages - end_pages + 1, numpages+1))
Esempio n. 45
0
def bus_stations(request):
    read_file_with_station = list(
        DictReader(open(settings.BUS_STATION_CSV, encoding='cp1251')))

    paginator = Paginator(read_file_with_station, 10)
    current_page = int(request.GET.get('page', 1))
    current_stations = paginator.page(current_page)

    return render_to_response(
        'index.html',
        context={
            'bus_stations':
            current_stations.object_list,
            'current_page':
            current_page,
            'prev_page_url':
            f'bus_stations?page={current_stations.previous_page_number()}'
            if current_stations.has_previous() else None,
            'next_page_url':
            f'bus_stations?page={current_stations.next_page_number()}'
            if current_stations.has_next() else None,
        })
Esempio n. 46
0
    def get_context_data(self, *args, **kwargs):
        context = super(CollectionReferencesView, self).get_context_data(*args, **kwargs)
        self.get_args()

        api = OclApi(self.request, debug=True)
        results = api.get(self.owner_type, self.owner_id, 'collections', self.collection_id)
        collection = results.json()

        params = self.request.GET.copy()
        params['verbose'] = 'true'
        params['limit'] = '10'

        versions = self.get_collection_versions(
            self.owner_type, self.owner_id, self.collection_id,
            search_params={'limit': '0'})

        searcher = self.get_collection_data(
            self.owner_type, self.owner_id, self.collection_id, 'references',
            collection_version_id=self.collection_version_id,
            search_params=params)
        search_results_paginator = Paginator(range(searcher.num_found), searcher.num_per_page)
        search_results_current_page = search_results_paginator.page(searcher.current_page)

        context['kwargs'] = self.kwargs
        context['url_params'] = self.request.GET
        context['selected_tab'] = 'References'
        context['collection'] = collection
        context['references'] = searcher.search_results
        context['results'] = searcher.search_results
        context['current_page'] = search_results_current_page
        context['pagination_url'] = self.request.get_full_path()
        context['search_query'] = searcher.get_query()
        context['search_filters'] = searcher.search_filter_list
        context['search_sort_options'] = searcher.get_sort_options()
        context['search_sort'] = self.request.GET.get('search_sort', 'ASC')
        context['search_facets_json'] = searcher.search_facets
        context['search_filters_debug'] = str(searcher.search_filter_list)
        context['collection_versions'] = versions.search_results
        return context
Esempio n. 47
0
def index(httpRequest,pindex):
	'''浏览信息'''
	mod = Users.objects.all()
	keyword = httpRequest.GET.get('search',None)
	sexValue = httpRequest.GET.get('select','')
	
	where=[]
	if keyword:
		mod = mod.filter(Q(username__contains =keyword) | Q(name__contains=keyword))
		where.append('search='+keyword)
	else:
		mod = mod.filter()
	if sexValue != '' and sexValue !='-1':
		mod = mod.filter(sex = (sexValue))
		where.append('select='+sexValue)
	else:
		mod = mod.filter()
	
	where = "&".join(where)
	p = Paginator(mod,2)#两条一页
	
	list2 = p.page(pindex) #拿取第pindex页的数据
	list3 = p.page_range
	if p.num_pages == 1:
		nextPage = 1
		prePage = 1
	elif pindex == str(p.num_pages):
		nextPage = p.num_pages
		prePage = list2.previous_page_number()
		# nextPage = p.next_page_number()
	elif pindex == '1':
		prePage = '1'
		nextPage = list2.next_page_number()
	else:
		nextPage = list2.next_page_number()
		prePage = list2.previous_page_number()

	data={"data":list2,'list3':list3,'pindex':int(pindex),'nextPage':nextPage,'prePage':prePage,'where':where}
	return render(httpRequest,'myadmin/users/users.html', data)
Esempio n. 48
0
def paginator(objects, request, default_page=1, default_size=50):
    """ Get from request page and page_size and return paginated objects

    :param objects: all queryset
    :param request: view request object
    :param default_page: start page if there is no page in GET
    :param default_size: page size if there is no page in GET
    :return: paginated objects
    """
    page_size = request.GET.get('page_size',
                                request.GET.get('length', default_size))
    if 'start' in request.GET:
        page = int_from_request(request.GET, 'start', default_page)
        page = page / int(page_size) + 1
    else:
        page = int_from_request(request.GET, 'page', default_page)

    if page_size == '-1':
        return objects
    else:
        paginator = Paginator(objects, page_size)
        return paginator.page(page).object_list
Esempio n. 49
0
def posts(request, page):
    # Try to load authenticated user
    try:
        person = get_object_or_404(Person, username=request.user.username)

    except:
        person = None

    # Load all posts order by there publish time
    posts = Post.objects.all().order_by('-publish_time')
    paginate = Paginator(posts, 3) # Paginate by 3

    # Load banner
    try:
        ad = Ad.objects.filter(type='صفحه اول')
        ad = choice(ad)

        while ad.available_views == '0':
            ad.delete()
            ad = choice(Ad.objects.filter(type='صفحه اول'))

        ad.available_views = int(ad.available_views) - 1
        ad.save()

    except:
        ad = None

    context = {
        'person': person,
        'posts': paginate.page(page),
        'ad': ad,
    }

    # Add authenticated user and it's new notifications to context
    mskf.add_notification_availability_to_context(request, context)
    mskf.add_authenticated_user_to_context(request, context)

    # Show "index" page template to user
    return render(request, 'index.html', context)
Esempio n. 50
0
def my_products(request, number_page, pk):
    all_prod = Product.objects.all()
    user_id = auth.get_user(request).id
    my_prod = all_prod.filter(saler=user_id)

    q = request.GET.get('q')
    if pk == 0:
        my_prod = all_prod.filter(saler=user_id)
    if pk == 1:
        my_prod = my_prod.filter(category='telephone')
    if pk == 2:
        my_prod = my_prod.filter(category='tablet')
    if pk == 3:
        my_prod = my_prod.filter(category='laptop')
    if q is not None:
        my_prod = my_prod.filter(name__icontains=q)
    curent_page = Paginator(my_prod, 6)
    if int(number_page) > curent_page.num_pages:
        number_page = curent_page.num_pages
    my_prod = curent_page.page(number_page)
    context = {'my_prod': my_prod, 'filter': q, 'pk': pk}
    return render(request, 'my_products.html', context=context)
Esempio n. 51
0
def index(request):
    #把数据显示成按照数据的一个类别进行排序
    #显示所有数据
    data=models.Booktype.objects.extra(select={'paths':'concat(path,id)'}).order_by("paths")

    #获取对应的请求数据
    btype=request.GET.get("btype",None)
    keywords=request.GET.get("keywords",None)

     # 根据搜索框显示符合条件的数据 
    if btype=='all' or btype=='catename':
        if keywords:
            #根据分类名和父类名查询
            data=models.Booktype.objects.filter(
                    Q(catename__contains=keywords) 
            )
    elif btype=='pname':
        search={'catename__contains':keywords}
        #根据父类名查找父类id
        if keywords.isdigit():
            return HttpResponse("<script>alert('请输入有效的类别名进行查询');location.href='/myadmin/type/index';</script>")
        ob=models.Booktype.objects.filter(**search)
        for i in ob:
            data=models.Booktype.objects.filter(pid=i.id)

    # 实例化分页类
    p = Paginator(data,5)
    # 获取当前的页码数
    pageindex = request.GET.get('page',1)
    # 获取当前页的数据
    typelist = p.page(pageindex)
    # 获取所有页码
    # pages = p.page_range
    # 获取总页数
    pages = p.num_pages
    # 最终显示的结果数据
    ob=selectAlltype(typelist)      
    context={'typelist':ob,'page':pages}
    return render(request,'myadmin/types/index.html',context)
Esempio n. 52
0
def make_pages(messages, page_number):
    # Paginate
    p = Paginator(messages, 10)
    num_pages = p.num_pages
   
    # Return max 10 messages
    if num_pages > 1:
        messages = p.page(page_number).object_list

    # Check min and max
    previous = page_number - 1
    next = page_number + 1

    # Return values
    return {
        "messages": messages,
        "num_pages": num_pages,
        "page_range": p.page_range,
        "curr_page": page_number,
        "previous": previous,
        "next": next
    }
Esempio n. 53
0
 def check_indexes(self, params, page_num, indexes):
     """
     Helper method that instantiates a Paginator object from the passed
     params and then checks that the start and end indexes of the passed
     page_num match those given as a 2-tuple in indexes.
     """
     paginator = Paginator(*params)
     if page_num == 'first':
         page_num = 1
     elif page_num == 'last':
         page_num = paginator.num_pages
     page = paginator.page(page_num)
     start, end = indexes
     msg = (
         "For %s of page %s, expected %s but got %s. Paginator parameters were: %s"
     )
     self.assertEqual(
         start, page.start_index(),
         msg % ('start index', page_num, start, page.start_index(), params))
     self.assertEqual(
         end, page.end_index(),
         msg % ('end index', page_num, end, page.end_index(), params))
Esempio n. 54
0
def post_list(request):
    post_list = Post.objects.filter(
        published_date__lte=timezone.now()).order_by('published_date')
    query = request.GET.get('q')
    print(query)
    if query:
        que = list(query.split(" "))

        print(que)
        post_list = Post.objects.filter(
            Q(tags__name__in=que)).distinct().order_by('published_date')
    print(post_list)
    if not post_list:
        return render(request, 'Notes/discussion_list.html',
                      {'posts': post_list})

    paginator = Paginator(post_list, 3, allow_empty_first_page=True)
    page = request.GET.get('page', 1)

    posts = paginator.page(page)

    return render(request, 'Notes/discussion_list.html', {'posts': posts})
Esempio n. 55
0
def movies_form(request):
    if get_session(request):
        pass
    else:
        return HttpResponseRedirect("/login")
    user_id = request.session["user_id"]
    user_name = request.session["user_name"]
    user_fav = models.User_favorite.objects.all().filter(user_id=user_id)
    movies = models.MovieInfo.objects.all().order_by('top')

    if request.method == 'POST':
        movie_id = request.POST.get("movie_id")
        if not user_fav.filter(url_object_id=movie_id).exists():
            models.User_favorite.objects.create(user_id=user_id,
                                                url_object_id=movie_id)
        else:
            user_fav.filter(url_object_id=movie_id).delete()
        print(movie_id)

    paginator = Paginator(movies, 25)
    current_page = int(request.GET.get('page', 1))
    if paginator.num_pages > 7:
        if current_page - 3 < 1:
            page_ran = range(1, 8)
        elif current_page + 3 > paginator.num_pages:
            page_ran = range(paginator.num_pages - 6, paginator.num_pages + 1)
        else:
            page_ran = range(current_page - 3, current_page + 4)
        page_range = page_ran
    else:
        page_range = paginator.page_range
    current_page_content = paginator.page(current_page)
    return render(
        request, 'movies_form.html', {
            "movies": current_page_content,
            "page_range": page_range,
            "user_fav": user_fav,
            "user_name": user_name
        })
    def test_pagination_begin(self):

        numpages = 100
        begin_pages = 2
        end_pages = 4
        before_current_pages = 6
        after_current_pages = 8

        for x in range(0, numpages * self.perpage):
            get_user_model().objects.create(username="******" % x)

        paginator = Paginator(get_user_model().objects.all(), per_page=self.perpage)

        for x in range(1, begin_pages+1):
            page = paginator.page(x)
            context = pagination.pagination(page, begin_pages, end_pages, before_current_pages, after_current_pages)

            self.assertEqual(context['num_pages'], numpages)
            self.assertEqual(context['page'], page)
            self.assertEqual(context['begin'], range(1, min(before_current_pages + after_current_pages, numpages)+1))
            self.assertEqual(context['middle'], [])
            self.assertEqual(context['end'], range(numpages - end_pages + 1, numpages+1))
Esempio n. 57
0
def index(request):
    try:
        page = int(request.GET.get('page'))
    except:
        page = 1
    background_image = "/static/img/diary_" + str(random.randint(0,
                                                                 2)) + ".jpg"
    article_list = Article.objects.all().order_by('-time')
    paginator = Paginator(article_list, 5)
    nowPage = paginator.page(page)
    is_paginated = (paginator.num_pages > 1)
    context = {
        'article_list': nowPage.object_list,
        'is_paginated': is_paginated,
        'page_obj': nowPage,
        'Host': Host,
        'background_image': background_image,
        'paginator': paginator,
    }
    pagination_data = pagination_data_fun(paginator, nowPage, is_paginated)
    context.update(pagination_data)
    return render(request, 'index.html', context)
Esempio n. 58
0
def list_handle(request, tid, pindex, sort):
    typeinfo = TypeInfo.objects.get(pk=int(tid))
    news = typeinfo.goodsinfo_set.order_by('-id')[0:2]
    if sort == '1':  # 按最新排序
        goods_list = GoodsInfo.objects.filter(
            gtype_id=int(tid)).order_by('-id')
    if sort == '2':  # 按价格排序
        goods_list = GoodsInfo.objects.filter(
            gtype_id=int(tid)).order_by('-gprice')
    if sort == '3':  # 按热度排序
        goods_list = GoodsInfo.objects.filter(
            gtype_id=int(tid)).order_by('-gclick')
    paginator = Paginator(goods_list, 10)
    page = paginator.page(int(pindex))
    context = {
        'page': page,
        'paginator': paginator,
        'typeinfo': typeinfo,
        'sort': sort,
        'news': news,
    }
    return render(request, 'df_goods/list.html', context)
Esempio n. 59
-1
def show_chat(request,to):
    from_user = request.user
    to_user = get_object_or_404(User,username=to)
    if from_user==to_user:
        messages.error(request,_(u'Вы не можете написать сообщение самому себе'))
#        messages.error(request,_(u'Can not write email to yourself'))
        return HttpResponseRedirect(request.META['HTTP_REFERER'])
    #get existed chat
    chat= Chat.objects.filter(from_user=from_user,to_user=to_user) or Chat.objects.filter(to_user=from_user,from_user=to_user)
    if chat:
        chat=chat[0]

    msgs=None
    if chat:
        if chat.from_user==from_user:
            chat.is_from_user_read=False
        else:
            chat.is_to_user_read=False
        chat.save()
        msgs= chat.comments.all()
        msgs=Paginator(msgs,10)
        try:
            page = request.GET['page']
        except:
            page = 1

        try:
            msgs = msgs.page(page)
        except (EmptyPage, InvalidPage):
            msgs = msgs.page(msgs.num_pages)

    return render_to_response('cart/message.html',{'chat':chat,'msgs':msgs,'to':to},context_instance=RequestContext(request))
Esempio n. 60
-18
def story_page(request, story_id, story_slug):
    """
    A page or part of story.
    @story_id
    @story_slug
    """
    user = request.user
    all_parts = Part.objects.filter(story = story_id).order_by('order')
    paginator = Paginator(all_parts, 1)
    page = request.GET.get('page')
    story = Story.objects.get(id = story_id)
    
    # If the slug is wrong, redirect to the correct url
    story_slug_db = story.slug
    if story_slug_db != story_slug:
        url = "/story/" + str(story.id) + "/" + str(story_slug_db) + "/"
        return HttpResponseRedirect(url)
    
    try:
        parts = paginator.page(page)
    except (PageNotAnInteger, TypeError):
        parts = paginator.page(1)
    except EmptyPage:
        parts = paginator.page(paginator.num_pages)
    
    c = {"parts": parts,
	"story":story,
         "user": user,}
    return render_to_response('book.html', c, context_instance = RequestContext(request))