Exemple #1
0
def find_post(request, user_pk):
    '''Finds all posts of a user'''
    u = get_object_or_404(User, pk=user_pk)
    posts = Post.objects\
                .filter(author=u)\
                .order_by('-pubdate')\
                .all()

    # Paginator
    paginator = Paginator(posts, settings.POSTS_PER_PAGE)
    page = request.GET.get('page')

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

    return render_template(
        'forum/find_post.html', {
            'posts': shown_posts,
            'usr': u,
            'pages': paginator_range(page, paginator.num_pages),
            'nb': page
        })
Exemple #2
0
def find_topic(request, user_pk):
    """Finds all topics of a user."""

    displayed_user = get_object_or_404(User, pk=user_pk)
    topics = \
        Topic.objects\
        .filter(author=displayed_user)\
        .exclude(Q(forum__group__isnull=False) & ~Q(forum__group__in=request.user.groups.all()))\
        .prefetch_related("author")\
        .order_by("-pubdate").all()

    # Paginator
    paginator = Paginator(topics, settings.TOPICS_PER_PAGE)
    page = request.GET.get("page")
    try:
        shown_topics = paginator.page(page)
        page = int(page)
    except PageNotAnInteger:
        shown_topics = paginator.page(1)
        page = 1
    except EmptyPage:
        shown_topics = paginator.page(paginator.num_pages)
        page = paginator.num_pages

    return render_template("forum/find/topic.html", {
        "topics": shown_topics,
        "usr": displayed_user,
        "pages": paginator_range(page, paginator.num_pages),
        "nb": page,
    })
Exemple #3
0
def find_topic(request, user_pk):
    """Finds all topics of a user."""

    u = get_object_or_404(User, pk=user_pk)
    topics = \
        Topic.objects\
        .filter(author=u)\
        .exclude(Q(forum__group__isnull=False) & ~Q(forum__group__in=u.groups.all()))\
        .prefetch_related("author")\
        .order_by("-pubdate").all()

    # Paginator

    paginator = Paginator(topics, settings.TOPICS_PER_PAGE)
    page = request.GET.get("page")
    try:
        shown_topics = paginator.page(page)
        page = int(page)
    except PageNotAnInteger:
        shown_topics = paginator.page(1)
        page = 1
    except EmptyPage:
        shown_topics = paginator.page(paginator.num_pages)
        page = paginator.num_pages

    return render_template("forum/find/topic.html", {
        "topics": shown_topics,
        "usr": u,
        "pages": paginator_range(page, paginator.num_pages),
        "nb": page,
    })
Exemple #4
0
def followed_topics(request):
    """
    Displays the followed topics for the current user, with `settings.ZDS_APP['forum']['followed_topics_per_page']`
    topics per page.
    """
    topics_followed = TopicAnswerSubscription.objects.get_objects_followed_by(
        request.user)

    # Paginator

    paginator = Paginator(
        topics_followed, settings.ZDS_APP['forum']['followed_topics_per_page'])
    page = request.GET.get("page")
    try:
        shown_topics = paginator.page(page)
        page = int(page)
    except PageNotAnInteger:
        shown_topics = paginator.page(1)
        page = 1
    except EmptyPage:
        shown_topics = paginator.page(paginator.num_pages)
        page = paginator.num_pages
    topic_read = TopicRead.objects.list_read_topic_pk(request.user,
                                                      shown_topics)
    return render(
        request, "forum/topic/followed.html", {
            "followed_topics": shown_topics,
            "topic_read": topic_read,
            "pages": paginator_range(page, paginator.num_pages),
            "nb": page
        })
Exemple #5
0
def topic(request, topic_pk, topic_slug):
    """Display a thread and its posts using a pager."""

    # TODO: Clean that up
    g_topic = get_object_or_404(PrivateTopic, pk=topic_pk)

    if not g_topic.author == request.user \
            and request.user not in list(g_topic.participants.all()):
        raise PermissionDenied

    # Check link
    if not topic_slug == slugify(g_topic.title):
        return redirect(g_topic.get_absolute_url())

    if request.user.is_authenticated():
        if never_privateread(g_topic):
            mark_read(g_topic)

    posts = PrivatePost.objects.filter(privatetopic__pk=g_topic.pk)\
        .order_by('position_in_topic')\
        .all()

    last_post_pk = g_topic.last_message.pk

    # Handle pagination
    paginator = Paginator(posts, settings.POSTS_PER_PAGE)

    try:
        page_nbr = int(request.GET['page'])
    except KeyError:
        page_nbr = 1

    try:
        posts = paginator.page(page_nbr)
    except PageNotAnInteger:
        posts = paginator.page(1)
    except EmptyPage:
        raise Http404

    res = []
    if page_nbr != 1:
        # Show the last post of the previous page
        last_page = paginator.page(page_nbr - 1).object_list
        last_post = (last_page)[len(last_page) - 1]
        res.append(last_post)

    for post in posts:
        res.append(post)

    # Build form to add an answer for the current topid.
    form = PrivatePostForm(g_topic, request.user)

    return render_template('mp/topic/index.html', {
        'topic': g_topic,
        'posts': res,
        'pages': paginator_range(page_nbr, paginator.num_pages),
        'nb': page_nbr,
        'last_post_pk': last_post_pk,
        'form': form
    })
Exemple #6
0
    def form_valid(self, form):
        self.queryset = form.search()
        context = self.get_context_data(**{
            self.form_name: form,
            'query': form.cleaned_data.get(self.search_field),
            'object_list': self.queryset,
            'models': self.request.GET.getlist('models', ''),
        })

        # Retrieve page number
        if "page" in self.request.GET and self.request.GET["page"].isdigit():
            page_number = int(self.request.GET["page"])
        elif "page" not in self.request.GET:
            page_number = 1
        else:
            raise Http404

        # Create pagination
        paginator = self.get_paginator(self.queryset, self.paginate_by, 0, False)

        if paginator.num_pages == 0:
            num_pages = 1
        else:
            num_pages = paginator.num_pages

        context['nb'] = page_number
        context['pages'] = paginator_range(page_number, num_pages)

        return self.render_to_response(context)
Exemple #7
0
def find_topic_by_tag(request, tag_pk, tag_slug):
    """Finds all topics byg tag."""

    tag = Tag.objects.filter(pk=tag_pk, slug=tag_slug).first()
    if tag is None:
        return redirect(reverse("zds.forum.views.index"))
    u = request.user
    if "filter" in request.GET:
        filter = request.GET["filter"]
        if request.GET["filter"] == "solve":
            topics = Topic.objects.filter(
                tags__in=[tag],
                is_sticky=False,
                is_solved=True).order_by("-last_message__pubdate").prefetch_related(
                "author",
                "last_message",
                "tags")\
                .exclude(Q(forum__group__isnull=False) & ~Q(forum__group__in=u.groups.all()))\
                .all()
        else:
            topics = Topic.objects.filter(
                tags__in=[tag],
                is_sticky=False,
                is_solved=False).order_by("-last_message__pubdate").prefetch_related(
                "author",
                "last_message",
                "tags")\
                .exclude(Q(forum__group__isnull=False) & ~Q(forum__group__in=u.groups.all()))\
                .all()
    else:
        filter = None
        topics = Topic.objects.filter(tags__in=[tag], is_sticky=False) .order_by(
            "-last_message__pubdate")\
            .exclude(Q(forum__group__isnull=False) & ~Q(forum__group__in=u.groups.all()))\
            .prefetch_related("author", "last_message", "tags").all()
    # Paginator

    paginator = Paginator(topics, settings.TOPICS_PER_PAGE)
    page = request.GET.get("page")
    try:
        shown_topics = paginator.page(page)
        page = int(page)
    except PageNotAnInteger:
        shown_topics = paginator.page(1)
        page = 1
    except EmptyPage:
        shown_topics = paginator.page(paginator.num_pages)
        page = paginator.num_pages
    return render_template("forum/find/topic_by_tag.html", {
        "topics": shown_topics,
        "tag": tag,
        "pages": paginator_range(page, paginator.num_pages),
        "nb": page,
        "filter": filter,
    })
Exemple #8
0
def find_topic_by_tag(request, tag_pk, tag_slug):
    """Finds all topics byg tag."""

    tag = Tag.objects.filter(pk=tag_pk, slug=tag_slug).first()
    if tag is None:
        return redirect(reverse("zds.forum.views.index"))
    u = request.user
    if "filter" in request.GET:
        filter = request.GET["filter"]
        if request.GET["filter"] == "solve":
            topics = Topic.objects.filter(
                tags__in=[tag],
                is_solved=True).order_by("-last_message__pubdate").prefetch_related(
                    "author",
                    "last_message",
                    "tags")\
                .exclude(Q(forum__group__isnull=False) & ~Q(forum__group__in=u.groups.all()))\
                .all()
        else:
            topics = Topic.objects.filter(
                tags__in=[tag],
                is_solved=False).order_by("-last_message__pubdate")\
                .prefetch_related(
                    "author",
                    "last_message",
                    "tags")\
                .exclude(Q(forum__group__isnull=False) & ~Q(forum__group__in=u.groups.all()))\
                .all()
    else:
        filter = None
        topics = Topic.objects.filter(tags__in=[tag]).order_by("-last_message__pubdate")\
            .exclude(Q(forum__group__isnull=False) & ~Q(forum__group__in=u.groups.all()))\
            .prefetch_related("author", "last_message", "tags").all()
    # Paginator

    paginator = Paginator(topics, settings.ZDS_APP['forum']['topics_per_page'])
    page = request.GET.get("page")
    try:
        shown_topics = paginator.page(page)
        page = int(page)
    except PageNotAnInteger:
        shown_topics = paginator.page(1)
        page = 1
    except EmptyPage:
        shown_topics = paginator.page(paginator.num_pages)
        page = paginator.num_pages
    return render_template(
        "forum/find/topic_by_tag.html", {
            "topics": shown_topics,
            "tag": tag,
            "pages": paginator_range(page, paginator.num_pages),
            "nb": page,
            "filter": filter,
        })
Exemple #9
0
def details(request, cat_slug, forum_slug):
    """Display the given forum and all its topics."""

    forum = get_object_or_404(Forum, slug=forum_slug)
    if not forum.can_read(request.user):
        raise PermissionDenied
    sticky_topics = Topic.objects.filter(forum__pk=forum.pk, is_sticky=True).order_by(
        "-last_message__pubdate").prefetch_related("author", "last_message", "tags").all()
    if "filter" in request.GET:
        filter = request.GET["filter"]
        if request.GET["filter"] == "solve":
            topics = Topic.objects.filter(
                forum__pk=forum.pk,
                is_sticky=False,
                is_solved=True).order_by("-last_message__pubdate").prefetch_related(
                "author",
                "last_message",
                "tags").all()
        else:
            topics = Topic.objects.filter(
                forum__pk=forum.pk,
                is_sticky=False,
                is_solved=False).order_by("-last_message__pubdate").prefetch_related(
                "author",
                "last_message",
                "tags").all()
    else:
        filter = None
        topics = Topic.objects.filter(forum__pk=forum.pk, is_sticky=False) .order_by(
            "-last_message__pubdate").prefetch_related("author", "last_message", "tags").all()

    # Paginator

    paginator = Paginator(topics, settings.TOPICS_PER_PAGE)
    page = request.GET.get("page")
    try:
        shown_topics = paginator.page(page)
        page = int(page)
    except PageNotAnInteger:
        shown_topics = paginator.page(1)
        page = 1
    except EmptyPage:
        shown_topics = paginator.page(paginator.num_pages)
        page = paginator.num_pages

    return render_template("forum/category/forum.html", {
        "forum": forum,
        "sticky_topics": sticky_topics,
        "topics": shown_topics,
        "pages": paginator_range(page, paginator.num_pages),
        "nb": page,
        "filter": filter,
    })
Exemple #10
0
def index(request):
    """Display the all private topics."""

    # delete actions
    if request.method == 'POST':
        if 'delete' in request.POST:
            liste = request.POST.getlist('items')
            topics = PrivateTopic.objects.filter(pk__in=liste)\
                .filter(
                    Q(participants__in=[request.user])
                    | Q(author=request.user))

            for topic in topics:
                if topic.participants.all().count() == 0:
                    topic.delete()
                elif request.user == topic.author:
                    topic.author = topic.participants.all()[0]
                    topic.participants.remove(topic.participants.all()[0])
                    topic.save()
                else:
                    topic.participants.remove(request.user)
                    topic.save()

    privatetopics = PrivateTopic.objects\
        .filter(Q(participants__in=[request.user]) | Q(author=request.user))\
        .select_related("author", "participants")\
        .distinct().order_by('-last_message__pubdate').all()

    # Paginator
    paginator = Paginator(privatetopics,
                          settings.ZDS_APP['forum']['topics_per_page'])
    page = request.GET.get('page')

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

    return render_template(
        'mp/index.html', {
            'privatetopics': shown_privatetopics,
            'pages': paginator_range(page, paginator.num_pages),
            'nb': page
        })
Exemple #11
0
def index(request):
    """Displays the list of registered users."""

    if request.is_ajax():
        q = request.GET.get('q', '')
        if request.user.is_authenticated():
            members = User.objects.filter(username__icontains=q).exclude(
                pk=request.user.pk)[:20]
        else:
            members = User.objects.filter(username__icontains=q)[:20]
        results = []
        for member in members:
            member_json = {}
            member_json['id'] = member.pk
            member_json['label'] = member.username
            member_json['value'] = member.username
            results.append(member_json)
        data = json.dumps(results)

        mimetype = "application/json"

        return HttpResponse(data, mimetype)

    else:
        members = User.objects.order_by("-date_joined")
        # Paginator

        paginator = Paginator(members,
                              settings.ZDS_APP['member']['members_per_page'])
        page = request.GET.get("page")
        try:
            shown_members = paginator.page(page)
            page = int(page)
        except PageNotAnInteger:
            shown_members = paginator.page(1)
            page = 1
        except EmptyPage:
            shown_members = paginator.page(paginator.num_pages)
            page = paginator.num_pages
        return render_template(
            "member/index.html", {
                "members": shown_members,
                "count": members.count(),
                "pages": paginator_range(page, paginator.num_pages),
                "nb": page,
            })
Exemple #12
0
def index(request):
    """Display the all private topics."""

    # delete actions
    if request.method == "POST":
        if "delete" in request.POST:
            liste = request.POST.getlist("items")
            topics = PrivateTopic.objects.filter(pk__in=liste).all()
            for topic in topics:
                if topic.participants.all().count() == 0:
                    topic.delete()
                elif request.user == topic.author:
                    topic.author = topic.participants.all()[0]
                    topic.participants.remove(topic.participants.all()[0])
                    topic.save()
                else:
                    topic.participants.remove(request.user)
                    topic.save()

    privatetopics = (
        PrivateTopic.objects.filter(Q(participants__in=[request.user]) | Q(author=request.user))
        .select_related("author", "participants")
        .distinct()
        .order_by("-last_message__pubdate")
        .all()
    )

    # Paginator
    paginator = Paginator(privatetopics, settings.TOPICS_PER_PAGE)
    page = request.GET.get("page")

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

    return render_template(
        "mp/index.html",
        {"privatetopics": shown_privatetopics, "pages": paginator_range(page, paginator.num_pages), "nb": page},
    )
Exemple #13
0
def index(request):
    """Displays the list of registered users."""

    if request.is_ajax():
        q = request.GET.get('q', '')
        if request.user.is_authenticated() :
            members = User.objects.filter(username__icontains=q).exclude(pk=request.user.pk)[:20]
        else:
            members = User.objects.filter(username__icontains=q)[:20]
        results = []
        for member in members:
            member_json = {}
            member_json['id'] = member.pk
            member_json['label'] = member.username
            member_json['value'] = member.username
            results.append(member_json)
        data = json.dumps(results)
        
        mimetype = "application/json"
        
        return HttpResponse(data, mimetype)

    else:
        members = User.objects.order_by("-date_joined")
        # Paginator

        paginator = Paginator(members, settings.MEMBERS_PER_PAGE)
        page = request.GET.get("page")
        try:
            shown_members = paginator.page(page)
            page = int(page)
        except PageNotAnInteger:
            shown_members = paginator.page(1)
            page = 1
        except EmptyPage:
            shown_members = paginator.page(paginator.num_pages)
            page = paginator.num_pages
        return render_template("member/index.html", {
            "members": shown_members,
            "count": members.count(),
            "pages": paginator_range(page, paginator.num_pages),
            "nb": page,
        })
Exemple #14
0
def details(request, cat_slug, forum_slug):
    """Display the given forum and all its topics."""

    forum = get_object_or_404(Forum, slug=forum_slug)
    if not forum.can_read(request.user):
        raise PermissionDenied
    if "filter" in request.GET:
        filter = request.GET["filter"]
        if filter == "solve":
            sticky_topics = get_topics(forum_pk=forum.pk, is_sticky=True, is_solved=True)
            topics = get_topics(forum_pk=forum.pk, is_sticky=False, is_solved=True)
        else:
            sticky_topics = get_topics(forum_pk=forum.pk, is_sticky=True, is_solved=False)
            topics = get_topics(forum_pk=forum.pk, is_sticky=False, is_solved=False)
    else:
        filter = None
        sticky_topics = get_topics(forum_pk=forum.pk, is_sticky=True)
        topics = get_topics(forum_pk=forum.pk, is_sticky=False)

    # Paginator

    paginator = Paginator(topics, settings.TOPICS_PER_PAGE)
    page = request.GET.get("page")
    try:
        shown_topics = paginator.page(page)
        page = int(page)
    except PageNotAnInteger:
        shown_topics = paginator.page(1)
        page = 1
    except EmptyPage:
        shown_topics = paginator.page(paginator.num_pages)
        page = paginator.num_pages

    return render_template("forum/category/forum.html", {
        "forum": forum,
        "sticky_topics": sticky_topics,
        "topics": shown_topics,
        "pages": paginator_range(page, paginator.num_pages),
        "nb": page,
        "filter": filter,
    })
Exemple #15
0
def followed_topics(request):
    followed_topics = request.user.get_profile().get_followed_topics()

    # Paginator

    paginator = Paginator(followed_topics, settings.FOLLOWED_TOPICS_PER_PAGE)
    page = request.GET.get("page")
    try:
        shown_topics = paginator.page(page)
        page = int(page)
    except PageNotAnInteger:
        shown_topics = paginator.page(1)
        page = 1
    except EmptyPage:
        shown_topics = paginator.page(paginator.num_pages)
        page = paginator.num_pages
    return render_template("forum/topic/followed.html",
                           {"followed_topics": shown_topics,
                            "pages": paginator_range(page,
                                                     paginator.num_pages),
                            "nb": page})
Exemple #16
0
def followed_topics(request):
    followed_topics = request.user.get_profile().get_followed_topics()

    # Paginator

    paginator = Paginator(followed_topics, settings.FOLLOWED_TOPICS_PER_PAGE)
    page = request.GET.get("page")
    try:
        shown_topics = paginator.page(page)
        page = int(page)
    except PageNotAnInteger:
        shown_topics = paginator.page(1)
        page = 1
    except EmptyPage:
        shown_topics = paginator.page(paginator.num_pages)
        page = paginator.num_pages
    return render_template("forum/topic/followed.html",
                           {"followed_topics": shown_topics,
                            "pages": paginator_range(page,
                                                     paginator.num_pages),
                            "nb": page})
Exemple #17
0
    def create_response(self):
        (paginator, page) = self.build_page()

        page_nbr = int(self.request.GET.get('page', 1))

        context = {
            'query': self.query,
            'form': self.form,
            'page': page,
            'pages': paginator_range(page_nbr, paginator.num_pages),
            'nb': page_nbr,
            'paginator': paginator,
            'suggestion': None,
            'model_name': MODEL_NAMES
        }

        if self.results and hasattr(self.results, 'query') and self.results.query.backend.include_spelling:
            context['suggestion'] = self.form.get_suggestion()

        context.update(self.extra_context())
        return render_template(self.template, context)
Exemple #18
0
def details(request, cat_slug, forum_slug):
    '''
    Display the given forum and all its topics
    '''
    forum = get_object_or_404(Forum, slug=forum_slug)

    if not forum.can_read(request.user):
        raise Http404

    sticky_topics = Topic.objects\
        .filter(forum__pk=forum.pk, is_sticky=True)\
        .order_by('-last_message__pubdate')\
        .all()
    topics = Topic.objects\
        .filter(forum__pk=forum.pk, is_sticky=False)\
        .order_by('-last_message__pubdate')\
        .all()

    # Paginator
    paginator = Paginator(topics, settings.TOPICS_PER_PAGE)
    page = request.GET.get('page')

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

    return render_template(
        'forum/details.html', {
            'forum': forum,
            'sticky_topics': sticky_topics,
            'topics': shown_topics,
            'pages': paginator_range(page, paginator.num_pages),
            'nb': page
        })
Exemple #19
0
def index(request):
    '''
    Display the all private topics
    '''
    
    #delete actions
    if request.method == 'POST':
        if 'delete' in request.POST:
            liste = request.POST.getlist('items')
            topics=PrivateTopic.objects.filter(pk__in=liste).all()
            for topic in topics:
                if request.user == topic.author:
                    topic.author=topic.participants.all()[0]
                    topic.participants.remove(topic.participants.all()[0])
                else :
                    topic.participants.remove(request.user)
                topic.save()

    privatetopics = PrivateTopic.objects\
        .filter(Q(participants__in=[request.user])|Q(author=request.user))\
        .distinct().order_by('-last_message__pubdate').all()

    # Paginator
    paginator = Paginator(privatetopics, settings.TOPICS_PER_PAGE)
    page = request.GET.get('page')

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

    return render_template('mp/index.html', {
        'privatetopics': shown_privatetopics,
        'pages': paginator_range(page, paginator.num_pages), 'nb': page
    })
Exemple #20
0
def find_post(request, user_pk):
    """Finds all posts of a user."""

    u = get_object_or_404(User, pk=user_pk)
    
    if request.user.has_perm("forum.change_post"):
        posts = \
            Post.objects.filter(author=u)\
            .exclude(Q(topic__forum__group__isnull=False) & ~Q(topic__forum__group__in=u.groups.all()))\
            .prefetch_related("author")\
            .order_by("-pubdate").all()
    else:
        posts = \
            Post.objects.filter(author=u)\
            .filter(is_visible=True)\
            .exclude(Q(topic__forum__group__isnull=False) & ~Q(topic__forum__group__in=u.groups.all()))\
            .prefetch_related("author").order_by("-pubdate").all()


    # Paginator

    paginator = Paginator(posts, settings.POSTS_PER_PAGE)
    page = request.GET.get("page")
    try:
        shown_posts = paginator.page(page)
        page = int(page)
    except PageNotAnInteger:
        shown_posts = paginator.page(1)
        page = 1
    except EmptyPage:
        shown_posts = paginator.page(paginator.num_pages)
        page = paginator.num_pages

    return render_template("forum/find/post.html", {
        "posts": shown_posts,
        "usr": u,
        "pages": paginator_range(page, paginator.num_pages),
        "nb": page,
    })
Exemple #21
0
def find_post(request, user_pk):
    """Finds all posts of a user."""

    displayed_user = get_object_or_404(User, pk=user_pk)
    user = request.user

    if user.has_perm("forum.change_post"):
        posts = \
            Post.objects.filter(author=displayed_user)\
            .exclude(Q(topic__forum__group__isnull=False) & ~Q(topic__forum__group__in=user.groups.all()))\
            .prefetch_related("author")\
            .order_by("-pubdate").all()
    else:
        posts = \
            Post.objects.filter(author=displayed_user)\
            .filter(is_visible=True)\
            .exclude(Q(topic__forum__group__isnull=False) & ~Q(topic__forum__group__in=user.groups.all()))\
            .prefetch_related("author").order_by("-pubdate").all()

    # Paginator
    paginator = Paginator(posts, settings.ZDS_APP['forum']['posts_per_page'])
    page = request.GET.get("page")
    try:
        shown_posts = paginator.page(page)
        page = int(page)
    except PageNotAnInteger:
        shown_posts = paginator.page(1)
        page = 1
    except EmptyPage:
        shown_posts = paginator.page(paginator.num_pages)
        page = paginator.num_pages

    return render_template(
        "forum/find/post.html", {
            "posts": shown_posts,
            "usr": displayed_user,
            "pages": paginator_range(page, paginator.num_pages),
            "nb": page,
        })
Exemple #22
0
    def create_response(self):
        (paginator, page) = self.build_page()

        page_nbr = int(self.request.GET.get('page', 1))

        context = {
            'query': self.query,
            'form': self.form,
            'page': page,
            'pages': paginator_range(page_nbr, paginator.num_pages),
            'nb': page_nbr,
            'paginator': paginator,
            'suggestion': None,
            'model_name': MODEL_NAMES
        }

        if self.results and hasattr(
                self.results,
                'query') and self.results.query.backend.include_spelling:
            context['suggestion'] = self.form.get_suggestion()

        context.update(self.extra_context())
        return render(self.request, self.template, context)
Exemple #23
0
def topic(request, topic_pk, topic_slug):
    """Display a thread and its posts using a pager."""

    topic = get_object_or_404(Topic, pk=topic_pk)
    if not topic.forum.can_read(request.user):
        raise PermissionDenied

    # Check link

    if not topic_slug == slugify(topic.title):
        return redirect(topic.get_absolute_url())

    # If the user is authenticated and has never read topic, we mark it as
    # read.

    if request.user.is_authenticated():
        if never_read(topic):
            mark_read(topic)

    # Retrieves all posts of the topic and use paginator with them.

    posts = \
        Post.objects.filter(topic__pk=topic.pk) \
        .select_related() \
        .order_by("position"
                  ).all()
    last_post_pk = topic.last_message.pk

    # Handle pagination

    paginator = Paginator(posts, settings.POSTS_PER_PAGE)

    # The category list is needed to move threads

    categories = Category.objects.all()
    if "page" in request.GET:
        try:
            page_nbr = int(request.GET["page"])
        except:
            # problem in variable format
            raise Http404
    else:
        page_nbr = 1
    try:
        posts = paginator.page(page_nbr)
    except PageNotAnInteger:
        posts = paginator.page(1)
    except EmptyPage:
        raise Http404
    res = []
    if page_nbr != 1:

        # Show the last post of the previous page

        last_page = paginator.page(page_nbr - 1).object_list
        last_post = last_page[len(last_page) - 1]
        res.append(last_post)
    for post in posts:
        res.append(post)

    # Build form to send a post for the current topic.

    form = PostForm(topic, request.user)
    form.helper.form_action = reverse("zds.forum.views.answer") + "?sujet=" \
        + str(topic.pk)
    form_move = MoveTopicForm(topic=topic)

    return render_template("forum/topic/index.html", {
        "topic": topic,
        "posts": res,
        "categories": categories,
        "pages": paginator_range(page_nbr, paginator.num_pages),
        "nb": page_nbr,
        "last_post_pk": last_post_pk,
        "form": form,
        "form_move": form_move,
    })
Exemple #24
0
def view_online(request, article_pk, article_slug):
    '''Show the given article if exists and is visible'''
    article = get_object_or_404(Article, pk=article_pk)

    try:
        sha = request.GET['version']
    except KeyError:
        sha = article.sha_draft

    if article_slug != slugify(article.title):
        return redirect(article.get_absolute_url())

    #find the good manifest file
    article_version = article.load_json()
    txt = open(
        os.path.join(article.get_path(), article_version['text'] + '.html'),
        "r")
    article_version['txt'] = txt.read()
    txt.close()
    article_version['pk'] = article.pk
    article_version['slug'] = article.slug
    article_version['is_locked'] = article.is_locked
    if request.user.is_authenticated():
        article_version['antispam'] = article.antispam()

    #find reactions
    if request.user.is_authenticated():
        if never_read(article):
            mark_read(article)

    reactions = Reaction.objects\
                .filter(article__pk=article.pk)\
                .order_by('position')\
                .all()

    if article.last_reaction:
        last_reaction_pk = article.last_reaction.pk
    else:
        last_reaction_pk = 0

    # Handle pagination
    paginator = Paginator(reactions, settings.POSTS_PER_PAGE)

    try:
        page_nbr = int(request.GET['page'])
    except KeyError:
        page_nbr = 1

    try:
        reactions = paginator.page(page_nbr)
    except PageNotAnInteger:
        reactions = paginator.page(1)
    except EmptyPage:
        raise Http404

    res = []
    if page_nbr != 1:
        # Show the last reaction of the previous page
        last_page = paginator.page(page_nbr - 1).object_list
        last_reaction = (last_page)[len(last_page) - 1]
        res.append(last_reaction)

    for reaction in reactions:
        res.append(reaction)

    return render_template(
        'article/view_online.html', {
            'article': article_version,
            'authors': article.authors,
            'tags': article.subcategory,
            'version': sha,
            'prev': get_prev_article(article),
            'next': get_next_article(article),
            'reactions': res,
            'pages': paginator_range(page_nbr, paginator.num_pages),
            'nb': page_nbr,
            'last_reaction_pk': last_reaction_pk
        })
Exemple #25
0
def topic(request, topic_pk, topic_slug):
    '''
    Display a thread and its posts using a pager
    '''
    # TODO: Clean that up
    g_topic = get_object_or_404(Topic, pk=topic_pk)

    if not g_topic.forum.can_read(request.user):
        raise Http404
    # Check link
    if not topic_slug == slugify(g_topic.title):
        return redirect(g_topic.get_absolute_url())

    if request.user.is_authenticated():
        if never_read(g_topic):
            mark_read(g_topic)

    posts = Post.objects\
                .filter(topic__pk=g_topic.pk)\
                .order_by('position')\
                .all()

    last_post_pk = g_topic.last_message.pk

    # Handle pagination
    paginator = Paginator(posts, settings.POSTS_PER_PAGE)

    # The category list is needed to move threads
    categories = Category.objects.all()

    try:
        page_nbr = int(request.GET['page'])
    except KeyError:
        page_nbr = 1

    try:
        posts = paginator.page(page_nbr)
    except PageNotAnInteger:
        posts = paginator.page(1)
    except EmptyPage:
        raise Http404

    res = []
    if page_nbr != 1:
        # Show the last post of the previous page
        last_page = paginator.page(page_nbr - 1).object_list
        last_post = (last_page)[len(last_page) - 1]
        res.append(last_post)

    for post in posts:
        res.append(post)

    return render_template(
        'forum/topic.html', {
            'topic': g_topic,
            'posts': res,
            'categories': categories,
            'pages': paginator_range(page_nbr, paginator.num_pages),
            'nb': page_nbr,
            'last_post_pk': last_post_pk
        })
Exemple #26
0
def view_online(request, article_pk, article_slug):
    """Show the given article if exists and is visible."""
    article = get_object_or_404(Article, pk=article_pk)

    # The slug of the article must to be right.
    if article_slug != slugify(article.title):
        return redirect(article.get_absolute_url_online())

    # Load the article.
    article_version = article.load_json()
    txt = open(
        os.path.join(
            article.get_path(),
            article_version['text'] +
            '.html'),
        "r")
    article_version['txt'] = txt.read()
    txt.close()
    article_version['pk'] = article.pk
    article_version['slug'] = article.slug
    article_version['image'] = article.image
    article_version['is_locked'] = article.is_locked
    article_version['get_absolute_url'] = article.get_absolute_url()
    article_version['get_absolute_url_online'] = article.get_absolute_url_online()

    # If the user is authenticated
    if request.user.is_authenticated():
        # We check if he can post an article or not with
        # antispam filter.
        article_version['antispam'] = article.antispam()
        # If the user is never read, we mark this article read.
        if never_read(article):
            mark_read(article)

    # Find all reactions of the article.
    reactions = Reaction.objects\
        .filter(article__pk=article.pk)\
        .order_by('position')\
        .all()

    # Retrieve pk of the last reaction. If there aren't reactions
    # for the article, we initialize this last reaction at 0.
    last_reaction_pk = 0
    if article.last_reaction:
        last_reaction_pk = article.last_reaction.pk

    # Handle pagination.
    paginator = Paginator(reactions, settings.POSTS_PER_PAGE)

    try:
        page_nbr = int(request.GET['page'])
    except KeyError:
        page_nbr = 1

    try:
        reactions = paginator.page(page_nbr)
    except PageNotAnInteger:
        reactions = paginator.page(1)
    except EmptyPage:
        raise Http404

    res = []
    if page_nbr != 1:
        # Show the last reaction of the previous page
        last_page = paginator.page(page_nbr - 1).object_list
        last_reaction = (last_page)[len(last_page) - 1]
        res.append(last_reaction)

    for reaction in reactions:
        res.append(reaction)

    # Build form to send a reaction for the current article.
    form = ReactionForm(article, request.user)

    return render_template('article/view.html', {
        'article': article_version,
        'authors': article.authors,
        'tags': article.subcategory,
        'prev': get_prev_article(article),
        'next': get_next_article(article),
        'reactions': res,
        'pages': paginator_range(page_nbr, paginator.num_pages),
        'nb': page_nbr,
        'last_reaction_pk': last_reaction_pk,
        'form': form
    })
Exemple #27
0
def topic(request, topic_pk, topic_slug):
    """Display a thread and its posts using a pager."""

    topic = get_object_or_404(Topic, pk=topic_pk)
    if not topic.forum.can_read(request.user):
        raise PermissionDenied

    # Check link

    if not topic_slug == slugify(topic.title):
        return redirect(topic.get_absolute_url())

    # If the user is authenticated and has never read topic, we mark it as
    # read.

    if request.user.is_authenticated():
        if never_read(topic):
            mark_read(topic)

    # Retrieves all posts of the topic and use paginator with them.

    posts = \
        Post.objects.filter(topic__pk=topic.pk) \
        .select_related() \
        .order_by("position"
                  ).all()
    last_post_pk = topic.last_message.pk

    # Handle pagination

    paginator = Paginator(posts, settings.POSTS_PER_PAGE)

    # The category list is needed to move threads

    categories = Category.objects.all()
    try:
        page_nbr = int(request.GET["page"])
    except KeyError:
        page_nbr = 1
    try:
        posts = paginator.page(page_nbr)
    except PageNotAnInteger:
        posts = paginator.page(1)
    except EmptyPage:
        raise Http404
    res = []
    if page_nbr != 1:

        # Show the last post of the previous page

        last_page = paginator.page(page_nbr - 1).object_list
        last_post = last_page[len(last_page) - 1]
        res.append(last_post)
    for post in posts:
        res.append(post)

    # Build form to send a post for the current topic.

    form = PostForm(topic, request.user)
    form.helper.form_action = reverse("zds.forum.views.answer") + "?sujet=" \
        + str(topic.pk)
    form_move = MoveTopicForm(topic=topic)

    return render_template("forum/topic/index.html", {
        "topic": topic,
        "posts": res,
        "categories": categories,
        "pages": paginator_range(page_nbr, paginator.num_pages),
        "nb": page_nbr,
        "last_post_pk": last_post_pk,
        "form": form,
        "form_move": form_move,
    })
Exemple #28
0
def view_online(request, article_pk, article_slug):
    """Show the given article if exists and is visible."""
    article = get_object_or_404(Article, pk=article_pk)

    # Load the article.
    article_version = article.load_json_for_public()
    txt = open(
        os.path.join(article.get_path(), article_version['text'] + '.html'),
        "r")
    article_version['txt'] = txt.read()
    txt.close()
    article_version = article.load_dic(article_version)

    # If the user is authenticated
    if request.user.is_authenticated():
        # We check if he can post an article or not with
        # antispam filter.
        article_version['antispam'] = article.antispam()
        # If the user is never read, we mark this article read.
        if never_read(article):
            mark_read(article)

    # Find all reactions of the article.
    reactions = Reaction.objects\
        .filter(article__pk=article.pk)\
        .order_by('position')\
        .all()

    # Retrieve pk of the last reaction. If there aren't reactions
    # for the article, we initialize this last reaction at 0.
    last_reaction_pk = 0
    if article.last_reaction:
        last_reaction_pk = article.last_reaction.pk

    # Handle pagination.
    paginator = Paginator(reactions, settings.POSTS_PER_PAGE)

    try:
        page_nbr = int(request.GET['page'])
    except KeyError:
        page_nbr = 1

    try:
        reactions = paginator.page(page_nbr)
    except PageNotAnInteger:
        reactions = paginator.page(1)
    except EmptyPage:
        raise Http404

    res = []
    if page_nbr != 1:
        # Show the last reaction of the previous page
        last_page = paginator.page(page_nbr - 1).object_list
        last_reaction = (last_page)[len(last_page) - 1]
        res.append(last_reaction)

    for reaction in reactions:
        res.append(reaction)

    # Build form to send a reaction for the current article.
    form = ReactionForm(article, request.user)

    return render_template(
        'article/view.html', {
            'article': article_version,
            'authors': article.authors,
            'tags': article.subcategory,
            'prev': get_prev_article(article),
            'next': get_next_article(article),
            'reactions': res,
            'pages': paginator_range(page_nbr, paginator.num_pages),
            'nb': page_nbr,
            'last_reaction_pk': last_reaction_pk,
            'form': form
        })
Exemple #29
0
def view_online(request, article_pk, article_slug):
    '''Show the given article if exists and is visible'''
    article = get_object_or_404(Article, pk=article_pk)
    
    try:
        sha = request.GET['version']
    except KeyError:
        sha = article.sha_draft

    if article_slug != slugify(article.title):
        return redirect(article.get_absolute_url())
    
    #find the good manifest file
    article_version = article.load_json()
    txt = open(os.path.join(article.get_path(), article_version['text']+'.html'), "r")
    article_version['txt'] = txt.read()
    txt.close()
    article_version['pk'] = article.pk
    article_version['slug'] = article.slug
    article_version['is_locked'] = article.is_locked
    if request.user.is_authenticated():
        article_version['antispam'] = article.antispam()
    
    #find reactions
    if request.user.is_authenticated():
        if never_read(article):
            mark_read(article)
            
    reactions = Reaction.objects\
                .filter(article__pk=article.pk)\
                .order_by('position')\
                .all()
            
    if article.last_reaction:
        last_reaction_pk = article.last_reaction.pk
    else:
        last_reaction_pk = 0
    
    # Handle pagination
    paginator = Paginator(reactions, settings.POSTS_PER_PAGE)

    try:
        page_nbr = int(request.GET['page'])
    except KeyError:
        page_nbr = 1

    try:
        reactions = paginator.page(page_nbr)
    except PageNotAnInteger:
        reactions = paginator.page(1)
    except EmptyPage:
        raise Http404

    res = []
    if page_nbr != 1:
        # Show the last reaction of the previous page
        last_page = paginator.page(page_nbr - 1).object_list
        last_reaction = (last_page)[len(last_page) - 1]
        res.append(last_reaction)

    for reaction in reactions:
        res.append(reaction)
    
    return render_template('article/view_online.html', {
        'article': article_version,
        'authors': article.authors,
        'tags': article.subcategory,
        'version': sha,
        'prev': get_prev_article(article),
        'next': get_next_article(article),
        'reactions': res,
        'pages': paginator_range(page_nbr, paginator.num_pages),
        'nb': page_nbr,
        'last_reaction_pk': last_reaction_pk 
    })