def _process(self):
defaults = FormDefaults(get_default_values(MenuEntry))
entry_type = request.args['type']
if entry_type == MenuEntryType.separator.name:
entry = MenuEntry(event=self.event, type=MenuEntryType.separator)
db.session.add(entry)
db.session.flush()
return jsonify_data(flash=False, entry=_render_menu_entry(entry))
elif entry_type == MenuEntryType.user_link.name:
form_cls = MenuLinkForm
elif entry_type == MenuEntryType.page.name:
form_cls = MenuPageForm
else:
raise BadRequest
form = form_cls(obj=defaults)
if form.validate_on_submit():
entry = MenuEntry(event=self.event, type=MenuEntryType[entry_type])
form.populate_obj(entry, skip={'html'})
if entry.is_page:
page = EventPage(html=form.html.data)
self.event.custom_pages.append(page)
entry.page = page
db.session.add(entry)
db.session.flush()
return jsonify_data(entry=_render_menu_entry(entry))
return jsonify_form(form)
def _process(self):
form = PaperTemplateForm()
if form.validate_on_submit():
template = create_paper_template(self.event, form.data)
flash(_('Paper template "{}" added.').format(template.name), 'success')
return _render_teplate_list(self.event)
return jsonify_form(form, form_header_kwargs={'action': request.relative_url})
def _process(self):
item = self.entry.object
entry_dt = self.entry.start_dt.astimezone(self.event_new.tzinfo)
form = BaseEntryForm(obj=FormDefaults(item, time=entry_dt.time()), day=entry_dt.date(),
event=self.event_new, entry=self.entry,
session_block=self.entry.parent.object if self.entry.parent else None)
data = form.data
shift_later = data.pop('shift_later')
updated_entries = []
if form.validate_on_submit():
with track_time_changes(auto_extend=True, user=session.user) as changes:
if shift_later:
new_end_dt = form.start_dt.data + form.duration.data
shift = new_end_dt - self.entry.end_dt
updated_entries += shift_following_entries(self.entry, shift, session_=self.session)
if self.entry.contribution:
update_timetable_entry(self.entry, {'start_dt': form.start_dt.data})
update_contribution(item, {'duration': form.duration.data})
elif self.entry.break_:
update_break_entry(item, data)
elif self.entry.session_block:
update_session_block(item, data)
notifications = get_time_changes_notifications(changes, tzinfo=self.event_new.tzinfo, entry=self.entry)
updated_entries.append(item.timetable_entry)
return jsonify_data(entries=[serialize_entry_update(entry) for entry in updated_entries], flash=False,
shift_later=shift_later, notifications=notifications)
self.commit = False
return jsonify_form(form, back_button=False, disabled_until_change=True)
def _process(self):
form = ReferenceTypeForm()
if form.validate_on_submit():
reference_type = create_reference_type(form.data)
flash(_("External ID type '{}' created successfully").format(reference_type.name), 'success')
return jsonify_data(html=_render_reference_type_list())
return jsonify_form(form)
def _process(self):
form = ReferenceTypeForm(obj=FormDefaults(self.reference_type), reference_type=self.reference_type)
if form.validate_on_submit():
update_reference_type(self.reference_type, form.data)
flash(_("External ID type '{}' successfully updated").format(self.reference_type.name), 'success')
return jsonify_data(html=_render_reference_type_list())
return jsonify_form(form)
def _process(self):
form = EventKeywordsForm(obj=self.event_new)
if form.validate_on_submit():
update_event(self.event_new, form.data)
flash(_('The keywords for the event have been updated'))
return jsonify_data(html=Markup('<br>').join(self.event_new.keywords))
return jsonify_form(form)
def _process(self):
description_settings = abstracts_settings.get(self.event, 'description_settings')
form = AbstractContentSettingsForm(obj=FormDefaults(description_settings))
if form.validate_on_submit():
abstracts_settings.set(self.event, 'description_settings', form.data)
return jsonify_data(flash=False)
return jsonify_form(form)
def _process(self):
form = TrackForm(event=self.event, obj=self.track)
if form.validate_on_submit():
update_track(self.track, form.data)
flash(_('Track "{}" has been modified.').format(self.track.title), 'success')
return jsonify_data(html=_render_track_list(self.event))
return jsonify_form(form)
def _process(self):
form = ContributionStartDateForm(obj=FormDefaults(start_dt=self.contrib.start_dt), contrib=self.contrib)
if form.validate_on_submit():
with track_time_changes():
update_timetable_entry(self.contrib.timetable_entry, {'start_dt': form.start_dt.data})
return jsonify_data(new_value=format_datetime(self.contrib.start_dt, 'short'))
return jsonify_form(form, back_button=False, disabled_until_change=True)
def _process(self):
defaults = FormDefaults(obj=self.question, **self.question.field_data)
form = self.question.field.create_config_form(obj=defaults)
if form.validate_on_submit():
update_reviewing_question(self.question, form)
return jsonify_data(flash=False)
return jsonify_form(form, fields=getattr(form, '_order', None))
def _process(self):
form = ContributionDurationForm(obj=FormDefaults(self.contrib), contrib=self.contrib)
if form.validate_on_submit():
with track_time_changes():
update_contribution(self.contrib, {'duration': form.duration.data})
return jsonify_data(new_value=format_human_timedelta(self.contrib.duration))
return jsonify_form(form, back_button=False, disabled_until_change=True)
def _process(self):
form = CreateCategoryForm()
if form.validate_on_submit():
new_category = create_category(self.category, form.data)
flash(_('Category "{}" has been created.').format(new_category.title), 'success')
return jsonify_data(flash=False, redirect=url_for('.manage_settings', new_category))
return jsonify_form(form)
def _process(self):
form = ContributionDefaultDurationForm(duration=contribution_settings.get(self.event, 'default_duration'))
if form.validate_on_submit():
contribution_settings.set(self.event, 'default_duration', form.duration.data)
flash(_("Default contribution duration was changed successfully"))
return jsonify_data()
return jsonify_form(form)
def _process(self):
form = IPNetworkGroupForm(obj=self.network_group)
if form.validate_on_submit():
form.populate_obj(self.network_group)
logger.info('Network group %s edited by %s', self.network_group, session.user)
return jsonify_data(flash=False)
return jsonify_form(form)
def _process(self):
form = EventPersonForm(obj=FormDefaults(self.person, skip_attrs={'title'}, title=self.person._title))
if form.validate_on_submit():
update_person(self.person, form.data)
person_data = self.get_persons()[self.person.email or self.person.id]
tpl = get_template_module('events/persons/management/_person_list_row.html')
return jsonify_data(html=tpl.render_person_row(person_data))
return jsonify_form(form)
def _process(self):
form = PaperTemplateForm(template=self.template, obj=FormDefaults(self.template, template=self.template))
if form.validate_on_submit():
old_name = self.template.name
update_paper_template(self.template, form.data)
flash(_('Paper template "{}" updated.').format(old_name), 'success')
return _render_teplate_list(self.event)
return jsonify_form(form, form_header_kwargs={'action': request.relative_url})
def _process(self):
form = ReportErrorForm(email=(session.user.email if session.user else ''))
if form.validate_on_submit():
self._send_email(form.email.data, form.comment.data)
if config.SENTRY_DSN and self.error_data['sentry_event_id'] is not None:
self._send_sentry(form.email.data, form.comment.data)
return jsonify_data(flash=False)
return jsonify_form(form)
def _process(self):
reg_managers = {p.principal for p in self.event.acl_entries
if p.has_management_role('registration', explicit=True)}
form = RegistrationManagersForm(obj=FormDefaults(managers=reg_managers))
if form.validate_on_submit():
update_object_principals(self.event, form.managers.data, role='registration')
return jsonify_data(flash=False)
return jsonify_form(form)
def _process(self):
form = TrackForm(event=self.event)
if form.validate_on_submit():
track = create_track(self.event, form.data)
flash(_('Track "{}" has been created.').format(track.title), 'success')
return jsonify_data(html=_render_track_list(self.event), new_track_id=track.id,
tracks=[{'id': t.id, 'title': t.title} for t in self.event.tracks])
return jsonify_form(form)
def _process(self):
form = EventPersonLinkForm(obj=self.event_new, event=self.event_new, event_type=self.event_new.type)
if form.validate_on_submit():
update_event(self.event_new, form.data)
tpl = get_template_module('events/management/_event_person_links.html')
return jsonify_data(html=tpl.render_event_person_links(self.event_new.type, self.event_new.person_links))
self.commit = False
return jsonify_form(form)
def _process(self):
form = self.field_cls.create_config_form()
if form.validate_on_submit():
new_question = create_reviewing_question(self.event, AbstractReviewQuestion, self.field_cls, form)
self.event.abstract_review_questions.append(new_question)
logger.info("Abstract reviewing question %r created by %r", new_question, session.user)
return jsonify_data(flash=False)
return jsonify_form(form, fields=getattr(form, '_order', None))
def _process(self):
form = NewsSettingsForm(obj=FormDefaults(**news_settings.get_all()))
if form.validate_on_submit():
news_settings.set_multi(form.data)
get_recent_news.clear_cached()
flash(_('Settings have been saved'), 'success')
return jsonify_data()
return jsonify_form(form)
def _process(self):
form = EventLocationForm(obj=self.event_new)
if form.validate_on_submit():
update_event(self.event_new, form.data)
flash(_('The location for the event has been updated'))
tpl = get_template_module('events/management/_event_location.html')
return jsonify_data(html=tpl.render_event_location_info(self.event_new.location_data))
return jsonify_form(form)
def _process(self):
form = BOASettingsForm(obj=FormDefaults(**boa_settings.get_all(self.event)))
if form.validate_on_submit():
boa_settings.set_multi(self.event, form.data)
clear_boa_cache(self.event)
flash(_('Book of Abstract settings have been saved'), 'success')
return jsonify_data()
return jsonify_form(form)
def _process(self):
form = EventReferencesForm(obj=FormDefaults(references=self.event_new.references))
if form.validate_on_submit():
create_event_references(event=self.event_new, data=form.data)
flash(_('External IDs saved'), 'success')
tpl = get_template_module('events/management/_reference_list.html')
return jsonify_data(html=tpl.render_event_references_list(self.event_new.references))
return jsonify_form(form)
def _process(self):
tpl = get_template_module('events/surveys/emails/survey_link_email.html', event=self.event)
form = InvitationForm(body=tpl.get_html_body(), subject=tpl.get_subject(), event=self.event)
if form.validate_on_submit():
self._send_emails(form, form.recipients.data)
num = len(form.recipients.data)
flash(ngettext('Your email has been sent.', '{} emails have been sent.', num).format(num))
return jsonify_data(flash=True)
return jsonify_form(form)
def _process(self):
current_event_settings = event_settings.get_all(self.event_new)
defaults = FormDefaults(current_event_settings, **settings.get_all())
form = EventSettingsForm(prefix="payment-", obj=defaults)
if form.validate_on_submit():
event_settings.set_multi(self.event_new, form.data)
flash(_("Settings saved"), "success")
return jsonify_data()
return jsonify_form(form)
def _process(self):
form = self.field_cls.create_config_form()
if form.validate_on_submit():
new_question = create_reviewing_question(self.event, PaperReviewQuestion, self.field_cls, form,
{'type': PaperReviewType[self.review_type]})
self.event.paper_review_questions.append(new_question)
logger.info("Reviewing question %r created by %r", new_question, session.user)
return jsonify_data(flash=False)
return jsonify_form(form, fields=getattr(form, '_order', None))
def _process(self):
form = RegistrationFormScheduleForm(obj=FormDefaults(self.regform), regform=self.regform)
if form.validate_on_submit():
self.regform.start_dt = form.start_dt.data
self.regform.end_dt = form.end_dt.data
flash(_("Registrations for {} have been scheduled").format(self.regform.title), 'success')
logger.info("Registrations for %s scheduled by %s", self.regform, session.user)
return jsonify_data(flash=False)
return jsonify_form(form, submit=_('Schedule'))
def _process(self):
inherited_location = self.event.location_data
inherited_location['inheriting'] = True
form = SessionForm(obj=FormDefaults(colors=get_random_color(self.event), location_data=inherited_location),
event=self.event)
if form.validate_on_submit():
new_session = create_session(self.event, form.data)
return self._get_response(new_session)
return jsonify_form(form)
def _process(self):
form = SessionForm(obj=self.session, event=self.event)
if form.validate_on_submit():
update_session(self.session, form.data)
return jsonify_data(html=_render_session_list(self.event))
return jsonify_form(form)
def _process(self):
form = None
parent_session_block = self.entry.parent.object if self.entry.parent else None
if self.entry.contribution:
contrib = self.entry.contribution
tt_entry_dt = self.entry.start_dt.astimezone(self.event.tzinfo)
form = ContributionEntryForm(obj=FormDefaults(
contrib, time=tt_entry_dt.time()),
event=self.event,
contrib=contrib,
to_schedule=False,
day=tt_entry_dt.date(),
session_block=parent_session_block)
if form.validate_on_submit():
with track_time_changes(auto_extend=True,
user=session.user) as changes:
with flash_if_unregistered(self.event,
lambda: contrib.person_links):
update_contribution(contrib,
*get_field_values(form.data))
notifications = get_time_changes_notifications(
changes, tzinfo=self.event.tzinfo, entry=self.entry)
return jsonify_data(update=serialize_entry_update(
self.entry, session_=self.session),
notifications=notifications)
elif not form.is_submitted():
handle_legacy_description(form.description, contrib)
return jsonify_template(
'events/contributions/forms/contribution.html',
form=form,
fields=form._display_fields)
elif self.entry.break_:
break_ = self.entry.break_
tt_entry_dt = self.entry.start_dt.astimezone(self.event.tzinfo)
form = BreakEntryForm(obj=FormDefaults(break_,
time=tt_entry_dt.time()),
event=self.event,
day=tt_entry_dt.date(),
session_block=parent_session_block)
if form.validate_on_submit():
with track_time_changes(auto_extend=True,
user=session.user) as changes:
update_break_entry(break_, form.data)
notifications = get_time_changes_notifications(
changes, tzinfo=self.event.tzinfo, entry=self.entry)
return jsonify_data(update=serialize_entry_update(
self.entry, session_=self.session),
notifications=notifications,
flash=False)
elif self.entry.session_block:
if self.edit_session:
session_ = self.entry.session_block.session
form = SessionForm(obj=FormDefaults(session_),
event=self.event)
if form.validate_on_submit():
update_session(session_, form.data)
return jsonify_data(update=serialize_entry_update(
self.entry, session_=self.session),
flash=False)
else:
block = self.entry.session_block
tt_entry_dt = self.entry.start_dt.astimezone(self.event.tzinfo)
form = SessionBlockEntryForm(obj=FormDefaults(
block, time=tt_entry_dt.time()),
event=self.event,
session_block=block,
to_schedule=False,
day=tt_entry_dt.date())
if form.validate_on_submit():
with track_time_changes(auto_extend=True,
user=session.user) as changes:
update_session_block(block, form.data)
notifications = get_time_changes_notifications(
changes, tzinfo=self.event.tzinfo, entry=self.entry)
return jsonify_data(update=serialize_entry_update(
self.entry, session_=self.session),
notifications=notifications,
flash=False)
self.commit = False
return jsonify_form(form,
fields=getattr(form, '_display_fields', None))
def render_form(self, form):
return jsonify_form(form, footer_align_right=True)
def _process(self):
form = AdminUserSettingsForm(obj=FormDefaults(**user_management_settings.get_all()))
if form.validate_on_submit():
user_management_settings.set_multi(form.data)
return jsonify_data(flash=False)
return jsonify_form(form)
def _process(self):
form = TrackGroupForm()
if form.validate_on_submit():
create_track_group(self.event, form.data)
return jsonify_data(html=_render_track_list(self.event))
return jsonify_form(form)
def _process(self):
roles = {}
event_permissions = event_permissions_schema.dump(self.event).get(
'acl_entries', {})
roles['global'] = self._map_event_to_track_permissions(
event_permissions)
tracks = Track.query.with_parent(self.event).options(
subqueryload('acl_entries'))
tracks_by_id = {str(track.id): track for track in tracks}
for track in tracks:
roles[str(track.id)] = track_permissions_schema.dump(track).get(
'acl_entries', {})
form = AbstractReviewingRolesForm(event=self.event,
obj=FormDefaults(roles=roles))
if form.validate_on_submit():
role_data = form.data['roles']
# Update global permissions
global_conveners = []
global_reviewers = []
global_roles = role_data.pop('global')
for identifier, permissions in global_roles:
principal = principal_from_identifier(
identifier,
allow_groups=True,
allow_event_roles=True,
allow_category_roles=True,
event_id=self.event.id)
if 'convene' in permissions:
global_conveners.append(principal)
if 'review' in permissions:
global_reviewers.append(principal)
update_object_principals(self.event,
global_conveners,
permission='convene_all_abstracts')
update_object_principals(self.event,
global_reviewers,
permission='review_all_abstracts')
# Update track specific permissions
track_conveners = []
track_reviewers = []
for (track_id, track_roles) in role_data.items():
acl_entries = {}
for identifier, permissions in track_roles:
principal = principal_from_identifier(
identifier,
allow_groups=True,
allow_event_roles=True,
allow_category_roles=True,
event_id=self.event.id)
acl_entries[principal] = set(permissions)
if 'convene' in permissions:
track_conveners.append(principal)
if 'review' in permissions:
track_reviewers.append(principal)
track = tracks_by_id[track_id]
current = {
e.principal: get_unified_permissions(e)
for e in track.acl_entries
}
update_principals_permissions(track, current, acl_entries)
# Update event ACL for track and global permissions
all_conveners = set(global_conveners + track_conveners)
all_reviewers = set(global_reviewers + track_reviewers)
update_object_principals(self.event,
all_conveners,
permission='track_convener')
update_object_principals(self.event,
all_reviewers,
permission='abstract_reviewer')
flash(_("Abstract reviewing roles have been updated."), 'success')
logger.info(
"Abstract reviewing roles of %s have been updated by %s",
self.event, session.user)
return jsonify_data()
return jsonify_form(form,
skip_labels=True,
form_header_kwargs={'id': 'reviewing-role-form'},
disabled_until_change=False)
