Source code for org.views.form_registration_window

from __future__ import annotations

from collections import defaultdict
from onegov.core.security import Private
from onegov.form import CompleteFormSubmission
from onegov.form import FormDefinition
from onegov.form import FormRegistrationWindow
from onegov.form import FormSubmission
from onegov.org import OrgApp, _
from onegov.org.cli import close_ticket
from onegov.org.forms import FormRegistrationWindowForm
from onegov.org.forms.form_registration import FormRegistrationMessageForm
from onegov.org.layout import FormSubmissionLayout
from onegov.core.elements import Link, LinkGroup, Confirm, Intercooler, Block

from onegov.org.models import TicketNote
from onegov.org.views.form_submission import handle_submission_action
from onegov.org.mail import send_transactional_html_mail
from onegov.org.views.ticket import accept_ticket, send_email_if_enabled
from onegov.ticket import TicketCollection, Ticket


from typing import Any, Literal, TYPE_CHECKING
if TYPE_CHECKING:
    from email.headerregistry import Address
    from onegov.core.types import RenderData, SequenceOrScalar
    from onegov.org.request import OrgRequest
    from webob import Response


@OrgApp.form(
    model=FormDefinition,
    name='new-registration-window',
    permission=Private,
    form=FormRegistrationWindowForm,
    template='form.pt'
)


def handle_new_registration_form(
    self: FormDefinition,
    request: OrgRequest,
    form: FormRegistrationWindowForm,
    layout: FormSubmissionLayout | None = None
) -> RenderData | Response:
    title = _('New Registration Window')

    layout = layout or FormSubmissionLayout(self, request)
    layout.editbar_links = None
    layout.breadcrumbs.append(Link(title, '#'))

    if form.submitted(request):
        assert form.start.data is not None
        assert form.end.data is not None
        form.populate_obj(self.add_registration_window(
            form.start.data,
            form.end.data
        ))

        request.success(_('The registration window was added successfully'))
        return request.redirect(request.link(self))

    return {
        'layout': layout,
        'title': title,
        'form': form,
        'helptext': _(
            'Registration windows limit forms to a set number of submissions '
            'and a specific time-range.'
        )
    }





def send_form_registration_email(
    request: OrgRequest,
    receivers: SequenceOrScalar[Address | str],
    content: dict[str, Any],
    action: Literal['general-message']
) -> None:
    if action == 'general-message':
        subject = _('General Message')
    else:
        raise NotImplementedError

    send_transactional_html_mail(
        request=request,
        template='mail_registration_message.pt',
        subject=subject,
        receivers=receivers,
        content=content
    )





def ticket_linkable(
    request: OrgRequest,
    ticket: Ticket | None
) -> Ticket | None:

    if ticket is None:
        return None
    if not request.link(ticket):
        return None
    return ticket



@OrgApp.form(
    model=FormRegistrationWindow,
    permission=Private,
    name='send-message',
    template='form.pt',
    form=FormRegistrationMessageForm
)


def view_send_form_registration_message(
    self: FormRegistrationWindow,
    request: OrgRequest,
    form: FormRegistrationMessageForm,
    layout: FormSubmissionLayout | None = None,
) -> RenderData | Response:

    if form.submitted(request):
        count = 0
        tickets = TicketCollection(request.session)

        for email, submission in form.receivers.items():
            if not form.message.data:
                continue

            ticket = tickets.by_handler_id(submission.id.hex)

            # be extra safe and check for missing ticket of submission
            ticket = ticket_linkable(request, ticket)
            if ticket is not None:
                TicketNote.create(ticket, request, (
                    request.translate(_(
                        'New e-mail: ${message}',
                        mapping={'message': form.message.data.strip()}
                    ))
                ))

            send_form_registration_email(
                request=request,
                receivers=(email,),
                action='general-message',
                content={
                    'model': submission,
                    'action': 'general-message',
                    'message': form.message.data.strip(),
                }
            )
            count += 1

        request.success(
            _('Successfully sent ${count} emails', mapping={'count': count})
        )
        return request.redirect(request.link(self))

    layout = layout or FormSubmissionLayout(self.form, request)
    layout.breadcrumbs.append(
        Link(_('Registration Window'), request.link(self))
    )
    layout.editbar_links = []
    return {
        'title': _('Send E-Mail to attendees'),
        'layout': layout,
        'form': form
    }



@OrgApp.html(
    model=FormRegistrationWindow,
    permission=Private,
    template='registration_window.pt'
)


def view_registration_window(
    self: FormRegistrationWindow,
    request: OrgRequest,
    layout: FormSubmissionLayout | None = None
) -> RenderData:

    layout = layout or FormSubmissionLayout(self.form, request)
    title = layout.format_date_range(self.start, self.end)

    layout.breadcrumbs.append(Link(title, '#'))

    registrations = defaultdict(list)

    q = request.session.query(FormSubmission)
    q = q.filter_by(registration_window_id=self.id)
    q = q.filter_by(state='complete')
    # ogc-1345 order after family name first
    q = q.order_by(
        FormSubmission.data['nachname'],
        FormSubmission.data['name'],
        FormSubmission.data['vorname'],
    )
    has_pending_or_confirmed = False

    for submission in q:
        if not submission.registration_state:
            continue

        registrations[submission.registration_state].append(submission)
        if submission.registration_state != 'cancelled':
            has_pending_or_confirmed = True

    editbar_links: list[Link | LinkGroup] = [
        Link(
            text=_('Edit'),
            url=request.link(self, 'edit'),
            attrs={'class': 'edit-link'}
        )
    ]
    if registrations:
        editbar_links.append(
            Link(
                text=_('Email attendees'),
                url=request.link(self, name='send-message'),
                attrs={'class': 'manage-recipients'}
            )
        )
        editbar_links.append(
            Link(
                text=_('Cancel Registration Window'),
                url=layout.csrf_protected_url(
                    request.link(self, name='cancel')),
                attrs={'class': 'cancel'},
                traits=(
                    Confirm(
                        _('You really want to cancel all confirmed and '
                          'deny all open submissions for this '
                          'registration window?'),
                        _('Each attendee will receive a ticket email '
                          'unless ticket messages are not muted.'),
                        _('Cancel Registration Window'),
                        _('Cancel'),
                    ),
                    Intercooler(
                        request_method='POST',
                        redirect_after=request.link(self)
                    )
                )
            ),
        )
    editbar_links.append(
        Link(
            text=_('Delete'),
            url=layout.csrf_protected_url(request.link(self)),
            attrs={'class': 'delete-link'},
            traits=(
                Confirm(
                    _(
                        'Do you really want to delete '
                        'this registration window?'
                    ),
                    _('Existing submissions will be disassociated.'),
                    _('Delete registration window'),
                    _('Cancel')
                ),
                Intercooler(
                    request_method='DELETE',
                    redirect_after=request.link(self.form)
                )
            ) if not has_pending_or_confirmed else (
                Block(
                    _("This registration window can't be deleted."),
                    _('There are confirmed or open submissions associated '
                      'with it. Cancel the registration window first.'),
                    _('Cancel')
                )
            )
        )
    )

    layout.editbar_links = editbar_links

    tickets = TicketCollection(request.session)

    def ticket_link(subm: FormSubmission) -> str | None:
        ticket = tickets.by_handler_id(subm.id.hex)
        return ticket and request.link(ticket) or None

    return {
        'layout': layout,
        'title': title,
        'model': self,
        'registrations': registrations,
        'groups': (
            (_('Open'), 'open'),
            (_('Confirmed'), 'confirmed'),
            (_('Cancelled'), 'cancelled'),
        ),
        'ticket_link': ticket_link
    }



@OrgApp.form(
    model=FormRegistrationWindow,
    permission=Private,
    form=FormRegistrationWindowForm,
    template='form.pt',
    name='edit'
)


def handle_edit_registration_form(
    self: FormRegistrationWindow,
    request: OrgRequest,
    form: FormRegistrationWindowForm,
    layout: FormSubmissionLayout | None = None
) -> RenderData | Response:

    title = _('Edit Registration Window')

    layout = layout or FormSubmissionLayout(self.form, request)
    layout.breadcrumbs.append(Link(title, '#'))
    layout.editbar_links = []

    if form.submitted(request):
        form.populate_obj(self)

        request.success(_('Your changes were saved'))
        return request.redirect(request.link(self.form))

    elif not request.POST:
        form.process(obj=self)

    return {
        'layout': layout,
        'title': title,
        'form': form
    }



@OrgApp.view(
    model=FormRegistrationWindow,
    permission=Private,
    name='cancel',
    request_method='POST'
)


def view_cancel_submissions_for_registration_window(
    self: FormRegistrationWindow,
    request: OrgRequest
) -> None:
    """ Cancels a bunch of submissions either open ones or already accepted
    ones. If there is a corresponding ticket, it is accepted before denying
    the submission. """
    request.assert_valid_csrf_token()
    count = 0
    action: Literal['cancelled', 'denied']
    for submission in self.submissions:
        if submission.registration_state == 'confirmed':
            action = 'cancelled'
        elif submission.registration_state == 'open':
            action = 'denied'
        else:
            continue
        ticket = TicketCollection(request.session).by_handler_id(
            submission.id.hex)
        if ticket and ticket.state == 'open':
            accept_ticket(ticket, request)

        if ticket:
            # if there is a ticket then the submission is complete
            assert isinstance(submission, CompleteFormSubmission)
            handle_submission_action(
                submission, request, action, ignore_csrf=True, raises=True,
                no_messages=True, force_email=ticket.muted
            )

            assert request.current_user is not None
            close_ticket(ticket, request.current_user, request)
            # same behaviour as when closing ticket normally
            # to disable mail on ticket close, there is a ticket-setting
            send_email_if_enabled(
                ticket=ticket,
                request=request,
                template='mail_ticket_closed.pt',
                subject=_('Your request has been closed.')
            )
        count += 1
    if count:
        request.success(
            _('${count} submissions cancelled / denied over the ticket system',
              mapping={'count': count}))



@OrgApp.view(
    model=FormRegistrationWindow,
    permission=Private,
    request_method='DELETE'
)


def delete_registration_window(
    self: FormRegistrationWindow,
    request: OrgRequest
) -> None:

    request.assert_valid_csrf_token()

    self.disassociate()
    request.session.delete(self)

    request.success(_('The registration window was deleted'))