def publish_event(self, request):
""" Publish an event. """
self.publish()
request.success(_("You have accepted the event ${title}", mapping={
'title': self.title
}))
if self.meta.get('submitter_email'):
session = request.app.session()
ticket = TicketCollection(session).by_handler_id(self.id.hex)
send_html_mail(
request=request,
template='mail_event_accepted.pt',
subject=_("Your event was accepted"),
receivers=(self.meta.get('submitter_email'), ),
content={
'model': self,
'ticket': ticket
}
)
if 'return-to' in request.GET:
return morepath.redirect(request.GET['return-to'])
return morepath.redirect(request.link(self))
def view_upload_election(self, request):
""" Upload results of an election.
Redirects to the majorz or proporz upload view.
"""
if self.type == 'majorz':
return morepath.redirect(request.link(self, 'upload-majorz'))
return morepath.redirect(request.link(self, 'upload-proporz'))
def view_latest_event(self, request):
""" Redirects to the latest occurrence of an event that is, either the
next future event or the last event in the past if there are no more
future events.
"""
now = utcnow()
for occurrence in self.occurrences:
if now < occurrence.start:
return morepath.redirect(request.link(occurrence))
return morepath.redirect(request.link(occurrence))
def handle_edit_reservation(self, request, form):
# this view is public, but only for a limited time
assert_anonymous_access_only_temporary(self, request)
collection = ResourceCollection(request.app.libres_context)
resource = collection.by_id(self.resource)
if form.submitted(request):
scheduler = resource.get_scheduler(request.app.libres_context)
try:
if self.email != form.email.data:
scheduler.change_email(self.token, form.email.data)
start, end = form.get_date_range()
scheduler.change_reservation(
self.token, self.id, start, end, quota=form.data.get('quota')
)
except LibresError as e:
utils.show_libres_error(e, request)
else:
forms = FormCollection(request.app.session())
submission = forms.submissions.by_id(self.token)
confirm_link = request.link(self, 'bestaetigung')
if submission is None:
return morepath.redirect(confirm_link)
else:
return morepath.redirect(
get_submission_link(request, submission, confirm_link)
)
form.apply_model(self)
layout = ReservationLayout(resource, request)
layout.breadcrumbs.append(Link(_("Edit Reservation"), '#'))
title = _("Change reservation for ${title}", mapping={
'title': resource.title,
})
return {
'layout': layout,
'title': title,
'form': form,
'allocation': self,
'button_text': _("Continue")
}
def handle_password_reset_request(self, request, form):
""" Handles the GET and POST password reset requests. """
if form.submitted(request):
user, token = form.get_token(request)
if user is not None and token is not None:
url = "{0}?token={1}".format(request.link(self, name="reset-password"), token)
send_html_mail(
request=request,
template="mail_password_reset.pt",
subject=_("Password reset"),
receivers=(user.username,),
content={"model": None, "url": url},
)
else:
log.info("Failed password reset attempt by {}".format(request.client_addr))
response = morepath.redirect(request.link(self))
request.success(
_(
(
u"A password reset link has been sent to ${email}, provided an "
u"account exists for this email address."
),
mapping={"email": form.email.data},
)
)
return response
layout = DefaultLayout(self, request)
layout.breadcrumbs = [
Link(_("Homepage"), layout.homepage_url),
Link(_("Reset password"), request.link(self, name="request-password")),
]
return {"layout": layout, "title": _(u"Reset password"), "form": form, "form_width": "small"}
def handle_password_reset(self, request, form):
request.include("common")
request.include("check_password")
if form.submitted(request):
identity = form.get_identity(request)
if identity is not None:
response = morepath.redirect(request.link(self))
morepath.remember_identity(response, request, identity)
request.success(_("Password changed."))
return response
else:
request.alert(_("Wrong username or password reset link not valid any more."))
log.info("Failed password reset attempt by {}".format(request.client_addr))
if "token" in request.params:
form.token.data = request.params["token"]
layout = DefaultLayout(self, request)
layout.breadcrumbs = [
Link(_("Homepage"), layout.homepage_url),
Link(_("Reset password"), request.link(self, name="request-password")),
]
return {"layout": layout, "title": _(u"Reset password"), "form": form, "form_width": "small"}
def delete_upload_token(self, request, form):
""" Delete the upload token item. """
layout = ManageUploadTokensLayout(self, request)
if form.submitted(request):
upload_tokens = UploadTokenCollection(request.session)
upload_tokens.delete(self)
request.message(_("Upload token deleted."), 'success')
return morepath.redirect(layout.manage_model_link)
return {
'message': _(
'Do you really want to delete "${item}"?',
mapping={'item': self.token}
),
'layout': layout,
'form': form,
'title': self.token,
'subtitle': _("Delete upload token"),
'button_text': _("Delete upload token"),
'button_class': 'alert',
'cancel': layout.manage_model_link
}
def edit_election(self, request, form):
""" Edit an existing election. """
layout = ManageElectionsLayout(self, request)
archive = ArchivedResultCollection(request.session)
form.set_domain(request.app.principal)
if form.submitted(request):
form.update_model(self)
archive.update(self, request)
request.message(_("Election modified."), 'success')
return redirect(layout.manage_model_link)
if not form.errors:
form.apply_model(self)
return {
'layout': layout,
'form': form,
'title': self.title,
'shortcode': self.shortcode,
'subtitle': _("Edit election"),
'cancel': layout.manage_model_link
}
def view_trigger_notficiations(self, request, form):
""" Trigger the notifications of the current election day. """
layout = ManageLayout(self, request)
session = request.session
if form.submitted(request):
notifications = NotificationCollection(session)
notifications.trigger_summarized(
request,
form.election_models(session),
form.vote_models(session),
form.notifications.data
)
request.message(_("Notifications triggered."), 'success')
return redirect(layout.manage_link)
latest_date = form.latest_date(session)
latest_date = layout.format_date(latest_date, 'date_long')
return {
'layout': layout,
'form': form,
'title': _("Trigger notifications"),
'subtitle': _(
"Elections and votes on ${date}",
mapping={'date': latest_date}
),
'cancel': layout.manage_link
}
def handle_cleanup_allocations(self, request, form):
""" Removes all unused allocations between the given dates. """
if form.submitted(request):
start, end = form.data['start'], form.data['end']
scheduler = self.get_scheduler(request.app.libres_context)
count = scheduler.remove_unused_allocations(start, end)
request.success(
_("Successfully removed ${count} unused allocations", mapping={
'count': count
})
)
return morepath.redirect(request.link(self))
layout = ResourceLayout(self, request)
layout.breadcrumbs.append(Link(_("Clean up"), '#'))
layout.editbar_links = None
return {
'layout': layout,
'title': _("Clean up"),
'form': form
}
def clear_election_compound(self, request, form):
""" Clear the results of an election ompound. """
layout = ManageElectionCompoundsLayout(self, request)
archive = ArchivedResultCollection(request.session)
if form.submitted(request):
archive.clear(self, request)
request.message(_("Results deleted."), 'success')
return redirect(layout.manage_model_link)
return {
'message': _(
'Do you really want to clear all party results of "${item}"?',
mapping={
'item': self.title
}
),
'layout': layout,
'form': form,
'title': self.title,
'shortcode': self.shortcode,
'subtitle': _("Clear results"),
'button_text': _("Clear results"),
'button_class': 'alert',
'cancel': layout.manage_model_link
}
def handle_new_definition(self, request, form):
if form.submitted(request):
model = Bunch(
title=None, definition=None, type='custom', meta={}, content={}
)
form.update_model(model)
# forms added online are always custom forms
new_form = self.definitions.add(
title=model.title,
definition=model.definition,
type='custom',
meta=model.meta,
content=model.content
)
request.success(_("Added a new form"))
return morepath.redirect(request.link(new_form))
layout = FormEditorLayout(self, request)
layout.breadcrumbs = [
Link(_("Homepage"), layout.homepage_url),
Link(_("Forms"), request.link(self)),
Link(_("New Form"), request.link(self, name='neu'))
]
return {
'layout': layout,
'title': _("New Form"),
'form': form,
'form_width': 'large',
}
def handle_edit_definition(self, request, form):
if form.submitted(request):
self.title = form.title.data
if self.type == 'custom':
self.definition = form.definition.data
form.update_model(self)
request.success(_("Your changes were saved"))
return morepath.redirect(request.link(self))
else:
form.title.data = self.title
form.definition.data = self.definition
form.apply_model(self)
collection = FormCollection(request.app.session())
layout = FormEditorLayout(self, request)
layout.breadcrumbs = [
Link(_("Homepage"), layout.homepage_url),
Link(_("Forms"), request.link(collection)),
Link(self.title, request.link(self)),
Link(_("Edit"), request.link(self, name='bearbeiten'))
]
return {
'layout': layout,
'title': self.title,
'form': form,
'form_width': 'large',
}
def search(self, request):
layout = DefaultLayout(self, request)
layout.breadcrumbs.append(Link(_("Search"), "#"))
try:
request.app.es_client.ping()
except TransportError:
log.warn("Elasticsearch cluster is offline")
return {"title": _("Search Unavailable"), "layout": layout, "connection": False}
if "lucky" in request.GET:
url = self.feeling_lucky()
if url:
return morepath.redirect(url)
return {
"title": _("Search"),
"model": self,
"layout": layout,
"hide_search_header": True,
"searchlabel": _("Search through ${count} indexed documents", mapping={"count": self.available_documents}),
"resultslabel": _("${count} Results", mapping={"count": self.subset_count}),
"connection": True,
}
def delete_subscriber(self, request, form):
""" Delete a single subsriber. """
layout = ManageSubscribersLayout(self, request)
if form.submitted(request):
subscribers = SubscriberCollection(request.session)
subscribers.unsubscribe(self.address)
request.message(_("Subscriber deleted."), 'success')
return redirect(layout.manage_model_link)
return {
'message': _(
'Do you really want to delete "${item}"?',
mapping={
'item': self.address
}
),
'layout': layout,
'form': form,
'title': self.address,
'subtitle': _("Delete subscriber"),
'button_text': _("Delete subscriber"),
'button_class': 'alert',
'cancel': layout.manage_model_link
}
def view_topic(self, request):
assert self.trait in {'link', 'page'}
if not request.is_logged_in and self.trait == 'link':
return morepath.redirect(self.content['url'])
layout = PageLayout(self, request)
if request.is_logged_in:
layout.editbar_links = self.get_editbar_links(request)
children = self.children
else:
children = request.exclude_invisible(self.children)
return {
'layout': layout,
'title': self.title,
'name': self.trait_messages[self.trait]['name'],
'page': self,
'children': [
Link(child.title, request.link(child), model=child)
for child in sorted(children, key=lambda c: c.name)
]
}
def handle_defined_form(self, request, form):
""" Renders the empty form and takes input, even if it's not valid, stores
it as a pending submission and redirects the user to the view that handles
pending submissions.
"""
collection = FormCollection(request.app.session())
if request.POST:
submission = collection.submissions.add(
self.name, form, state='pending')
return morepath.redirect(request.link(submission))
return {
'layout': FormSubmissionLayout(self, request),
'title': self.title,
'form': form,
'definition': self,
'form_width': 'small',
'lead': self.meta.get('lead'),
'text': self.content.get('text'),
'people': self.people,
'contact': self.contact_html
}
def delete_election_compound(self, request, form):
""" Delete an existing election compound. """
layout = ManageElectionCompoundsLayout(self, request)
archive = ArchivedResultCollection(request.session)
if form.submitted(request):
archive.delete(self, request)
request.message(_("Compound deleted."), 'success')
return redirect(layout.manage_model_link)
return {
'message': _(
'Do you really want to delete "${item}"?',
mapping={
'item': self.title
}
),
'layout': layout,
'form': form,
'title': self.title,
'shortcode': self.shortcode,
'subtitle': _("Delete compound"),
'button_text': _("Delete compound"),
'button_class': 'alert',
'cancel': layout.manage_model_link
}
def handle_new_page(self, request, form, src=None):
if form.submitted(request):
pages = PageCollection(request.app.session())
page = pages.add(
parent=self.page,
title=form.title.data,
type=self.page.type,
meta={'trait': self.trait}
)
form.update_model(page)
request.app.update_homepage_pages()
request.success(page.trait_messages[page.trait]['new_page_added'])
return morepath.redirect(request.link(page))
if src:
form.apply_model(src)
site_title = self.page.trait_messages[self.trait]['new_page_title']
return {
'layout': EditorLayout(self, request, site_title),
'title': site_title,
'form': form,
'form_width': 'large'
}
def reopen_ticket(self, request):
user = UserCollection(request.app.session()).by_username(
request.identity.userid)
try:
self.reopen_ticket(user)
except InvalidStateChange:
request.alert(
_("The ticket cannot be re-opened because it's not closed.")
)
else:
request.success(_("You have reopened ticket ${number}", mapping={
'number': self.number
}))
email = self.snapshot.get('email') or self.handler.email
send_html_mail(
request=request,
template='mail_ticket_reopened.pt',
subject=_("Your ticket has been reopened"),
receivers=(email, ),
content={
'model': self
}
)
request.app.update_ticket_count()
return morepath.redirect(request.link(self))
def close_ticket(self, request):
try:
self.close_ticket()
except InvalidStateChange:
request.alert(
_("The ticket cannot be closed because it's not pending")
)
else:
request.success(_("You have closed ticket ${number}", mapping={
'number': self.number
}))
email = self.snapshot.get('email') or self.handler.email
send_html_mail(
request=request,
template='mail_ticket_closed.pt',
subject=_("Your ticket has been closed"),
receivers=(email, ),
content={
'model': self
}
)
request.app.update_ticket_count()
return morepath.redirect(
request.link(TicketCollection(request.app.session())))
def accept_reservation(self, request):
if not self.data or not self.data.get('accepted'):
collection = ResourceCollection(request.app.libres_context)
resource = collection.by_id(self.resource)
scheduler = resource.get_scheduler(request.app.libres_context)
reservations = scheduler.reservations_by_token(self.token)
send_html_mail(
request=request,
template='mail_reservation_accepted.pt',
subject=_("Your reservation was accepted"),
receivers=(self.email, ),
content={
'model': self,
'resource': resource,
'reservations': reservations
}
)
for reservation in reservations:
reservation.data = reservation.data or {}
reservation.data['accepted'] = True
# libres does not automatically detect changes yet
flag_modified(reservation, 'data')
request.success(_("The reservation was accepted"))
else:
request.warning(_("The reservation has already been accepted"))
return morepath.redirect(request.params['return-to'])
def reject_reservation(self, request):
collection = ResourceCollection(request.app.libres_context)
resource = collection.by_id(self.resource)
scheduler = resource.get_scheduler(request.app.libres_context)
reservations = scheduler.reservations_by_token(self.token.hex)
forms = FormCollection(request.app.session())
submission = forms.submissions.by_id(self.token.hex)
send_html_mail(
request=request,
template='mail_reservation_rejected.pt',
subject=_("Your reservation was rejected"),
receivers=(self.email, ),
content={
'model': self,
'resource': resource,
'reservations': reservations
}
)
# create a snapshot of the ticket to keep the useful information
tickets = TicketCollection(request.app.session())
ticket = tickets.by_handler_id(self.token.hex)
ticket.create_snapshot(request)
scheduler.remove_reservation(self.token.hex)
if submission:
forms.submissions.delete(submission)
request.success(_("The reservation was rejected"))
# return none on intercooler js requests
if not request.headers.get('X-IC-Request'):
return morepath.redirect(request.params['return-to'])
def delete_data_source_item(self, request, form):
""" Delete the data source item. """
layout = ManageDataSourceItemsLayout(self.source, request)
if form.submitted(request):
data_source_items = DataSourceItemCollection(request.session)
data_source_items.delete(self)
request.message(_("Mapping deleted."), 'success')
return morepath.redirect(layout.manage_model_link)
return {
'message': _(
'Do you really want to delete "${item}"?',
mapping={
'item': self.name
}
),
'layout': layout,
'form': form,
'title': self.name,
'subtitle': _("Delete mapping"),
'button_text': _("Delete mapping"),
'button_class': 'alert',
'cancel': layout.manage_model_link
}
def handle_complete_submission(self, request):
form = request.get_form(self.form_class, data=self.data)
# we're not really using a csrf protected form here (the complete form
# button is basically just there so we can use a POST instead of a GET)
form.validate()
form.ignore_csrf_error()
if form.errors:
return morepath.redirect(request.link(self))
else:
if self.state == 'complete':
self.data.changed() # trigger updates
request.success(_(u"Your changes were saved"))
return morepath.redirect(request.link(
FormCollection(request.app.session()).scoped_submissions(
self.name, ensure_existance=False)
))
else:
collection = FormCollection(request.app.session())
collection.submissions.complete_submission(self)
# make sure accessing the submission doesn't flush it, because
# it uses sqlalchemy utils observe, which doesn't like premature
# flushing at all
with collection.session.no_autoflush:
ticket = TicketCollection(request.app.session()).open_ticket(
handler_code='FRM', handler_id=self.id.hex
)
send_html_mail(
request=request,
template='mail_ticket_opened.pt',
subject=_("A ticket has been opened"),
receivers=(self.email, ),
content={
'model': ticket
}
)
request.success(_("Thank you for your submission!"))
request.app.update_ticket_count()
return morepath.redirect(request.link(ticket, 'status'))
def handle_pending_submission(self, request):
""" Renders a pending submission, takes it's input and allows the
user to turn the submission into a complete submission, once all data
is valid.
Takes the following query parameters for customization::
* ``edit`` no validation is done on the first load if present
* ``return-to`` the view redirects to this url once complete if present
* ``title`` a custom title (required if external submission)
* ``quiet`` no success messages are rendered if present
"""
collection = FormCollection(request.app.session())
form = request.get_form(self.form_class, data=self.data)
form.action = request.link(self)
if 'edit' not in request.GET:
form.validate()
if not request.POST:
form.ignore_csrf_error()
else:
collection.submissions.update(self, form)
# these parameters keep between form requests (the rest throw away)
for param in {'return-to', 'title', 'quiet'}:
if param in request.GET:
action = URL(form.action).query_param(param, request.GET[param])
form.action = action.as_string()
completable = not form.errors and 'edit' not in request.GET
if completable and 'return-to' in request.GET:
if 'quiet' not in request.GET:
request.success(_("Your changes were saved"))
return morepath.redirect(request.GET['return-to'])
if 'title' in request.GET:
title = request.GET['title']
else:
title = self.form.title
return {
'layout': FormSubmissionLayout(self, request, title),
'title': title,
'form': form,
'completable': completable,
'edit_link': request.link(self) + '?edit',
'complete_link': request.link(self, 'complete'),
'is_pending': self.state == 'pending',
'readonly': 'readonly' in request.GET,
}
def manage_data_source(self, request):
""" Manage the data source.
Redirect to the list of data source items.
"""
layout = ManageDataSourceItemsLayout(self, request)
return morepath.redirect(layout.manage_model_link)
def handle_new_allocation(self, request, form):
""" Handles new allocations for differing form classes. """
if form.submitted(request):
scheduler = self.get_scheduler(request.app.libres_context)
try:
allocations = scheduler.allocate(
dates=form.dates,
whole_day=form.whole_day,
quota=form.quota,
quota_limit=form.quota_limit,
data=form.data,
partly_available=form.partly_available
)
except LibresError as e:
utils.show_libres_error(e, request)
else:
request.success(_("Successfully added ${n} allocations", mapping={
'n': len(allocations)
}))
self.highlight_allocations(allocations)
return morepath.redirect(request.link(self))
elif not request.POST:
start, end = utils.parse_fullcalendar_request(request, self.timezone)
whole_day = request.params.get('whole_day') == 'yes'
if start and end:
if whole_day:
form.start.data = start
form.end.data = end
if hasattr(form, 'as_whole_day'):
form.as_whole_day.data = 'yes'
else:
form.start.data = start
form.end.data = end
if hasattr(form, 'as_whole_day'):
form.as_whole_day.data = 'no'
if hasattr(form, 'start_time'):
form.start_time.data = start
form.end_time.data = end
layout = ResourceLayout(self, request)
layout.breadcrumbs.append(Link(_("New allocation"), '#'))
layout.editbar_links = None
return {
'layout': layout,
'title': _("New allocation"),
'form': form
}
def accept_ticket(self, request):
user = UserCollection(request.app.session()).by_username(
request.identity.userid)
self.accept_ticket(user)
request.success(_(u"You have accepted ticket ${number}", mapping={
'number': self.number
}))
request.app.update_ticket_count()
return morepath.redirect(request.link(self))
def handle_edit_event(self, request, form):
""" Edit an event.
An anonymous user might edit an initiated event, a logged in user can also
edit all events.
"""
assert_anonymous_access_only_temporary(request, self)
if form.submitted(request):
form.update_model(self)
request.success(_("Your changes were saved"))
if 'return-to' in request.GET:
return morepath.redirect(request.GET['return-to'])
return morepath.redirect(request.link(self))
form.apply_model(self)
if 'return-to' in request.GET:
action = URL(form.action)
action = action.query_param('return-to', request.GET['return-to'])
form.action = action.as_string()
layout = EventLayout(self, request)
layout.breadcrumbs.append(Link(_("Edit"), '#'))
layout.editbar_links = []
return {
'layout': layout,
'title': self.title,
'form': form,
'form_width': 'large'
}
def finalize(self):
self.clear()
return morepath.redirect(self.request.link(self.context))
def modal_process_delete(context, request):
if not context.delete_view_enabled:
raise HTTPNotFound()
context.model.delete()
return morepath.redirect(
request.link(context.collection_ui, "+modal-close"))
def root_default(self, request):
return morepath.redirect('/customers')
def create(self, request, appstruct):
policy = Policy(**appstruct)
request.db_session.add(policy)
request.db_session.flush()
return redirect(request.link(policy))
def view_default_assistant(self, request):
return morepath.redirect(request.link(self.assistant))
def process_profile(context, request):
userinfo_f = userinfo_form(request)
password_f = password_form(request)
controls = list(request.POST.items())
controls_dict = dict(controls)
active_form = controls_dict['__formid__']
user = context.model
attributes_f = attributes_form(user, request)
failed = False
if active_form == 'userinfo-form':
try:
data = userinfo_f.validate(controls)
except deform.ValidationFailure as e:
failed = True
userinfo_f = e
userdata = userinfo_f.field.schema.serialize(user.data.as_dict())
for k in userdata.keys():
if userinfo_f.cstruct[k] is not colander.null:
userdata[k] = userinfo_f.cstruct[k]
userinfo_f.field.cstruct = userdata
if not failed:
updatedata = {}
for f in ['email']:
updatedata[f] = data[f]
user.update(updatedata)
if not failed:
request.notify('success', 'Profile updated',
'Your profile have been successfully updated')
return morepath.redirect(request.url)
elif active_form == 'password-form':
try:
data = password_f.validate(controls)
except deform.ValidationFailure as e:
failed = True
password_f = e
if not failed:
if not user.validate(data['password_current']):
exc = colander.Invalid(password_f, 'Invalid password')
password_f.widget.handle_error(password_f, exc)
failed = True
if not failed:
try:
user.change_password(data['password_current'],
data['password'])
except morpfw.authn.pas.exc.InvalidPasswordError as e:
exc = colander.Invalid(password_f, 'Invalid password')
password_f.widget.handle_error(password_f, exc)
failed = True
if not failed:
request.notify('success', 'Password changed',
'Your password have been successfully changed')
return morepath.redirect(request.url)
elif active_form == 'personalinfo-form':
try:
data = attributes_f.validate(controls)
except deform.ValidationFailure as e:
failed = True
attributes_f = e
if not failed:
xattrprovider = user.xattrprovider()
xattrprovider.update(data)
request.notify('success', 'Profile updated',
'Your profile have been successfully updated')
return morepath.redirect(request.url)
else:
request.notify('error', 'Unknown form',
'Invalid form identifier was supplied')
return morepath.redirect(request.url)
has_photo = user.get_blob('profile-photo')
return {
'page_title':
'Personal Settings',
'profile_photo':
request.link(context, '+download?field=profile-photo')
if has_photo else None,
'forms': [{
'form_title':
'Personal Information',
'form':
attributes_f,
'readonly':
False,
'form_data':
user['xattrs'] if active_form != 'personalinfo-form' else None
}, {
'form_title':
'User Information',
'form':
userinfo_f,
'readonly':
False,
'form_data':
user.data.as_dict() if active_form != 'userinfo-form' else None
}, {
'form_title': 'Password',
'form': password_f,
'readonly': False,
}]
}
def root_default(self, request):
return redirect('/documents')
def publish_issue(self, request, form):
""" Publish an issue.
This moves all accepted notices related to this issue to the published
state (if not already) and generates the PDF. The publication numbers are
assigned during PDF creation.
This view is only visible by a publisher.
"""
layout = Layout(self, request)
if not layout.publishing:
return {
'layout': layout,
'title': self.name,
'subtitle': _("Publish"),
'callout': _("Publishing is disabled."),
'show_form': False
}
if self.notices('submitted').first():
request.message(
_("There are submitted notices for this issue!"), 'warning'
)
if self.pdf:
request.message(
_("A PDF already exists for this issue!"), 'warning'
)
old_numbers = self.publication_numbers()
if any(old_numbers.values()):
request.message(
_("There are already official notices with publication numbers!"),
'warning'
)
if form.submitted(request):
self.publish(request)
request.message(_("Issue published."), 'success')
new_numbers = self.publication_numbers()
if any(old_numbers.values()) and old_numbers != new_numbers:
request.message(
_(
"The already assigned publication numbers have been "
"changed. Recreating the following issues might be needed."
), 'warning'
)
return redirect(layout.manage_issues_link)
return {
'layout': layout,
'form': form,
'title': self.name,
'subtitle': _("Publish"),
'button_text': _("Publish"),
'cancel': layout.manage_issues_link,
'message': _(
(
'Do you really want to publish "${item}"? This will assign '
'the publication numbers to the official notices and create '
'the PDF.'
),
mapping={
'item': self.name,
'number': len(self.notices('accepted').all())
}
),
}
def create(self, request, appstruct):
page = Page(**appstruct)
request.db_session.add(page)
request.db_session.flush()
return redirect(request.link(page))
def modal_process_xattredit(context, request):
result = process_xattredit(context, request)
if isinstance(result, HTTPFound):
return morepath.redirect(request.link(context, "+modal-close"))
return result
def logout(self, request):
@request.after
def forget(response):
request.app.forget_identity(response, request)
return redirect('/')
def create(self, request, appstruct):
proposition_type = PropositionType(**appstruct)
request.db_session.add(proposition_type)
request.db_session.flush()
return redirect(request.link(proposition_type))
def default(self, request):
return morepath.redirect('/')
def reject_notice(self, request, form):
""" Reject a notice.
This view is used by the publishers to reject a submitted notice.
Only submitted notices may be rejected.
"""
layout = Layout(self, request)
if self.state != 'submitted':
return {
'layout': layout,
'title': self.title,
'subtitle': _("Reject Official Note"),
'callout': _("Only submitted official notices may be rejected."),
'show_form': False
}
if form.submitted(request):
self.reject(request, form.comment.data)
request.message(_("Official notice rejected."), 'success')
if self.user:
request.app.send_transactional_email(
subject=request.translate(
_("Official Notice Rejected ${id}",
mapping={'id': self.id})),
receivers=(self.user.username, ),
reply_to=request.app.mail['transactional']['sender'],
content=render_template(
'mail_notice_rejected.pt', request, {
'title':
request.translate(
_("Official Notice Rejected ${id}",
mapping={'id': self.id})),
'model':
self,
'comment':
form.comment.data,
'layout':
MailLayout(self, request),
'url':
request.link(self)
}))
return redirect(layout.dashboard_or_notices_link)
return {
'message':
_('Do you really want to reject "${item}"?',
mapping={'item': self.title}),
'layout':
layout,
'form':
form,
'title':
self.title,
'subtitle':
_("Reject Official Note"),
'button_text':
_("Reject Official Note"),
'button_class':
'alert',
'cancel':
request.link(self)
}
def view(self, request):
@request.after
def set_header(response):
response.headers.add('Foo', 'FOO')
return morepath.redirect('http://example.org')
def submit_notice(self, request, form):
""" Submit a notice.
This view is used by the editors to submit their drafts for the publishers
to review.
Only drafted notices may be submitted. Editors may only submit their own
notices (publishers may submit any notice).
If a notice has invalid/past issues or an invalid/inactive
category/organization, the user is redirected to the edit view.
"""
layout = Layout(self, request)
is_private = request.is_private(self)
if not is_private:
user_ids, group_ids = get_user_and_group(request)
if not ((self.group_id in group_ids) or (self.user_id in user_ids)):
raise HTTPForbidden()
if self.state != 'drafted' and self.state != 'rejected':
return {
'layout':
layout,
'title':
self.title,
'subtitle':
_("Submit Official Note"),
'callout':
_("Only drafted or rejected official notices may be submitted."),
'show_form':
False
}
if (self.expired_issues or (self.overdue_issues and not is_private)
or self.invalid_category or self.invalid_organization):
return redirect(request.link(self, name='edit'))
if form.submitted(request):
self.submit(request)
request.message(_("Official notice submitted."), 'success')
return redirect(layout.dashboard_or_notices_link)
return {
'message':
_('Do you really want to submit "${item}"?',
mapping={'item': self.title}),
'layout':
layout,
'form':
form,
'title':
self.title,
'subtitle':
_("Submit Official Note"),
'button_text':
_("Submit Official Note"),
'cancel':
request.link(self)
}
def logout(context, request):
@request.after
def forget(response):
request.app.forget_identity(response, request)
return morepath.redirect(request.relative_url('/'))
def get_oauth_login(self, _):
"""redirect to login URL on ekklesia ID server"""
return redirect(self.get_authorization_url())
def collection_index(context, request):
return morepath.redirect(
request.link(context, "+%s" % context.default_view))
def get_oauth_callback(self, _request):
self.fetch_token()
self.after_auth()
return redirect(self.back_url or "/")
def page_redirect(self, request):
lang = request.i18n.get_locale().language
url = request.class_link(Page, {'name': self.name, 'lang': lang})
return redirect(url)
def create(self, request, appstruct):
department = Department(**appstruct)
request.db_session.add(department)
request.db_session.flush()
return redirect(request.link(department))
def get_oauth_callback(self, _request):
self.fetch_token()
self.after_auth()
return redirect(self.redirect_after_success_url)
def update(self, request, appstruct):
self.update(**appstruct)
return redirect(request.link(self))
def model_index(context, request):
return morepath.redirect(
request.link(context, '+%s' % context.default_view))
def process_delete(context, request):
context.model.delete()
return morepath.redirect(request.link(context.collection_ui))
def edit(self, request):
if request.POST.get("submit"):
request.app.wiki.store_page(self.name, request.POST["content"])
return redirect(request.link(self))
elif request.POST.get("cancel"):
return redirect(request.link(Page("FrontPage")))
def index(self, request):
return redirect(request.link(Page("FrontPage")))
def modal_process_delete(context, request):
context.model.delete()
return morepath.redirect(
request.link(context.collection_ui, "+modal-close"))
def update(self, request, appstruct):
request.db_session.add(self)
self.update(**appstruct)
prop = request.q(Proposition).get({"id": appstruct["proposition_id"]})
return redirect(request.link(prop))
