Пример #1
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)
Пример #2
0
def pagination():
    class BookTable(tables.Table):
        name = tables.Column()

    # create some sample data
    data = []
    for i in range(100):
        data.append({"name": "Book No. %d" % i})
    books = BookTable(data)

    # external paginator
    paginator = Paginator(books.rows, 10)
    assert paginator.num_pages == 10
    page = paginator.page(1)
    assert page.has_previous() is False
    assert page.has_next() is True

    # integrated paginator
    books.paginate(page=1)
    Assert(hasattr(books, "page")) is True

    books.paginate(page=1, per_page=10)
    Assert(len(list(books.page.object_list))) == 10

    # new attributes
    Assert(books.paginator.num_pages) == 10
    Assert(books.page.has_previous()) is False
    Assert(books.page.has_next()) is True

    # exceptions are converted into 404s
    with Assert.raises(Http404) as error:
        books.paginate(Paginator, page=9999, per_page=10)
        books.paginate(Paginator, page='abc', per_page=10)
Пример #3
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 })
Пример #4
0
def paginate_context(request, model, urlbase, object_list, page, **kwargs):
    '''
    Helper function to make standard pagination available for the template
    "snapboard/page_navigation.html"
    '''
    page = int(page)
    pindex = page
    page_next = None
    page_prev = None
    page_range = None

    paginator = Paginator(object_list, _userdata(request, 'tpp'))
    try:
        object_page = paginator.page(pindex)
    except InvalidPage:
        raise InvalidPage

    if object_page.has_next():
        page_next = page + 1
    if object_page.has_previous():
        page_prev = page - 1
    if paginator.num_pages > 2:
        page_range = range(1, paginator.num_pages+1)

    return {
            'page': page,
            'page_total': paginator.num_pages,
            'page_next': page_next,
            'page_prev': page_prev,
            'page_range': page_range,
            model.__name__.lower() + '_page': object_page.object_list,
            'page_nav_urlbase': urlbase,
        }
Пример #5
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 })
Пример #6
0
    def paginate_items(self, items, page):
        """
        Paginate the list of items, if needed.
        """
        paginate_by = self.get_paginate_by(items)
        allow_empty = self.get_allow_empty()
        if not paginate_by:
            if not allow_empty and len(items) == 0:
                raise Http404("Empty list and '%s.allow_empty' is False." % self.__class__.__name__)
            return (None, None, items)

        paginator = Paginator(items, paginate_by, allow_empty_first_page=allow_empty)
        page = page or self.request.GET.get('page', 1)
        try:
            page_number = int(page)
        except ValueError:
            if page == 'last':
                page_number = paginator.num_pages
            else:
                raise Http404("Page is not 'last', nor can it be converted to an int.")
        try:
            page = paginator.page(page_number)
            return (paginator, page, page.object_list)
        except InvalidPage:
            raise Http404('Invalid page (%s)' % page_number)
Пример #7
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 })
Пример #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
Пример #9
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)
Пример #10
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})
Пример #11
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
Пример #12
0
    def get_results(self, request):
        if not SEARCH_VAR in request.GET:
            return super(SearchChangeList, self).get_results(request)

        # Note that pagination is 0-based, not 1-based.
        sqs = SearchQuerySet().models(self.model).auto_query(request.GET[SEARCH_VAR]).load_all()

        paginator = Paginator(sqs, self.list_per_page)
        # Get the number of objects, with admin filters applied.
        result_count = paginator.count
        full_result_count = SearchQuerySet().models(self.model).all().count()

        can_show_all = result_count <= list_max_show_all(self)
        multi_page = result_count > self.list_per_page

        # Get the list of objects to display on this page.
        try:
            result_list = paginator.page(self.page_num+1).object_list
            # Grab just the Django models, since that's what everything else is
            # expecting.
            result_list = [result.object for result in result_list]
        except InvalidPage:
            result_list = ()

        self.result_count = result_count
        self.full_result_count = full_result_count
        self.result_list = result_list
        self.can_show_all = can_show_all
        self.multi_page = multi_page
        self.paginator = paginator
Пример #13
0
    def build_page(self):
        """
        Paginates the results appropriately.

        In case someone does not want to use Django's built-in pagination, it
        should be a simple matter to override this method to do what they would
        like.
        """
        try:
            page_no = int(self.request.GET.get('page', 1))
        except (TypeError, ValueError):
            raise Http404("Not a valid number for page.")

        if page_no < 1:
            raise Http404("Pages should be 1 or greater.")

        start_offset = (page_no - 1) * self.results_per_page
        self.results[start_offset:start_offset + self.results_per_page]

        paginator = Paginator(self.results, self.results_per_page)

        try:
            page = paginator.page(page_no)
        except InvalidPage:
            raise Http404("No such page!")

        return (paginator, page)
Пример #14
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,
    })
Пример #15
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))
Пример #16
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)
Пример #17
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,
    })
Пример #18
0
    def index(self, page=1):
        # prepare result
        result = self.get_default_result("genres", page)

        object_list = Genre.objects.all()
        object_list = self.source_set_order(object_list)

        # get data
        paginator = Paginator(object_list, self.count)
        try:
            page_obj = paginator.page(page)
        except InvalidPage:
            return result

        result = self.result_set_order(result)
        result["hasNextPage"] = page_obj.has_next()
        for item in page_obj.object_list:
            dataset = {
                "id": item.id,
                "genre": item.Name,
            }

            result["itemList"].append(dataset)

        return result
Пример #19
0
    def index(self, page=1):
        # prepare result
        result = self.get_default_result("years", page)

        object_list = Song.objects.values("Year").distinct()
        object_list = object_list.exclude(Year=None).exclude(Year=0)
        object_list = self.source_set_order(object_list)

        # get data
        paginator = Paginator(object_list, self.count)
        try:
            page_obj = paginator.page(page)
        except InvalidPage:
            return result

        result = self.result_set_order(result)
        result["hasNextPage"] = page_obj.has_next()
        for item in page_obj.object_list:
            dataset = {
                "year": item["Year"],
            }

            result["itemList"].append(dataset)

        return result
Пример #20
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 
Пример #21
0
    def test_page_getitem(self):
        """
        Tests proper behavior of a paginator page __getitem__ (queryset
        evaluation, slicing, exception raised).
        """
        paginator = Paginator(Article.objects.order_by('id'), 5)
        p = paginator.page(1)

        # Make sure object_list queryset is not evaluated by an invalid __getitem__ call.
        # (this happens from the template engine when using eg: {% page_obj.has_previous %})
        self.assertIsNone(p.object_list._result_cache)
        with self.assertRaises(TypeError):
            p['has_previous']
        self.assertIsNone(p.object_list._result_cache)
        self.assertNotIsInstance(p.object_list, list)

        # Make sure slicing the Page object with numbers and slice objects work.
        self.assertEqual(p[0], Article.objects.get(headline='Article 1'))
        self.assertQuerysetEqual(p[slice(2)], [
            "<Article: Article 1>",
            "<Article: Article 2>",
        ]
        )
        # After __getitem__ is called, object_list is a list
        self.assertIsInstance(p.object_list, list)
Пример #22
0
	def post(self,page=1):
		searchText = self.request.get('searchtext')	
		try:
			page = int(page)
		except:
			page = 1
		courses = Course.all()
		allcourses = []
		for course in courses:
			if searchText in course.tags:
				course.tagstring = GetCourseTags(course.courseid)
				course.creatoremail = GetUserEmailFromGuser(course.createdbyuser)
				course.usercanreg = UserCanRegister(users.get_current_user().user_id(), course.courseid)
				course.regcount = GetCourseRegCount(course.courseid)
				allcourses.append(course)

		paginator = Paginator(allcourses,3)
		#if page>=paginator:
		#	page = paginator

		self.template_values = {
            "courses" : paginator.page(page).object_list
            ,"pages" : paginator.page_range
            ,"page" : page
		}

		page_display(self,"templates/coursesearch.html")
Пример #23
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
Пример #24
0
def list_projects(request):
    """
    A list of all projects in cloud teams
    """
    q = request.GET.get('q', '')
    qs = Project.objects.filter(Q(title__icontains=q) | Q(description__icontains=q) |
                                Q(category__icontains=q))

    # ordering
    order = request.GET.get('order', 'latest')
    if order == 'most-popular':
        qs = qs.annotate(num_followers=Count('followed')).order_by('-num_followers', '-created')
    else:
        order = 'latest'
        qs = qs.order_by('-created')

    pages = Paginator(qs, 10)

    context = {
        'n_of_projects': Project.objects.all().count(),
        'page_obj': pages.page(int(request.GET.get('page', '1'))),
        'q': q,
        'order': order
    }

    return render(request, 'ct_projects/project/all.html', context)
Пример #25
0
def prereg(request):
    """Redirects to prereg page if user has prereg access
    :param request: Current logged in user
    :return: Redirect to prereg page with username, reviewers, and user obj
    """
    paginator = Paginator(get_prereg_drafts(user=request.user), 5)

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

    page = paginator.page(page_number)

    try:
        drafts = [serializers.serialize_draft_registration(d, json_safe=False) for d in page]
    except EmptyPage:
        drafts = []

    for draft in drafts:
        draft['form'] = DraftRegistrationForm(draft)

    context = {
        'drafts': drafts,
        'page': page,
        'IMMEDIATE': serializers.IMMEDIATE,
    }
    return render(request, 'pre_reg/prereg.html', context)
Пример #26
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)
Пример #27
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')
    }
Пример #28
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))
Пример #29
0
def audit(request):

    audit_log_list = tables.table_filter(request, admin.AuditLogAdmin,
                                         models.AuditLog)
    order_res = tables.get_orderby(request, audit_log_list,
                                   admin.AuditLogAdmin)
    paginator = Paginator(order_res[0], admin.AuditLogAdmin.list_per_page)

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

    table_obj = tables.TableHandler(request, models.AuditLog,
                                    admin.AuditLogAdmin, audit_log_objs,
                                    order_res)

    return render(request, "audit.html", {
        'table_obj': table_obj,
        'paginator': paginator
    })
Пример #30
0
def AssetinfoView(request):
    assetinfo_list = AssetInfo.objects.all()
    obj_list = []
    if assetinfo_list:
        for obj in assetinfo_list:
            if obj.delstatus == 0:
                obj_list.append(obj)

    allcount = len(obj_list)

    paginate_by = settings.PAGE_NUM
    paginator = Paginator(obj_list, paginate_by)
    page = request.GET.get('page')
    try:
        obj_list = paginator.page(page)
    except PageNotAnInteger:
        obj_list = paginator.page(1)
    except EmptyPage:
        obj_list = paginator.page(paginator.num_pages)
    return render(request, 'include/assetinfo/assetinfo.html', {
        'obj_list': obj_list,
        'allcount': allcount,
        'sel_list': assetinfo_list
    })
Пример #31
0
    def get_context_data(self, **kwargs):
        # Get the context of this class based view.
        modified_context = super().get_context_data(**kwargs)

        # Validate the template selected.
        template = self.kwargs['template']
        if template not in ['search', 'summary', 'list']:
            from django.core.exceptions import PermissionDenied
            raise PermissionDenied(_('You entered wrong format.'))
        modified_context['template'] = template

        # Lookup the acitivty sheet items for this associate.
        jobs = WorkOrder.objects.filter(
            associate = modified_context['associate']
        ).prefetch_related(
            'associate',
            'customer'
        ).order_by('-completion_date')

        # Added our job state filtering.
        job_state = self.request.GET.get('job_state', 'all')
        if job_state != "all":
            jobs = jobs.filter(state=job_state)

        # Add pagination.
        paginator = Paginator(jobs, 25) # Show 25 contacts per page
        page = self.request.GET.get('page', 1)
        jobs_items = paginator.get_page(page)

        modified_context['paginated_job_items'] = jobs_items

        # Added boolean to view based on whether user is in management.
        modified_context['user_is_management_or_executive_staff'] = self.request.user.is_management_or_executive_staff()

        # Return our modified context.
        return modified_context
Пример #32
0
def logview(request, userid):
    user = User.objects.filter(id__exact=userid)[0]
    vardict = {}
    logtype = request.GET.get("logtype", 'dns')
    deltype = request.GET.get("del")
    if deltype == 'dns':
        DNSLog.objects.filter(user=user).delete()
        return HttpResponseRedirect('/?logtype=dns')
    if deltype == 'web':
        WebLog.objects.filter(user=user).delete()
        return HttpResponseRedirect('/?logtype=web')
    if logtype == 'dns':
        vardict['logtype'] = logtype
        dnspage = getpage(request.GET.get("dnspage", 1))
        paginator = Paginator(DNSLog.objects.filter(user=user), 10)
        try:
            dnslogs = paginator.page(dnspage)
        except(EmptyPage, InvalidPage, PageNotAnInteger):
            dnspage = paginator.num_pages
            dnslogs = paginator.page(paginator.num_pages)
        vardict['dnspage'] = dnspage
        vardict['pagerange'] = paginator.page_range
        vardict['dnslogs'] = dnslogs
        vardict['numpages'] = paginator.num_pages
    elif logtype == 'web':
        vardict['logtype'] = logtype
        webpage = getpage(request.GET.get("webpage", 1))
        paginator = Paginator(WebLog.objects.filter(user=user), 10)
        try:
            weblogs = paginator.page(webpage)
        except(EmptyPage, InvalidPage, PageNotAnInteger):
            webpage = paginator.num_pages
            weblogs = paginator.page(paginator.num_pages)
        vardict['webpage'] = webpage
        vardict['pagerange'] = paginator.page_range
        vardict['weblogs'] = weblogs
        vardict['numpages'] = paginator.num_pages
    else:
        return HttpResponseRedirect('/')

    vardict['userdomain'] = user.udomain + '.' + settings.DNS_DOMAIN

    vardict['udomain'] = str(user.udomain)
    vardict['admindomain'] = str(settings.ADMIN_DOMAIN)

    return render_to_response('views.html', vardict)
Пример #33
0
def popular(request, *args, **kwargs):

    try:
        limit = int(request.GET.get('limit', 10))
        if limit < 0 or limit > 100:
            limit = 10
    except:
        limit = 10
    try:
        page = int(request.GET.get('page', 1))
        if page < 0:
            page = 1
    except:
        page = 1

    paginator = Paginator(Question.objects.popular(), limit)
    paginator.baseurl = "?page="
    questions = paginator.page(page)

    return render(request, 'popular.html', {
        'questions': questions,
        'paginator': paginator,
        'page': page
    })
Пример #34
0
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})
Пример #35
0
 def render(self, context):
     key = self.queryset_var.var
     value = self.queryset_var.resolve(context)
     if isinstance(self.paginate_by, int):
         paginate_by = self.paginate_by
     else:
         paginate_by = self.paginate_by.resolve(context)
     paginator = Paginator(value, paginate_by, self.orphans)
     try:
         page_obj = paginator.page(context['request'].page)
     except InvalidPage:
         if INVALID_PAGE_RAISES_404:
             raise Http404('Invalid page requested.  If DEBUG were set to ' +
                 'False, an HTTP 404 page would have been shown instead.')
         context[key] = []
         context['invalid_page'] = True
         return u''
     if self.context_var is not None:
         context[self.context_var] = page_obj.object_list
     else:
         context[key] = page_obj.object_list
     context['paginator'] = paginator
     context['page_obj'] = page_obj
     return u''
Пример #36
0
def language_pages(request, language, batch, title=None, page_number=1):
    language_name = models.Language.objects.get(code=language).name
    page_title = 'Pages with %s text' % (language_name)
    path = 'reports/language_title_pages.html'
    if language != 'eng':
        if title:
            pages = models.Page.objects.filter(
                ocr__language_texts__language__code=language,
                issue__title__lccn=title
            ).values(
                'reel__number', 'issue__date_issued', 'issue__title__lccn',
                'issue__edition', 'sequence',
            ).order_by(
                'reel__number', 'issue__date_issued',
                'sequence'
            )
        else:
            pages = models.Page.objects.filter(
                ocr__language_texts__language__code=language,
                issue__batch__name=batch
            ).values(
                'reel__number', 'issue__date_issued', 'issue__title__lccn',
                'issue__edition', 'sequence',
            ).order_by(
                'reel__number', 'issue__title__lccn',
                'issue__date_issued', 'sequence'
            )
            path = 'reports/language_batch_pages.html'
        paginator = Paginator(pages, 25)
        try:
            page = paginator.page(page_number)
        except InvalidPage:
            page = paginator.page(1)
        page_range_short = list(_page_range_short(paginator, page))
    return render_to_response(path, dictionary=locals(),
                              context_instance=RequestContext(request))
Пример #37
0
def bidding(request, id=None, pg=1):
	if id:
		a = bidvar.objects.all();
		bid = bidvar.objects.filter(id = id).first()
		if request.method == 'POST':
			form = BidForm(request.POST, instance=bid)
			for b in a:
				if b.buyer == request.user:
					messages.add_message(request, messages.INFO, 'You can\'t have highest bid on two Companies')
					return redirect('bidding', pg=pg)						
			if bid.bidding_price < int(form['bidding_price'].value()):
				if request.user.eCoins > int(form['bidding_price'].value()):
					if int(form['bidding_price'].value())%100 == 0 and form.is_valid():
						bid.buyer = request.user
						form.save()	
						messages.add_message(request, messages.INFO, f'Your Bid has been placed sucessfully on {bid.company.company_name}' )
					else:
						messages.add_message(request, messages.INFO, 'You need to place bid in multiple of 100\'s only.'  )				

				else:
					messages.add_message(request, messages.INFO, 'You don\'t have enough E-Coins to place this bid.' )				
			else:
				messages.add_message(request, messages.INFO, 'Enter a Bid Price higher than the current Highest Bid Price')
			return redirect('bidding', pg=pg)
	
	form = BidForm()
	bid_list = bidvar.objects.filter(visible=True).order_by('-id')
	paginator = Paginator(bid_list, 13)
	context = {
		'form' : form,
		'Bid' : paginator.page(pg),
		'page' : pg,
		'paginator' : paginator,
		'Companys': Company.objects.order_by('-id')	
	}
	return render(request, 'home/letsbid.html', context)
Пример #38
0
def profile(request, username):
    try:
        user_profile = User.objects.get(username=username)
        user_following = user_profile.following.count()
        user_followers = user_profile.followers.count()
        if user_profile.followers.filter(username=request.user).exists():
            bool_follow = "Unfollow"
        else:
            bool_follow = "Follow"
        post_list = Post.objects.filter(author=username).order_by('-timestamp')
        paginator = Paginator(post_list, 5)

        page_number = request.GET.get('page')
        page = paginator.get_page(page_number)

        return render(request, "network/profile.html", {
            "username": username,
            "page": page,
            "user_followers": user_followers,
            "user_following": user_following,
            "bool_follow": bool_follow
        })
    except User.DoesNotExist:
        return render(request, "network/error.html", {"error": "This user does not yet exist"})
Пример #39
0
def profile(request, username):
    page_user = get_object_or_404(User, username=username)
    all_feeds = Feed.get_feeds().filter(user=page_user)
    paginator = Paginator(all_feeds, FEEDS_NUM_PATES)
    feeds = paginator.page(1)
    user = request.user

    from_feed = -1

    if feeds:
        from_feed = feeds[0].id

    if Follow.objects.filter(follower=user, followed=page_user).first():
        is_follow = True
    else:
        is_follow = False
    context = {
        'page_user': page_user,
        'feeds': feeds,
        'from_feed': from_feed,
        'page': 1,
        'is_follow': is_follow
    }
    return render(request, 'core/profile.html', context)
Пример #40
0
def index(request, now_page=1):
    # import pdb; pdb.set_trace()
    if 'record_number' in request.session:
        record_number = request.session['record_number']
    else:
        record_number = 10

    if 'new_old' in request.session:
        new_old = request.session['new_old']
    else:
        new_old = 1

    record_number_form = RecordNumberForm()
    record_number_form.initial = {'record_number': str(record_number)}

    new_old_form = NewOldForm()
    new_old_form.initial = {'new_old': str(new_old)}

    if new_old == "1":
        memos = Memo.objects.all().order_by("update_datetime").reverse()
    else:
        memos = Memo.objects.all()
    # page=Paginator(memos,15)
    page = Paginator(memos, record_number)
    # print(page.page_range)
    # print(dir(page))

    params = {
        #     # "memos":memos,
        "page": page.get_page(now_page),
        "form": PostForm(),
        'record_number_form': record_number_form,
        'new_old_form': new_old_form
    }

    return render(request, "index.html", params)
Пример #41
0
def list(request, tag_slug=None):
    object_list = Post.objects.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, 2)  # Show 25 contacts per page

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

    return render(request, 'list.html', {
        'page': page,
        'posts': posts,
        'tag': tag
    })
Пример #42
0
def song_list(request):
    page = request.GET.get('page', 1)
    # get list of all songs
    #db = MySQLdb.connect(**dbconfig)
    cnx = pymysql.connect(**dbconfig,cursorclass=pymysql.cursors.DictCursor)
    cursor = cnx.cursor()
#    cursor.execute("SELECT * FROM song LIMIT 100")
    sql_command = """
    select song.*, files.APIC
    from song
    inner join files
    on song.file_id = files.file_id
    """
    cursor.execute(sql_command)
    results = cursor.fetchall()
#    results[1]['APIC'] = b64encode(results[1]['APIC'])
    paginator = Paginator(results, 50)
    try:
        results = paginator.page(page)
    except PageNotAnInteger:
        results = paginator.page(1)
    except EmptyPage:
        results = paginator.page(paginator.num_pages)
    return render(request, 'song_list.html', {'results': results})
Пример #43
0
def _get_paginated_entities(locale, project, form, entities):
    """Return a paginated list of entities.

    This is used by the regular mode of the Translate page.
    """
    paginator = Paginator(entities, form.cleaned_data['limit'])

    try:
        entities_page = paginator.page(1)
    except EmptyPage:
        return JsonResponse({
            'has_next': False,
            'stats': {},
        })

    has_next = entities_page.has_next()
    entities_to_map = entities_page.object_list

    # If requested entity not on the first page
    if form.cleaned_data['entity']:
        entity_pk = form.cleaned_data['entity']
        entities_to_map_pks = [e.pk for e in entities_to_map]

        # TODO: entities_to_map.values_list() doesn't return entities from selected page
        if entity_pk not in entities_to_map_pks:
            if entity_pk in entities.values_list('pk', flat=True):
                entities_to_map_pks.append(entity_pk)
                entities_to_map = entities.filter(pk__in=entities_to_map_pks)

    return JsonResponse({
        'entities': Entity.map_entities(locale, entities_to_map, []),
        'has_next': has_next,
        'stats': TranslatedResource.objects.stats(
            project, form.cleaned_data['paths'], locale
        ),
    }, safe=False)
Пример #44
0
def project_list(request):
    if request.is_ajax():
        type_dict = json.loads(request.body.decode('utf-8'))
        if type_dict['mode'] == 'del':
            models.ProjectInfo.objects.filter(id=type_dict['id']).delete()
            return HttpResponse("OK")

    projectlists = models.ProjectInfo.objects.all().values(
        'id', 'project_name', 'responsible_name', 'test_user', 'dev_user',
        'publish_app', 'simple_desc', 'other_desc', 'create_time')
    paginator = Paginator(projectlists, 10)  # Show 10 contacts per page

    # 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:
        projectlist = paginator.page(page)
    except (EmptyPage, InvalidPage):
        projectlist = paginator.page(paginator.num_pages)
    return render(request, 'projectlist.html', {'projectlist': projectlist})
Пример #45
0
def admintable(request):
	if request.method == 'POST':
		mes = request.POST.get('mes')
		ano = request.POST.get('ano')
		print "entro al form"
		gasto1 = Gasto.objects.filter(fecha__year=int(ano)).filter(fecha__month=int(mes)).values_list('id', flat=True)
		gasto2 = Detalleg.objects.filter(gasto__in=gasto1)[:100]
		return render(request, 'adming.html',{'gasto':gasto2, 'posts':gasto2.all()})

	elif request.method == 'GET':
		mes = request.GET.get('mes')
		ano = request.GET.get('ano')
		

		if mes == None:
			today = datetime.date.today()
			print today
			gasto1 = Gasto.objects.filter().values_list('id', flat=True)
			pagastos = Detalleg.objects.filter(gasto__in=gasto1).order_by('-fecha')

			paginator = Paginator(pagastos, 50) # Show 25 contacts per page

			page = request.GET.get('page')
			try:
				posts = paginator.page(page)
			except PageNotAnInteger:
				# If page is not an integer, deliver first page.
				posts = paginator.page(1)
			except EmptyPage:
				# If page is out of range (e.g. 9999), deliver last page of results.
				posts = paginator.page(paginator.num_pages)
			print gasto1
			gasto2 = Detalleg.objects.filter(gasto__in=gasto1)
			return render(request, 'adming.html',{'gasto':gasto2, 'posts':posts,'gastos':gasto2.all()})
		else:
			return export_excelfecha(request, mes, ano)
Пример #46
0
    def get_context_data(self, *args, **kwargs):
        context = super(SearchView, self).get_context_data(*args, **kwargs)
        if 'query' in self.request.GET:
            self.form = SearchForm(self.request.GET)
            if self.form.is_valid():
                self.query = self.form.cleaned_data['query']
                context['results_count'] = self.model.objects.select_related(
                    'category').filter(
                        Q(title__icontains=self.query)
                        | Q(content__icontains=self.query))

                results = self.model.objects.select_related('category').filter(
                    Q(title__icontains=self.query)
                    | Q(content__icontains=self.query))
                page = self.request.GET.get('page', 1)
                paginator = Paginator(results, 6)
                try:
                    context['results'] = paginator.page(page)
                except PageNotAnInteger:
                    context['results'] = paginator.page(1)
                except EmptyPage:
                    context['results'] = paginator.page(paginator.num_pages)
                context['query'] = self.query
        return context
Пример #47
0
def post_list(request):
    categories = Category.objects.all()
    category_count = get_category_count()
    most_recent = Post.objects.order_by('-timestamp')[:8]
    post_list = Post.objects.order_by('-timestamp')
    paginator = Paginator(post_list, 8)
    page_request_var = 'page'
    page = request.GET.get(page_request_var)
    try:
        paginated_queryset = paginator.page(page)
    except PageNotAnInteger:
        paginated_queryset = paginator.page(1)
    except EmptyPage:
        paginated_queryset = paginator.page(paginator.num_pages)

    context = {
        'queryset': paginated_queryset,
        'most_recent': most_recent,
        'page_request_var': page_request_var,
        'categories': categories,
        'category_count': category_count,
        # 'form': form
    }
    return render(request, 'blog.html', context)
Пример #48
0
def index(request, num=1):
    try:
        if request.method == 'POST' and request.FILES['crt'] and request.FILES['incrt'] and request.FILES['key']:
            certificates = {
                'crt': request.FILES['crt'].read().decode().rstrip(),
                'incrt': request.FILES['incrt'].read().decode().rstrip(),
                'key': request.FILES['key'].read().decode().rstrip(),
            }
            test_result = certificates_test(request, certificates)
            if test_result:
                key = certificates['key']
                crt = certificates['crt'] + '\n' + certificates['incrt']
                upload_crts(crt, key)
                cn = get_cn(certificates)
                create_nginx_config(cn)
                restart_nginx_container()
            else:
                cn = "-"
            is_test_result = TestResult.objects.create(
                common_name=cn,
                filename_crt=request.FILES['crt'].name,
                filename_incrt=request.FILES['incrt'].name,
                filename_key=request.FILES['key'].name,
                is_test_result=test_result
            )
            is_test_result.save()
            return HttpResponseRedirect('/')
    except MultiValueDictKeyError:
        return HttpResponseRedirect('/')

    event_log = TestResult.objects.all().order_by('-tested_at')
    page = Paginator(event_log, 10)
    params = {
        'event_log': page.get_page(num)
    }
    return render(request, 'frontend/index.html', params)
Пример #49
0
    def list(self, request, *args, **kwargs):
        if "api" in request.META['PATH_INFO']:
            return super(SetVersionViewSet, self).list(request, *args, **kwargs)
        else:
            versions = self.filter_queryset(self.get_queryset()).order_by('imagesets')

            current_query = request.META['QUERY_STRING']
            if "page" not in request.query_params:
                current_query += "&page=1"
                page_id = 1
            else:
                page_id = int(request.query_params.get('page', 1))
            
            limit = int(request.query_params.get('limit', api_settings.PAGE_SIZE))
           
            paginator = Paginator(versions, limit)
            page = paginator.get_page(page_id)

            previous_query = first_query = current_query.replace("&page="+str(page_id), "&page=1")
            if page.has_previous():
                previous_query = current_query.replace("&page="+str(page_id), "&page={}".format(page.previous_page_number()))
            
            next_query = last_query = current_query.replace("&page="+str(page_id), "&page={}".format(paginator.num_pages))
            if page.has_next():
                next_query = current_query.replace("&page="+str(page_id), "&page={}".format(page.next_page_number()))

            return TemplateResponse(request, 'base/explore.html', {
                'mode': 'versions',
                'versions': page,  # to separate what kind of stuff is displayed in the view
                'paginator': page,  # for page stuff
                'first_query': first_query,
                'previous_query': previous_query,
                'next_query': next_query,
                'last_query': last_query,
                #'filter': self.filterset_class
            })
Пример #50
0
def get_network_query_info(request):
    data = dict()
    page_size = request.GET.get("page_size")
    current_page = request.GET.get("current_page")

    search_network = request.GET.get("search_network")

    if search_network:
        all_networks = NetworkQueryList.objects.filter(
            network__contains=search_network)
    else:
        all_networks = NetworkQueryList.objects.all()

    result = []
    paginator = Paginator(all_networks, page_size)
    total_networks = all_networks.count()
    network_page = paginator.page(current_page)
    for network in network_page:
        network_info = dict()
        network_info['key'] = network.id
        network_info['network'] = network.network
        network_info['tcp_query_ports'] = network.tcp_query_ports
        network_info['udp_query_ports'] = network.udp_query_ports
        network_info['query_status'] = network.get_query_status_display()
        network_info['online_ip_num'] = network.online_ip_num
        network_info['auto_enable'] = network.auto_enable
        network_info['crontab_task'] = network.crontab_task
        network_info['query_time'] = (
            network.query_time +
            datetime.timedelta(hours=8)).strftime("%Y-%m-%d %H:%M:%S")

        result.append(network_info)
    data['data'] = result
    data['total_network'] = total_networks
    data["status"] = "success"
    return json_response(data)
Пример #51
0
def home(request):
    fin_rj_list = Rj.objects.all()
    Rjsomme = Rj.objects.aggregate(Sum('p_acide_h2so4'))
    Rjsomme_s = Rj.objects.aggregate(Sum('s_c'))
    Rjsomme_s_c = Rj.objects.aggregate(Sum('r_s_solid'))



    Rj_filter = RjFilter(request.GET, queryset=fin_rj_list)




    page = request.GET.get('page', 1)

    paginator = Paginator(fin_rj_list, 5)
    try:
        fin_rj_list1 = paginator.page(page)
    except PageNotAnInteger:
        fin_rj_list1 = paginator.page(1)
    except EmptyPage:
        fin_rj_list1 = paginator.page(paginator.num_pages)

    return render(request, 'tifert/home.html', {'Rjsomme_s': Rjsomme_s,'Rjsomme_s_c': Rjsomme_s_c,'Rjsomme': Rjsomme,'fin_rj_list': fin_rj_list,'filter': Rj_filter,'fin_rj_list1': fin_rj_list1})
Пример #52
0
def classify(request, classify_id, page_id):
    classify = Classification.objects.all()
    classify1 = classify_id
    books = BookName.objects.filter(cfname=classify1)
    # 分页显示该类图书
    paginator = Paginator(books, 10)
    page = paginator.page(page_id)
    classify_name = Classification.objects.get(id=classify_id)
    # 创建翻页链接
    pagenum = int(page_id)
    page_next = pagenum + 1
    page_last = pagenum - 1
    if page_last == 0:
        page_last = 1
    if page_next > paginator.num_pages:
        page_next = paginator.num_pages
    return render(
        request, 'classify.html', {
            'books': page,
            'classify_name': classify_name,
            'classify': classify,
            'page_next': page_next,
            'page_last': page_last
        })
Пример #53
0
def display_articles(request):
    """
	display list of articles in  article list page.
	"""
    articlelist = Articles.objects.raw(
        'select o.id,title,username,views,o.created_at,g.name GNAME,c.name CNAME from (select id,title,username,views,created_at,GID,CID COMMID from ( select ba.id,ba.title , username,views,created_at ,(select group_id from Group_grouparticles where article_id=ba.id) GID , (select community_id from Community_communityarticles where article_id=ba.id) CID from (select * from BasicArticle_articles  where id in (select article_id from Group_grouparticles) or id in (select article_id from Community_communityarticles)) ba join auth_user au on ba.created_by_id=au.id join workflow_states ws on ws.id=ba.state_id where ws.name="publish") t ) o  left join Community_community c on c.id=COMMID left join Group_group g on g.id=GID order by views desc;'
    )
    page = request.GET.get('page', 1)
    paginator = Paginator(list(articlelist), 5)
    try:
        articles = paginator.page(page)
    except PageNotAnInteger:
        articles = paginator.page(1)
    except EmptyPage:
        articles = paginator.page(paginator.num_pages)
    fav_articles = ''
    if request.user.is_authenticated:
        fav_articles = favourite.objects.raw(
            'select  ba.id as id , title from BasicArticle_articles as ba ,UserRolesPermission_favourite as uf where ba.id=resource and user_id =%s;',
            [request.user.id])
    return render(request, 'articles.html', {
        'articles': articles,
        'favs': fav_articles
    })
Пример #54
0
def consulta_ordem_detalhe(request, **kwargs):

    if Ordem.objects.filter(id=kwargs.get('ordem')).exists():
        menu = menu_consultas(request)
        ordem = Ordem.objects.get(id=kwargs.get('ordem'))

        if kwargs.get('tipo'):
            itens = MaterialSaida.objects.filter(ordem=ordem).order_by(
                'material__material', 'material__codigo')

        else:
            itens = MaterialEntrada.objects.filter(ordem=ordem).order_by(
                'material__material', 'material__codigo')

        itens = itens.values(
            'material__codigo',
            'material__material',
            'quantidade',
        )
        paginator = Paginator(itens, 50)

        page_number = request.GET.get('page')
        page_obj = paginator.get_page(page_number)
        context = {
            'page_obj': page_obj,
            'ordem': ordem,
            'tipo': kwargs.get('tipo'),
        }
        context.update(menu)

        return render(request, 'almoxarifado/v2/consulta_ordem_detalhe.html',
                      context)

    else:

        return HttpResponseRedirect('/almoxarifado/consultas/')
Пример #55
0
def bus_stations(request):
    with open(settings.BUS_STATION_CSV, mode='r', encoding='cp1251') as file_data:
        contents = csv.DictReader(file_data)
        stops_list = list(contents)
        if request.GET.get('page'):
            page_number = int(request.GET.get('page'))
        else:
            page_number = 1
        p = Paginator(stops_list, 10)
        if page_number in range(1, p.num_pages):
            stops_page = p.page(page_number)
        else:
            stops_page = p.page(p.num_pages)
        current_page = stops_page.number
        prev_page_url = f'?page={stops_page.previous_page_number()}' \
            if stops_page.has_previous() else None
        next_page_url = f'?page={stops_page.next_page_number()}' \
            if stops_page.has_next() else None
        return render_to_response('index.html', context={
            'bus_stations': stops_page,
            'current_page': current_page,
            'prev_page_url': prev_page_url,
            'next_page_url': next_page_url,
        })
Пример #56
0
def select_paper_all(args):
    """Get All Papers"""

    page_number = 1 if constants.PAGE_NUMBER not in args else int(args[constants.PAGE_NUMBER])

    # list of tuple (id, abtract, DOI)
    paper_queryset = Paper.objects.all().values_list('id', 'abstract', 'DOI')

    papers = Paginator(paper_queryset, ALL_PAPER_PAGE_COUNT).get_page(page_number)

    is_finished = not papers.has_next()

    results = [] # list of dictionaries whose keys are ItemId, Abstract, and Keywords

    for paper in papers:
        result = {}
        paper_id, abstract, doi = paper
        keywords = paper_utils.get_keywords_paper(Q(paper_id=paper_id))
        result['Keywords'] = keywords[paper_id] if paper_id in keywords else []
        result['ItemId'] = paper_id

        if abstract:
            result['Abstract'] = abstract
        # If abstract doesn't exist, try getting abstract this time.
        #   We can use 'alternative-id' of Crossref for getting results from Semantic Scholar,
        #   but it is currently not saved in our DB. So use only DOI for now.
        else:
            if doi:
                __exploit_semanticscholar_for_abstract(paper_id, [doi]) # NOTE: This doesn't use shared_task of celery
                result['Abstract'] = Paper.objects.get(id=paper_id).abstract
            else:
                result['Abstract'] = abstract # save empty abstract

        results.append(result)

    return results, page_number, is_finished
Пример #57
0
    def test_page_getitem(self):
        """
        Tests proper behavior of a paginator page __getitem__ (queryset
        evaluation, slicing, exception raised).
        """
        paginator = Paginator(Article.objects.order_by('id'), 5)
        p = paginator.page(1)

        # Make sure object_list queryset is not evaluated by an invalid __getitem__ call.
        # (this happens from the template engine when using eg: {% page_obj.has_previous %})
        self.assertIsNone(p.object_list._result_cache)
        with self.assertRaises(TypeError):
            p['has_previous']
        self.assertIsNone(p.object_list._result_cache)
        self.assertNotIsInstance(p.object_list, list)

        # Make sure slicing the Page object with numbers and slice objects work.
        self.assertEqual(p[0], Article.objects.get(headline='Article 1'))
        self.assertQuerysetEqual(p[slice(2)], [
            "<Article: Article 1>",
            "<Article: Article 2>",
        ])
        # After __getitem__ is called, object_list is a list
        self.assertIsInstance(p.object_list, list)
Пример #58
0
def transactions(request):
    dvds = DVD.objects.all()  #imports dvds from database
    trans = Transaction.objects.all()  #imports dvds from database
    users = User.objects.all()  #imports dvds from database
    customer = Customer.objects.all()  #imports dvds from database

    query = request.GET.get("query")
    if query:
        trans = Transaction.objects.filter(
            Q(TransactionNumber__icontains=query)
        )  #Search Function according to name

    paginator = Paginator(dvds, 6)  # Show 3 dvds per page
    page = request.GET.get('page')
    dvds = paginator.get_page(page)
    form = DocumentForm()
    context_dict = {
        'dvds': dvds,
        'form': form,
        'trans': trans,
        'users': users,
        'customer': customer
    }
    return render(request, 'transactions.html', context_dict)
Пример #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))
Пример #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))