def add_fields(self):
        super(InputBasics, self).add_fields()

        self.fields[u'delivered_date'] = forms.DateField(
                label=_(u'inforequests:obligee_action:InputBasics:delivered_date:label'),
                localize=True,
                widget=forms.DateInput(attrs={
                    u'placeholder':
                        _('inforequests:obligee_action:InputBasics:delivered_date:placeholder'),
                    u'class': u'pln-datepicker',
                    }),
                )

        self.fields[u'attachments'] = AttachmentsField(
                label=_(u'inforequests:obligee_action:InputBasics:attachments:label'),
                help_text=_(u'inforequests:obligee_action:InputBasics:attachments:help_text'),
                upload_url_func=(
                    lambda: reverse(u'inforequests:upload_attachment')),
                download_url_func=(
                    lambda a: reverse(u'inforequests:download_attachment', args=[a.pk])),
                attached_to=(
                    self.wizard.draft,
                    Session.objects.get(session_key=self.wizard.request.session.session_key),
                    ),
                )
    def add_fields(self):
        super(Main, self).add_fields()

        self.fields[u'content'] = CompositeTextField(
                label=_(u'inforequests:clarification_response:Main:content:label'),
                template=u'inforequests/clarification_response/forms/content.txt',
                context=self.context(),
                fields=[
                    forms.CharField(widget=forms.Textarea(attrs={
                        u'placeholder':
                            _(u'inforequests:clarification_response:Main:content:placeholder'),
                        u'class': u'pln-autosize',
                        u'cols': u'', u'rows': u'',
                        })),
                    ],
                composite_attrs={
                    },
                )

        self.fields[u'attachments'] = AttachmentsField(
                label=_(u'inforequests:clarification_response:Main:attachments:label'),
                required=False,
                attached_to=(
                    self.wizard.draft,
                    Session.objects.get(session_key=self.wizard.request.session.session_key),
                    ),
                upload_url_func=(
                    lambda: reverse(u'inforequests:upload_attachment')),
                download_url_func=(
                    lambda a: reverse(u'inforequests:download_attachment', args=[a.pk])),
                )
    def add_fields(self):
        super(InputBasics, self).add_fields()

        self.fields[u'delivered_date'] = forms.DateField(
            label=_(
                u'inforequests:obligee_action:InputBasics:delivered_date:label'
            ),
            localize=True,
            widget=forms.DateInput(
                attrs={
                    u'placeholder':
                    _('inforequests:obligee_action:InputBasics:delivered_date:placeholder'
                      ),
                    u'class':
                    u'pln-datepicker',
                }),
        )

        self.fields[u'attachments'] = AttachmentsField(
            label=_(
                u'inforequests:obligee_action:InputBasics:attachments:label'),
            help_text=_(
                u'inforequests:obligee_action:InputBasics:attachments:help_text'
            ),
            upload_url_func=(
                lambda: reverse(u'inforequests:upload_attachment')),
            download_url_func=(lambda a: reverse(
                u'inforequests:download_attachment', args=[a.pk])),
            attached_to=(
                self.wizard.draft,
                Session.objects.get(
                    session_key=self.wizard.request.session.session_key),
            ),
        )
Beispiel #4
0
def index(request):
    if request.method == u'POST':
        button = clean_button(request.POST, [u'jump', u'reset'])

        if button == u'jump':
            form = forms.WarpForm(request.POST)
            if form.is_valid():
                jumpto = form.cleaned_data[u'jumpto']
                speedup = form.cleaned_data[u'speedup']
                if jumpto is not None or speedup is not None:
                    timewarp.jump(jumpto, speedup)
                return HttpResponseRedirect(reverse(u'admin:timewarp'))

        elif button == u'reset':
            timewarp.reset()
            return HttpResponseRedirect(reverse(u'admin:timewarp'))

        else: # invalid button
            form = forms.WarpForm()
    else:
        form = forms.WarpForm()

    return render(request, u'timewarp/timewarp.html', {
            u'timewarp': timewarp,
            u'form': form,
            u'title': u'Timewarp',
            })
Beispiel #5
0
def obligee_action_dispatcher(request):
    inforequests = (Inforequest.objects
            .not_closed()
            .owned_by(request.user)
            .order_by_submission_date()
            .select_undecided_emails_count()
            .prefetch_related(
                Inforequest.prefetch_main_branch(None,
                    Branch.objects.select_related(u'historicalobligee')))
            )

    # If the user has an inforequest with a new email, continue with it. If there is no new email
    # and the user has only one pending inforequest, continue with it. If the user has no pending
    # inforequests, return to inforequest index. Finally, if the user has at least two pending
    # inforequests, let him choose with which to continue.
    for inforequest in inforequests:
        if inforequest.has_undecided_emails:
            return HttpResponseRedirect(
                    reverse(u'inforequests:obligee_action', kwargs=dict(inforequest=inforequest)))
    if len(inforequests) == 1:
        return HttpResponseRedirect(
                reverse(u'inforequests:obligee_action', kwargs=dict(inforequest=inforequests[0])))
    if len(inforequests) == 0:
        return HttpResponseRedirect(reverse(u'inforequests:index'))

    return render(request, u'inforequests/obligee_action_dispatcher/dispatcher.html', {
            u'inforequests': inforequests,
            })
Beispiel #6
0
def index(request):
    if request.method == u'POST':
        button = clean_button(request.POST, [u'jump', u'reset'])

        if button == u'jump':
            form = forms.WarpForm(request.POST)
            if form.is_valid():
                jumpto = form.cleaned_data[u'jumpto']
                speedup = form.cleaned_data[u'speedup']
                if jumpto is not None or speedup is not None:
                    timewarp.jump(jumpto, speedup)
                return HttpResponseRedirect(reverse(u'admin:timewarp'))

        elif button == u'reset':
            timewarp.reset()
            return HttpResponseRedirect(reverse(u'admin:timewarp'))

        else:  # invalid button
            form = forms.WarpForm()
    else:
        form = forms.WarpForm()

    return render(request, u'timewarp/timewarp.html', {
        u'timewarp': timewarp,
        u'form': form,
        u'title': u'Timewarp',
    })
Beispiel #7
0
def file_create_or_edit(request, lang, path, name, create):
    u"""
    If ``create`` is False, then ``name`` should point to the page file we want to edit. If
    ``create`` is True, then ``name`` is ignored.
    """
    try:
        page = Page(path, lang)
    except InvalidPageError:
        raise Http404()
    if page.lpath != path:
        raise Http404()

    try:
        file = File(page, name) if not create else None
    except InvalidFileError:
        raise Http404()

    if request.method == u'POST':
        button = clean_button(request.POST, [u'save', u'save-and-continue'])

        if button in [u'save', u'save-and-continue']:
            form = forms.FileEditForm(page, file, create, request.POST,
                                      request.FILES)
            if form.is_valid():
                try:
                    new_file = form.save()
                except forms.FormSaveError:
                    pass
                else:
                    if button == u'save':
                        return HttpResponseRedirect(
                            reverse(u'admin:pages_edit',
                                    args=[lang, page.lpath]))
                    else:  # save-and-continue
                        return HttpResponseRedirect(
                            reverse(u'admin:pages_file_edit',
                                    args=[lang, page.lpath, new_file.name]))

        else:  # Invalid button
            raise SuspiciousOperation()

    else:  # GET
        form = forms.FileEditForm(page, file, create)

    return render(
        request, u'pages/admin/file_edit.html', {
            u'title':
            u'Add Page Attachment' if create else u'Edit Page Attachment',
            u'create': create,
            u'lang': lang,
            u'page': page,
            u'file': file,
            u'form': form,
        })
Beispiel #8
0
def page(context, *args):
    u"""
    Get page url. The page may be given with an absolute path or with a relative path
    with respect to the current page. If there is no current page, only absolute path
    may be given. The returned page is always is the same language as the current page.
    If you want to speficy different page paths for different languages, use multiple
    arguments prefixed with particular language code.

    Example: (Assuming the current page is '/sk/test/')
       Absolute path:
           {% page "/moo/foo/" %}                       -> /sk/moo/foo/
           {% page "/" %}                               -> /sk/
       Ralative path:
           {% page "foo/goo/" %}                        -> /sk/test/foo/goo/
           {% page "../" %}                             -> /sk/
           {% page "../foo/goo/" %}                     -> /sk/foo/goo/
           {% page "../../../../foo/goo/" %}            -> /sk/foo/goo/
       Path with no trailing slash:
           {% page "/moo/foo" %}                        -> /sk/foo/goo/
           {% page "foo/goo" %}                         -> /sk/test/foo/goo/
       File path:
           {% page "moo.jpg" %}                         -> /sk/test/moo.jpg
           {% page "/moo/foo/moo.jpg" %}                -> /sk/moo/foo/moo.jpg
           {% page "foo/goo/moo.jpg" %}                 -> /sk/test/foo/goo/moo.jpg
       Language alternatives:
           {% page "en:moo/enfoo" "sk:moo/skfoo" %}     -> /sk/test/moo/skfoo/
           {% page "en:moo/enfoo" "moo/xxfoo" %}        -> /sk/test/moo/xxfoo/
           {% page "en:moo/enfoo" %}                    -> /sk/test/
    """
    try:
        page = context[u'page']
        lang = page.lang
        path = page.path
    except (KeyError, AttributeError):
        lang = get_language()
        path = u'/'

    for arg in args:
        if u':' in arg:
            prefix, arg = arg.split(u':', 1)
            if prefix != lang:
                continue
        path = os.path.normpath(os.path.join(path, arg))
        break

    ppath, name = path.rsplit(u'/', 1)
    if u'.' in name:
        if not ppath.endswith(u'/'):
            ppath += u'/'
        return reverse(u'pages:file', args=[ppath.lstrip(u'/'), name])
    else:
        if not path.endswith(u'/'):
            path += u'/'
        return reverse(u'pages:view', args=[path.lstrip(u'/')])
Beispiel #9
0
def file_create_or_edit(request, lang, path, name, create):
    u"""
    If ``create`` is False, then ``name`` should point to the page file we want to edit. If
    ``create`` is True, then ``name`` is ignored.
    """
    try:
        page = Page(path, lang)
    except InvalidPageError:
        raise Http404()
    if page.lpath != path:
        raise Http404()

    try:
        file = File(page, name) if not create else None
    except InvalidFileError:
        raise Http404()

    if request.method == u'POST':
        button = clean_button(request.POST, [u'save', u'save-and-continue'])

        if button in [u'save', u'save-and-continue']:
            form = forms.FileEditForm(page, file, create, request.POST, request.FILES)
            if form.is_valid():
                try:
                    new_file = form.save()
                except forms.FormSaveError:
                    pass
                else:
                    if button == u'save':
                        return HttpResponseRedirect(reverse(u'admin:pages_edit',
                                args=[lang, page.lpath]))
                    else: # save-and-continue
                        return HttpResponseRedirect(reverse(u'admin:pages_file_edit',
                                args=[lang, page.lpath, new_file.name]))

        else: # Invalid button
            raise SuspiciousOperation()

    else: # GET
        form = forms.FileEditForm(page, file, create)

    return render(request, u'pages/admin/file_edit.html', {
            u'title': u'Add Page Attachment' if create else u'Edit Page Attachment',
            u'create': create,
            u'lang': lang,
            u'page': page,
            u'file': file,
            u'form': form,
            })
Beispiel #10
0
def alternatives(request, lang, path):
    try:
        page = Page(path, lang)
    except InvalidPageError:
        raise Http404()

    if page.lpath != path:
        logger = logging.getLogger(u'poleno.pages')
        logger.warning(u'Redirected request: /{}/{} -> /{}{}; Referer: {}'.format(
                lang, path, page.lang, page.path, request.META.get(u'HTTP_REFERER', u'--')))

    if page.is_disabled:
        raise Http404()
    if page.lpath != path:
        return HttpResponseRedirect(reverse(u'pages:alternatives', args=[lang, page.lpath]))

    alts = []
    current_lang = get_language()
    for alt_lang, alt_name in settings.LANGUAGES:
        alt_page = page.translation(alt_lang)
        if not alt_page:
            continue
        if alt_lang == current_lang:
            # And yet the translation is available
            return HttpResponseRedirect(alt_page.url)
        alts.append(dict(lang=alt_lang, name=alt_name, page=alt_page))

    return render(request, u'pages/alternatives.html', {
            u'alternatives': alts,
            })
Beispiel #11
0
def invite(request):
    if not request.user.invitationsupply.can_use_invitations:
        raise Http404()

    if request.method == u'POST':
        form = forms.InviteForm(request.POST)
        if form.is_valid():
            try:
                email = form.cleaned_data[u'email']
                request.user.invitationsupply.invite(email)
            except UserMayNotInvite:
                render_message(request, messages.ERROR,
                               u'invitations/messages/depleted.txt')
            else:
                render_message(request, messages.SUCCESS,
                               u'invitations/messages/invited.txt', {
                                   u'email': email,
                               })
            return HttpResponseRedirect(reverse(u'invitations:invite'))

    else:
        form = forms.InviteForm()

    return render(request, u'invitations/invite.html', {
        u'form': form,
    })
Beispiel #12
0
def delete(request, lang, path):
    try:
        page = Page(path, lang, keep_last=True)
    except InvalidPageError:
        raise Http404()
    if page.lpath != path:
        raise Http404()
    if page.is_root:
        raise Http404()

    if request.method == u'POST':
        button = clean_button(request.POST, [u'delete'])

        if button == u'delete':
            page.delete()
            return HttpResponseRedirect(reverse(u'admin:pages_index', args=[lang]))

        else: # Invalid button
            raise SuspiciousOperation()

    return render(request, u'pages/admin/delete.html', {
            u'title': u'Delete Page',
            u'lang': lang,
            u'page': page,
            })
Beispiel #13
0
def file_delete(request, lang, path, name):
    try:
        page = Page(path, lang)
    except InvalidPageError:
        raise Http404()
    if page.lpath != path:
        raise Http404()

    try:
        file = File(page, name)
    except InvalidFileError:
        raise Http404()

    if request.method == u'POST':
        button = clean_button(request.POST, [u'delete'])

        if button == u'delete':
            file.delete()
            return HttpResponseRedirect(reverse(u'admin:pages_edit', args=[lang, page.lpath]))

        else: # Invalid button
            raise SuspiciousOperation()

    return render(request, u'pages/admin/file_delete.html', {
            u'title': u'Delete Page Attachment',
            u'lang': lang,
            u'page': page,
            u'file': file,
            })
Beispiel #14
0
def snooze(request, inforequest_slug, inforequest_pk, branch_pk, action_pk):
    inforequest = (Inforequest.objects
            .not_closed().owned_by(request.user).get_or_404(pk=inforequest_pk))
    branch = inforequest.branch_set.get_or_404(pk=branch_pk)
    action = branch.last_action

    if action.pk != Action._meta.pk.to_python(action_pk):
        raise Http404()
    if not action.can_applicant_snooze:
        raise Http404()
    if inforequest.has_undecided_emails:
        raise Http404()
    if inforequest_slug != inforequest.slug:
        return HttpResponseRedirect(reverse(u'inforequests:snooze', kwargs=dict(action=action)))

    if request.method != u'POST':
        form = SnoozeForm(prefix=action.pk)
        return render_form(request, form, inforequest=inforequest, branch=branch, action=action)

    form = SnoozeForm(request.POST, prefix=action.pk)
    if not form.is_valid():
        return json_form(request, form, inforequest=inforequest, branch=branch, action=action)

    form.save(action)
    action.save(update_fields=[u'snooze'])

    # The inforequest was changed, we need to refetch it
    inforequest = Inforequest.objects.prefetch_detail().get(pk=inforequest.pk)
    return json_success(request, inforequest)
Beispiel #15
0
def alternatives(request, lang, path):
    try:
        page = Page(path, lang)
    except InvalidPageError:
        raise Http404()

    if page.lpath != path:
        logger = logging.getLogger(u'poleno.pages')
        logger.warning(
            u'Redirected request: /{}/{} -> /{}{}; Referer: {}'.format(
                lang, path, page.lang, page.path,
                request.META.get(u'HTTP_REFERER', u'--')))

    if page.is_disabled:
        raise Http404()
    if page.lpath != path:
        return HttpResponseRedirect(
            reverse(u'pages:alternatives', args=[lang, page.lpath]))

    alts = []
    current_lang = get_language()
    for alt_lang, alt_name in settings.LANGUAGES:
        alt_page = page.translation(alt_lang)
        if not alt_page:
            continue
        if alt_lang == current_lang:
            # And yet the translation is available
            return HttpResponseRedirect(alt_page.url)
        alts.append(dict(lang=alt_lang, name=alt_name, page=alt_page))

    return render(request, u'pages/alternatives.html', {
        u'alternatives': alts,
    })
Beispiel #16
0
def devtools_delete(request, inforequest_pk):
    assert settings.DEBUG

    inforequest = Inforequest.objects.owned_by(request.user).get_or_404(pk=inforequest_pk)
    inforequest.delete()

    return HttpResponseRedirect(reverse(u'inforequests:index'))
Beispiel #17
0
def delete(request, lang, path):
    try:
        page = Page(path, lang, keep_last=True)
    except InvalidPageError:
        raise Http404()
    if page.lpath != path:
        raise Http404()
    if page.is_root:
        raise Http404()

    if request.method == u'POST':
        button = clean_button(request.POST, [u'delete'])

        if button == u'delete':
            page.delete()
            return HttpResponseRedirect(
                reverse(u'admin:pages_index', args=[lang]))

        else:  # Invalid button
            raise SuspiciousOperation()

    return render(request, u'pages/admin/delete.html', {
        u'title': u'Delete Page',
        u'lang': lang,
        u'page': page,
    })
Beispiel #18
0
def adminurl(obj, view=u'change'):
    try:
        view_name = u'admin:{}_{}_{}'.format(obj._meta.app_label,
                                             obj._meta.model_name, view)
        return reverse(view_name, args=[obj.pk])
    except:
        return u''
Beispiel #19
0
def file(request, path, name):
    try:
        page = Page(path)
    except InvalidPageError:
        raise Http404()

    if page.lpath != path:
        logger = logging.getLogger(u'poleno.pages')
        logger.warning(
            u'Redirected request: /{}/{} -> /{}{}; Referer: {}'.format(
                page.lang, path, page.lang, page.path,
                request.META.get(u'HTTP_REFERER', u'--')))

    try:
        file = File(page, name)
    except InvalidFileError:
        raise Http404()

    if page.lpath != path:
        return HttpResponseRedirect(
            reverse(u'pages:file', args=[page.lpath, name]))

    return send_file_response(request,
                              file.filepath,
                              file.name,
                              file.content_type,
                              attachment=False)
Beispiel #20
0
def file_delete(request, lang, path, name):
    try:
        page = Page(path, lang)
    except InvalidPageError:
        raise Http404()
    if page.lpath != path:
        raise Http404()

    try:
        file = File(page, name)
    except InvalidFileError:
        raise Http404()

    if request.method == u'POST':
        button = clean_button(request.POST, [u'delete'])

        if button == u'delete':
            file.delete()
            return HttpResponseRedirect(
                reverse(u'admin:pages_edit', args=[lang, page.lpath]))

        else:  # Invalid button
            raise SuspiciousOperation()

    return render(
        request, u'pages/admin/file_delete.html', {
            u'title': u'Delete Page Attachment',
            u'lang': lang,
            u'page': page,
            u'file': file,
        })
Beispiel #21
0
def create_or_edit(request, lang, path, create):
    u"""
    If ``create`` is False, then ``path`` should point to the page we want to edit. If ``create``
    is True, then ``path`` should point to the page that will be the parent of the new page.
    """
    try:
        page = Page(path, lang, keep_last=True)
    except InvalidPageError:
        raise Http404()
    if page.lpath != path:
        raise Http404()
    if create and page.is_redirect:
        raise Http404()

    if request.method == u'POST':
        button = clean_button(request.POST, [u'save', u'save-and-continue'])

        if button in [u'save', u'save-and-continue']:
            form = forms.PageEditForm(page, create, request.POST)
            if form.is_valid():
                try:
                    new_page = form.save()
                except forms.FormSaveError:
                    pass
                else:
                    if button == u'save':
                        return HttpResponseRedirect(
                            reverse(u'admin:pages_index', args=[lang]))
                    else:  # save-and-continue
                        return HttpResponseRedirect(
                            reverse(u'admin:pages_edit',
                                    args=[lang, new_page.lpath]))

        else:  # Invalid button
            raise SuspiciousOperation()

    else:  # GET
        form = forms.PageEditForm(page, create)

    return render(
        request, u'pages/admin/edit.html', {
            u'title': u'Add Page' if create else u'Edit Page',
            u'create': create,
            u'lang': lang,
            u'page': page,
            u'form': form,
        })
Beispiel #22
0
def devtools_delete(request, inforequest_pk):
    assert settings.DEBUG

    inforequest = Inforequest.objects.owned_by(
        request.user).get_or_404(pk=inforequest_pk)
    inforequest.delete()

    return HttpResponseRedirect(reverse(u'inforequests:index'))
Beispiel #23
0
 def __init__(self, lang, field):
     super(LivePath, self).__init__(u'    • Details', format_html(
         u'<span class="live-path" data-field="{field}" data-value="{value}" data-url="{url}">'+
             u'{content}</span>',
         field=field.auto_id,
         url=reverse(u'admin:pages_live_path', args=[lang]),
         value=field.value(),
         content=self.render(lang, field.value()),
         ))
    def add_fields(self):
        super(Main, self).add_fields()

        self.fields[u'content'] = CompositeTextField(
            label=_(u'inforequests:clarification_response:Main:content:label'),
            template=u'inforequests/clarification_response/forms/content.txt',
            context=self.context(),
            fields=[
                forms.CharField(widget=forms.Textarea(
                    attrs={
                        u'placeholder':
                        _(u'inforequests:clarification_response:Main:content:placeholder'
                          ),
                        u'class':
                        u'pln-autosize',
                        u'cols':
                        u'',
                        u'rows':
                        u'',
                    })),
            ],
            composite_attrs={},
        )

        self.fields[u'attachments'] = AttachmentsField(
            label=_(
                u'inforequests:clarification_response:Main:attachments:label'),
            help_text=
            _(u'inforequests:clarification_response:Main:attachments:help_text'
              ),
            required=False,
            max_count=20,
            max_size=parsefilesize(u'15 MB'),
            max_total_size=parsefilesize(u'15 MB'),
            attached_to=(
                self.wizard.draft,
                Session.objects.get(
                    session_key=self.wizard.request.session.session_key),
            ),
            upload_url_func=(
                lambda: reverse(u'inforequests:upload_attachment')),
            download_url_func=(lambda a: reverse(
                u'inforequests:download_attachment', args=[a.pk])),
        )
Beispiel #25
0
def create_or_edit(request, lang, path, create):
    u"""
    If ``create`` is False, then ``path`` should point to the page we want to edit. If ``create``
    is True, then ``path`` should point to the page that will be the parent of the new page.
    """
    try:
        page = Page(path, lang, keep_last=True)
    except InvalidPageError:
        raise Http404()
    if page.lpath != path:
        raise Http404()
    if create and page.is_redirect:
        raise Http404()

    if request.method == u'POST':
        button = clean_button(request.POST, [u'save', u'save-and-continue'])

        if button in [u'save', u'save-and-continue']:
            form = forms.PageEditForm(page, create, request.POST)
            if form.is_valid():
                try:
                    new_page = form.save()
                except forms.FormSaveError:
                    pass
                else:
                    if button == u'save':
                        return HttpResponseRedirect(reverse(u'admin:pages_index', args=[lang]))
                    else: # save-and-continue
                        return HttpResponseRedirect(
                                reverse(u'admin:pages_edit', args=[lang, new_page.lpath]))

        else: # Invalid button
            raise SuspiciousOperation()

    else: # GET
        form = forms.PageEditForm(page, create)

    return render(request, u'pages/admin/edit.html', {
            u'title': u'Add Page' if create else u'Edit Page',
            u'create': create,
            u'lang': lang,
            u'page': page,
            u'form': form,
            })
def inforequest_detail(request, inforequest_slug, inforequest_pk):
    inforequest = Inforequest.objects.owned_by(request.user).prefetch_detail().get_or_404(pk=inforequest_pk)

    if inforequest_slug != inforequest.slug:
        return HttpResponseRedirect(reverse(u"inforequests:detail", kwargs=dict(inforequest=inforequest)))

    return render(
        request,
        u"inforequests/detail/detail.html",
        {u"inforequest": inforequest, u"devtools": u"inforequests/detail/devtools.html"},
    )
Beispiel #27
0
 def __init__(self, lang, field):
     super(LivePath, self).__init__(
         u'    • Details',
         format_html(
             u'<span class="live-path" data-field="{field}" data-value="{value}" data-url="{url}">'
             + u'{content}</span>',
             field=field.auto_id,
             url=reverse(u'admin:pages_live_path', args=[lang]),
             value=field.value(),
             content=self.render(lang, field.value()),
         ))
Beispiel #28
0
def appeal(request, inforequest_slug, inforequest_pk, branch_pk, step_idx=None):
    inforequest = (Inforequest.objects
            .not_closed().owned_by(request.user).get_or_404(pk=inforequest_pk))
    branch = inforequest.branch_set.get_or_404(pk=branch_pk)

    if not branch.can_add_appeal:
        raise Http404()
    if inforequest_slug != inforequest.slug:
        return HttpResponseRedirect(reverse(u'inforequests:appeal',
                kwargs=dict(branch=branch, step_idx=step_idx)))

    return wizard_view(AppealWizard, request, step_idx, branch)
Beispiel #29
0
def obligee_action(request, inforequest_slug, inforequest_pk, step_idx=None):
    inforequest = (Inforequest.objects
            .not_closed().owned_by(request.user).get_or_404(pk=inforequest_pk))
    inforequestemail = inforequest.inforequestemail_set.undecided().oldest().get_or_none()
    email = inforequestemail.email if inforequestemail is not None else None

    if inforequest_slug != inforequest.slug:
        return HttpResponseRedirect(reverse(u'inforequests:obligee_action',
                kwargs=dict(inforequest=inforequest, step_idx=step_idx)))

    return wizard_view(ObligeeActionWizard, request, step_idx,
            inforequest, inforequestemail, email)
Beispiel #30
0
def inforequest_detail(request, inforequest_slug, inforequest_pk):
    inforequest = (Inforequest.objects.owned_by(request.user).prefetch_detail()
                    .get_or_404(pk=inforequest_pk))

    if inforequest_slug != inforequest.slug:
        return HttpResponseRedirect(
                reverse(u'inforequests:detail', kwargs=dict(inforequest=inforequest)))

    return render(request, u'inforequests/detail/detail.html', {
            u'inforequest': inforequest,
            u'devtools': u'inforequests/detail/devtools.html',
            })
Beispiel #31
0
def admin_obj_format(obj, format=u'{tag}', *args, **kwargs):
    link = kwargs.pop(u'link', u'change')
    if obj is None:
        return u'--'
    tag = u'<{}: {}>'.format(obj.__class__.__name__, obj.pk)
    res = format.format(obj=obj, tag=tag, *args, **kwargs)
    if link:
        try:
            info = obj._meta.app_label, obj._meta.model_name, link
            url = reverse(u'admin:{}_{}_{}'.format(*info), args=[obj.pk])
            res = format_html(u'<a href="{0}">{1}</a>', url, res)
        except NoReverseMatch:
            pass
    return res
Beispiel #32
0
def obligee_action(request, inforequest_slug, inforequest_pk, step_idx=None):
    inforequest = (Inforequest.objects.not_closed().owned_by(
        request.user).get_or_404(pk=inforequest_pk))
    inforequestemail = inforequest.inforequestemail_set.undecided().oldest(
    ).get_or_none()
    email = inforequestemail.email if inforequestemail is not None else None

    if inforequest_slug != inforequest.slug:
        return HttpResponseRedirect(
            reverse(u'inforequests:obligee_action',
                    kwargs=dict(inforequest=inforequest, step_idx=step_idx)))

    return wizard_view(ObligeeActionWizard, request, step_idx, inforequest,
                       inforequestemail, email)
Beispiel #33
0
def admin_obj_format(obj, format=u'{tag}', *args, **kwargs):
    link = kwargs.pop(u'link', u'change')
    if obj is None:
        return u'--'
    tag = u'<{}: {}>'.format(obj.__class__.__name__, obj.pk)
    res = format.format(obj=obj, tag=tag, *args, **kwargs)
    if link:
        try:
            info = obj._meta.app_label, obj._meta.model_name, link
            url = reverse(u'admin:{}_{}_{}'.format(*info), args=[obj.pk])
            res = format_html(u'<a href="{0}">{1}</a>', url, res)
        except NoReverseMatch:
            pass
    return res
Beispiel #34
0
def appeal(request,
           inforequest_slug,
           inforequest_pk,
           branch_pk,
           step_idx=None):
    inforequest = (Inforequest.objects.not_closed().owned_by(
        request.user).get_or_404(pk=inforequest_pk))
    branch = inforequest.branch_set.get_or_404(pk=branch_pk)

    if not branch.can_add_appeal:
        raise Http404()
    if inforequest_slug != inforequest.slug:
        return HttpResponseRedirect(
            reverse(u'inforequests:appeal',
                    kwargs=dict(branch=branch, step_idx=step_idx)))

    return wizard_view(AppealWizard, request, step_idx, branch)
Beispiel #35
0
def view(request, path):
    try:
        page = Page(path)
    except InvalidPageError:
        raise Http404()

    if page.lpath != path:
        logger = logging.getLogger(u'poleno.pages')
        logger.warning(u'Redirected request: /{}/{} -> /{}{}; Referer: {}'.format(
                page.lang, path, page.lang, page.path, request.META.get(u'HTTP_REFERER', u'--')))

    if page.is_disabled:
        raise Http404()
    if page.lpath != path:
        return HttpResponseRedirect(reverse(u'pages:view', args=[page.lpath]))

    return render(request, u'pages/view.html', {
            u'page': page,
            })
Beispiel #36
0
def file(request, path, name):
    try:
        page = Page(path)
    except InvalidPageError:
        raise Http404()

    if page.lpath != path:
        logger = logging.getLogger(u'poleno.pages')
        logger.warning(u'Redirected request: /{}/{} -> /{}{}; Referer: {}'.format(
                page.lang, path, page.lang, page.path, request.META.get(u'HTTP_REFERER', u'--')))

    try:
        file = File(page, name)
    except InvalidFileError:
        raise Http404()

    if page.lpath != path:
        return HttpResponseRedirect(reverse(u'pages:file', args=[page.lpath, name]))

    return send_file_response(request, file.filepath, file.name,
            file.content_type, attachment=False)
Beispiel #37
0
def view(request, path):
    try:
        page = Page(path)
    except InvalidPageError:
        raise Http404()

    if page.lpath != path:
        logger = logging.getLogger(u'poleno.pages')
        logger.warning(
            u'Redirected request: /{}/{} -> /{}{}; Referer: {}'.format(
                page.lang, path, page.lang, page.path,
                request.META.get(u'HTTP_REFERER', u'--')))

    if page.is_disabled:
        raise Http404()
    if page.lpath != path:
        return HttpResponseRedirect(reverse(u'pages:view', args=[page.lpath]))

    return render(request, u'pages/view.html', {
        u'page': page,
    })
Beispiel #38
0
def change_lang(context, lang=None):
    u"""
    Get active page's url with laguage changed to the specified language.

    Example:
        {% change_lang 'en' %}

    Source: https://djangosnippets.org/snippets/2875/
    """
    path = context[u'request'].path
    url_parts = resolve(path)
    view_name = url_parts.view_name
    kwargs = url_parts.kwargs

    # Ask the view what to show after changing language.
    if hasattr(url_parts.func, u'change_lang'):
        view_name, kwargs = url_parts.func.change_lang(lang, **kwargs)

    with translation(lang):
        url = reverse(view_name, kwargs=kwargs)

    return format(url)
Beispiel #39
0
def change_lang(context, lang=None):
    u"""
    Get active page's url with laguage changed to the specified language.

    Example:
        {% change_lang 'en' %}

    Source: https://djangosnippets.org/snippets/2875/
    """
    path = context[u'request'].path
    url_parts = resolve(path)
    view_name = url_parts.view_name
    kwargs = url_parts.kwargs

    # Ask the view what to show after changing language.
    if hasattr(url_parts.func, u'change_lang'):
        view_name, kwargs = url_parts.func.change_lang(lang, **kwargs)

    with translation(lang):
        url = reverse(view_name, kwargs=kwargs)

    return format(url)
Beispiel #40
0
def snooze(request, inforequest_slug, inforequest_pk, branch_pk, action_pk):
    inforequest = (Inforequest.objects.not_closed().owned_by(
        request.user).get_or_404(pk=inforequest_pk))
    branch = inforequest.branch_set.get_or_404(pk=branch_pk)
    action = branch.last_action

    if action.pk != Action._meta.pk.to_python(action_pk):
        raise Http404()
    if not action.can_applicant_snooze:
        raise Http404()
    if inforequest.has_undecided_emails:
        raise Http404()
    if inforequest_slug != inforequest.slug:
        return HttpResponseRedirect(
            reverse(u'inforequests:snooze', kwargs=dict(action=action)))

    if request.method != u'POST':
        form = SnoozeForm(prefix=action.pk)
        return render_form(request,
                           form,
                           inforequest=inforequest,
                           branch=branch,
                           action=action)

    form = SnoozeForm(request.POST, prefix=action.pk)
    if not form.is_valid():
        return json_form(request,
                         form,
                         inforequest=inforequest,
                         branch=branch,
                         action=action)

    form.save(action)
    action.save(update_fields=[u'snooze'])

    # The inforequest was changed, we need to refetch it
    inforequest = Inforequest.objects.prefetch_detail().get(pk=inforequest.pk)
    return json_success(request, inforequest)
Beispiel #41
0
def inforequest_create(request, draft_pk=None):
    template = u'inforequests/create/create.html'
    draft = (InforequestDraft.objects.owned_by(request.user)
                .get_or_404(pk=draft_pk) if draft_pk else None)
    session = Session.objects.get(session_key=request.session.session_key)
    attached_to = (session, draft) if draft else (session,)

    if request.method != u'POST':
        form = InforequestForm(attached_to=attached_to, user=request.user)
        if draft:
            form.load_from_draft(draft)
        return render(request, template, dict(form=form))

    button = clean_button(request.POST, [u'submit', u'draft'])

    if button == u'draft':
        form = InforequestForm(request.POST, draft=True, attached_to=attached_to, user=request.user)
        if not form.is_valid():
            return render(request, template, dict(form=form))
        if not draft:
            draft = InforequestDraft(applicant=request.user)
        form.save_to_draft(draft)
        draft.save()
        return HttpResponseRedirect(reverse(u'inforequests:index'))

    if button == u'submit':
        form = InforequestForm(request.POST, attached_to=attached_to, user=request.user)
        if not form.is_valid():
            return render(request, template, dict(form=form))
        inforequest = form.save()
        inforequest.save()
        inforequest.main_branch.last_action.send_by_email()
        if draft:
            draft.delete()
        return HttpResponseRedirect(inforequest.get_absolute_url())

    raise SuspiciousOperation()
Beispiel #42
0
def invite(request):
    if not request.user.invitationsupply.can_use_invitations:
        raise Http404()

    if request.method == u'POST':
        form = forms.InviteForm(request.POST)
        if form.is_valid():
            try:
                email = form.cleaned_data[u'email']
                request.user.invitationsupply.invite(email)
            except UserMayNotInvite:
                render_message(request, messages.ERROR, u'invitations/messages/depleted.txt')
            else:
                render_message(request, messages.SUCCESS, u'invitations/messages/invited.txt', {
                    u'email': email,
                    })
            return HttpResponseRedirect(reverse(u'invitations:invite'))

    else:
        form = forms.InviteForm()

    return render(request, u'invitations/invite.html', {
            u'form': form,
        })
Beispiel #43
0
 def get_absolute_url(self, anchor=u''):
     return reverse(u'inforequests:detail',
                    kwargs=dict(inforequest=self)) + anchor
Beispiel #44
0
def adminurl(obj, view=u'change'):
    try:
        view_name = u'admin:{}_{}_{}'.format(obj._meta.app_label, obj._meta.model_name, view)
        return reverse(view_name, args=[obj.pk])
    except:
        return u''
def inforequest_delete_draft(request, draft_pk):
    draft = InforequestDraft.objects.owned_by(request.user).get_or_404(pk=draft_pk)
    draft.delete()
    return HttpResponseRedirect(reverse(u"inforequests:index"))
Beispiel #46
0
def attachment_upload(request):
    session = Session.objects.get(session_key=request.session.session_key)
    download_url_func = (
        lambda a: reverse(u'inforequests:download_attachment', args=[a.pk]))
    return attachments_views.upload(request, session, download_url_func)
Beispiel #47
0
 def url(self):
     with translation(self._lang):
         return reverse(u'pages:view', args=[self.lpath])
 def get_absolute_url(self, anchor=u''):
     return reverse(u'inforequests:detail', kwargs=dict(inforequest=self)) + anchor
Beispiel #49
0
def url(viewname, *args, **kwargs):
    return reverse(viewname, args=args, kwargs=kwargs)
 def get_step_url(self, step, anchor=u''):
     return reverse(u'inforequests:obligee_action',
             kwargs=dict(inforequest=self.inforequest, step=step)) + anchor
Beispiel #51
0
 def get_step_url(self, step, anchor=u''):
     return reverse(u'inforequests:appeal',
             kwargs=dict(branch=self.branch, step=step)) + anchor
 def get_step_url(self, step, anchor=u''):
     return reverse(u'inforequests:clarification_response',
             kwargs=dict(branch=self.branch, step=step)) + anchor
Beispiel #53
0
class InforequestForm(PrefixedForm):
    obligee = ObligeeField(
        label=_(u'inforequests:InforequestForm:obligee:label'),
        help_text=_(u'inforequests:InforequestForm:obligee:help_text'),
        widget=ObligeeWidget(
            input_attrs={
                u'placeholder':
                _(u'inforequests:InforequestForm:obligee:placeholder'),
            }),
    )
    subject = CompositeTextField(
        label=_(u'inforequests:InforequestForm:subject:label'),
        help_text=_(u'inforequests:InforequestForm:subject:help_text'),
        template=u'inforequests/create/forms/subject.txt',
        fields=[
            forms.CharField(
                max_length=50,
                widget=forms.TextInput(
                    attrs={
                        u'placeholder':
                        _(u'inforequests:InforequestForm:subject:placeholder'),
                    })),
        ],
    )
    content = CompositeTextField(
        label=_(u'inforequests:InforequestForm:content:label'),
        template=u'inforequests/create/forms/content.txt',
        fields=[
            forms.CharField(widget=forms.Textarea(
                attrs={
                    u'placeholder':
                    _(u'inforequests:InforequestForm:content:placeholder'),
                    u'class':
                    u'pln-autosize',
                    u'cols':
                    u'',
                    u'rows':
                    u'',
                })),
        ],
        composite_attrs={},
    )
    attachments = AttachmentsField(
        label=_(u'inforequests:InforequestForm:attachments:label'),
        help_text=_(u'inforequests:InforequestForm:attachments:help_text'),
        required=False,
        max_count=20,
        max_size=parsefilesize(u'15 MB'),
        max_total_size=parsefilesize(u'15 MB'),
        upload_url_func=(lambda: reverse(u'inforequests:upload_attachment')),
        download_url_func=(lambda a: reverse(
            u'inforequests:download_attachment', args=[a.pk])),
    )

    def __init__(self, *args, **kwargs):
        self.draft = kwargs.pop(u'draft', False)
        self.attached_to = kwargs.pop(u'attached_to')
        self.user = kwargs.pop(u'user')
        super(InforequestForm, self).__init__(*args, **kwargs)

        unique_email = settings.INFOREQUEST_UNIQUE_EMAIL.format(token=u'xxxx')
        unique_email = mark_safe(
            render_to_string(
                u'inforequests/create/snippets/content_unique_email.html',
                dict(unique_email=unique_email)).strip())
        self.fields[u'content'].widget.context[u'user'] = self.user
        self.fields[u'content'].widget.context[u'unique_email'] = unique_email
        self.fields[u'attachments'].attached_to = self.attached_to

        if self.draft:
            self.fields[u'obligee'].required = False
            self.fields[u'obligee'].email_required = False
            self.fields[u'subject'].required = False
            self.fields[u'content'].required = False
            self.fields[u'attachments'].max_count = None
            self.fields[u'attachments'].max_size = None
            self.fields[u'attachments'].max_total_size = None

    def save(self):
        assert self.is_valid()
        subject_finalize = lambda inforequest: self.fields[
            u'subject'].finalize(self.cleaned_data[u'subject'])
        content_finalize = lambda inforequest: self.fields[
            u'content'].finalize(
                self.cleaned_data[u'content'],
                dict(
                    unique_email=inforequest.unique_email,
                    obligee=self.cleaned_data[u'obligee'],
                ))
        inforequest = Inforequest.create(
            applicant=self.user,
            subject=self.cleaned_data[u'subject'][0],
            content=self.cleaned_data[u'content'][0],
            obligee=self.cleaned_data[u'obligee'],
            subject_finalize=subject_finalize,
            content_finalize=content_finalize,
            attachments=self.cleaned_data[u'attachments'],
        )
        return inforequest

    def save_to_draft(self, draft):
        assert self.is_valid()

        draft.obligee = self.cleaned_data[u'obligee']
        draft.subject = self.cleaned_data[u'subject']
        draft.content = self.cleaned_data[u'content']

        @after_saved(draft)
        def deferred(draft):
            # The new list of attachments may not be directly assigned to ``draft.attachment_set``
            # because the assignment would clear ``draft.attachment_set`` before adding the new
            # attachments. Any attachment that is in both the old and the new list would be deleted
            # and then saved again emitting ``*_delete`` signals and deleting its cascaded
            # relations.
            old_attachments = set(draft.attachment_set.all())
            new_attachments = []
            for attachment in self.cleaned_data[u'attachments']:
                if attachment in old_attachments:
                    old_attachments.remove(attachment)
                else:
                    new_attachments.append(attachment)
            draft.attachment_set.remove(*old_attachments)
            draft.attachment_set.add(*new_attachments)

    def load_from_draft(self, draft):
        self.initial[u'obligee'] = draft.obligee
        self.initial[u'subject'] = draft.subject
        self.initial[u'content'] = draft.content
        self.initial[u'attachments'] = draft.attachments
 def get_step_url(self, step, anchor=u''):
     return reverse(u'inforequests:obligee_action',
                    kwargs=dict(inforequest=self.inforequest,
                                step=step)) + anchor
Beispiel #55
0
def url(viewname, *args, **kwargs):
    return reverse(viewname, args=args, kwargs=kwargs)
Beispiel #56
0
    def __init__(self, page, create, *args, **kwargs):
        super(PageEditForm, self).__init__(*args, **kwargs)
        self.page = page
        self.create = create

        edit_root = not create and page.is_root
        edit_redirect = not create and page.is_redirect
        edit_regular = not create and not page.is_root and not page.is_redirect
        assert bool(create) + bool(edit_root) + bool(edit_redirect) + bool(
            edit_regular) == 1

        self.fieldsets = [
            Bunch(label=None, collapse=False, fields=[]),
            Bunch(label=u'Raw Config', collapse=True, fields=[]),
            Bunch(label=u'Page Content', collapse=False, fields=[]),
        ]

        if edit_regular:
            self.fields[u'parent'] = forms.CharField(
                label=u'URL Path',
                validators=[
                    RegexValidator(
                        pages.path_regex,
                        squeeze(u"""
                        Enter a valid path. It must be an absolute path with respect to the root
                        page starting and ending with a slash.
                        """)),
                ],
                widget=forms.TextInput(
                    attrs={
                        u'class':
                        u'popup-path',
                        u'style':
                        u'width: 50em;',
                        u'data-popup-url':
                        reverse(u'admin:pages_index', args=[page.lang]),
                        u'data-icon':
                        staticfiles_storage.url(
                            u'admin/img/selector-search.gif'),
                    }),
            )
            self.initial[u'parent'] = page.ppath
            self.fieldsets[0].fields.append(self[u'parent'])
            self.fieldsets[0].fields.append(
                LivePath(page.lang, self[u'parent']))
        else:
            self.fieldsets[0].fields.append(FakeField(u'URL Path', page.path))

        if create or edit_regular:
            self.fields[u'name'] = forms.CharField(
                label=u'URL Name',
                validators=[
                    RegexValidator(
                        pages.slug_regex,
                        u'Enter a valid slug. Only letters, numbers and dashes are allowed.'
                    ),
                ],
            )
            if not create:
                self.initial[u'name'] = page.name
            self.fieldsets[0].fields.append(self[u'name'])

        if create or edit_root or edit_regular:
            self.fields[u'title'] = forms.CharField(
                label=u'Page Title',
                required=False,
                widget=forms.TextInput(attrs={
                    u'style': u'width: 50em;',
                }),
            )
            if not create:
                self.initial[u'title'] = page._config.get(u'title')
            self.fieldsets[0].fields.append(self[u'title'])

        if create or edit_root or edit_regular:
            self.fields[u'label'] = forms.CharField(
                label=u'Menu Label',
                required=False,
            )
            if not create:
                self.initial[u'label'] = page._config.get(u'label')
            self.fieldsets[0].fields.append(self[u'label'])

        if create or edit_regular:
            self.fields[u'order'] = forms.CharField(
                label=u'Sort Key',
                required=False,
            )
            if not create:
                self.initial[u'order'] = page._config.get(u'order')
            self.fieldsets[0].fields.append(self[u'order'])

        if create or edit_regular:
            for lang, _ in settings.LANGUAGES:
                if lang != page.lang:
                    key = u'lang_{}'.format(lang)
                    self.fields[key] = forms.CharField(
                        label=u'Translation {}'.format(lang.upper()),
                        required=False,
                        validators=[
                            RegexValidator(
                                pages.path_regex,
                                squeeze(u"""
                                Enter a valid path. It must be an absolute path with respect to the
                                root page starting and ending with a slash.
                                """)),
                        ],
                        widget=forms.TextInput(
                            attrs={
                                u'class':
                                u'popup-path',
                                u'style':
                                u'width: 50em;',
                                u'data-popup-url':
                                reverse(u'admin:pages_index', args=[lang]),
                                u'data-icon':
                                staticfiles_storage.url(
                                    u'admin/img/selector-search.gif'),
                            }),
                    )
                    if not create:
                        self.initial[key] = page._config.get(key)
                    self.fieldsets[0].fields.append(self[key])
                    self.fieldsets[0].fields.append(LivePath(lang, self[key]))

        if edit_redirect:
            self.fields[u'redirect'] = forms.CharField(
                label=u'Redirect',
                validators=[
                    RegexValidator(
                        pages.path_regex,
                        squeeze(u"""
                        Enter a valid path. It must be an absolute path with respect to the root
                        page starting and ending with a slash.
                        """)),
                ],
                widget=forms.TextInput(
                    attrs={
                        u'class':
                        u'popup-path',
                        u'style':
                        u'width: 50em;',
                        u'data-popup-url':
                        reverse(u'admin:pages_index', args=[page.lang]),
                        u'data-icon':
                        staticfiles_storage.url(
                            u'admin/img/selector-search.gif'),
                    }),
            )
            self.initial[u'redirect'] = page.redirect_path
            self.fieldsets[0].fields.append(self[u'redirect'])
            self.fieldsets[0].fields.append(
                LivePath(page.lang, self[u'redirect']))

        if create or edit_root or edit_regular:
            self.fields[u'disabled'] = forms.BooleanField(
                label=u'Disabled',
                required=False,
            )
            if not create:
                self.initial[u'disabled'] = bool(page._config.get(u'disabled'))
            self.fieldsets[0].fields.append(self[u'disabled'])

        if create or edit_root or edit_regular:
            self.fields[u'raw'] = forms.CharField(
                label=u'',
                required=False,
                widget=forms.Textarea(attrs={
                    u'style': u'width: 100%; height: 10em;',
                }),
            )
            if not create:
                self.initial[u'raw'] = page.raw_config
            self.fieldsets[1].fields.append(self[u'raw'])

        if create or edit_root or edit_regular:
            with translation(page.lang):
                url = reverse(u'admin:pages_preview')
            self.fields[u'template'] = forms.CharField(
                label=u'',
                required=False,
                widget=forms.Textarea(attrs={
                    u'class': u'template-widget',
                    u'data-url': url,
                }),
            )
            if not create:
                self.initial[u'template'] = page.template
            self.fieldsets[2].fields.append(self[u'template'])