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 = 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):
defaults = FormDefaults(
content_review_questions=self.event.cfp.content_review_questions,
layout_review_questions=self.event.cfp.layout_review_questions,
**paper_reviewing_settings.get_all(self.event))
form = PaperReviewingSettingsForm(event=self.event, obj=defaults)
if form.validate_on_submit():
data = form.data
content_review_questions = data.pop('content_review_questions',
None)
layout_review_questions = data.pop('layout_review_questions', None)
if content_review_questions is None:
content_review_questions = self.event.cfp.content_review_questions
if layout_review_questions is None:
layout_review_questions = self.event.cfp.layout_review_questions
self.event.paper_review_questions = content_review_questions + layout_review_questions
email_settings = data.pop('email_settings')
data.update(email_settings)
paper_reviewing_settings.set_multi(self.event, data)
flash(_("The reviewing settings were saved successfully"),
'success')
logger.info("Paper reviewing settings of %r updated by %r",
self.event, session.user)
return jsonify_data()
self.commit = False
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 = 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 = TrackForm(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 = 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 = TrackForm()
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 = 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 = 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 = 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):
current_event_settings = payment_event_settings.get_all(self.event)
defaults = FormDefaults(current_event_settings,
**payment_settings.get_all())
form = EventSettingsForm(prefix='payment-', obj=defaults)
if form.validate_on_submit():
payment_event_settings.set_multi(self.event, form.data)
flash(_('Settings saved'), 'success')
return jsonify_data()
return jsonify_form(form)
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):
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 = 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):
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):
settings = track_settings.get_all(self.event)
form = ProgramForm(obj=FormDefaults(**settings))
if form.validate_on_submit():
update_program(self.event, form.data)
flash(_("The program has been updated."))
return jsonify_data()
elif not form.is_submitted():
handle_legacy_description(form.program, settings, get_render_mode=itemgetter('program_render_mode'),
get_value=itemgetter('program'))
return jsonify_form(form)
def _process(self):
form = ContributionTypeForm(event=self.event, obj=self.contrib_type)
if form.validate_on_submit():
old_name = self.contrib_type.name
form.populate_obj(self.contrib_type)
db.session.flush()
self.event.log(EventLogRealm.management, EventLogKind.change,
'Contributions',
'Updated type: {}'.format(old_name), session.user)
return contribution_type_row(self.contrib_type)
return jsonify_form(form)
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 = AddTemplateForm()
if self.always_clonable:
del form.is_clonable
if form.validate_on_submit():
is_clonable = form.is_clonable.data if form.is_clonable else True
new_template = DesignerTemplate(title=form.title.data, type=form.type.data, is_clonable=is_clonable,
**self.target_dict)
flash(_("Added new template '{}'").format(new_template.title), 'success')
return jsonify_data(html=_render_template_list(self.target, event=self.event_or_none))
return jsonify_form(form, disabled_until_change=False)
def _process(self):
form = IPNetworkGroupForm()
if form.validate_on_submit():
network_group = IPNetworkGroup()
form.populate_obj(network_group)
db.session.add(network_group)
db.session.flush()
logger.info('Network group %s created by %s', network_group,
session.user)
return jsonify_data(flash=False)
return jsonify_form(form)
def _process(self):
self.commit = False
form = PosterPrintingForm(self.event, template=self.template_id)
if form.validate_on_submit():
data = dict(form.data)
template_id = data.pop('template')
key = unicode(uuid.uuid4())
poster_cache.set(key, data, time=1800)
download_url = url_for('.print_poster', self.event, template_id=template_id, uuid=key)
return jsonify_data(flash=False, redirect=download_url, redirect_no_loading=True)
return jsonify_form(form, disabled_until_change=False, back=_('Cancel'), submit=_('Download PDF'))
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 = 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 = AbstractsScheduleForm(obj=FormDefaults(**abstracts_settings.get_all(self.event)),
event=self.event)
if form.validate_on_submit():
rescheduled = self.event.cfa.start_dt is not None
schedule_cfa(self.event, **form.data)
if rescheduled:
flash(_("Call for abstracts has been rescheduled"), 'success')
else:
flash(_("Call for abstracts has been scheduled"), 'success')
return jsonify_data(flash=False)
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):
form = ContributionTypeForm(event=self.event)
if form.validate_on_submit():
contrib_type = ContributionType()
form.populate_obj(contrib_type)
self.event.contribution_types.append(contrib_type)
db.session.flush()
self.event.log(EventLogRealm.management, EventLogKind.positive,
'Contributions',
'Added type: {}'.format(contrib_type.name),
session.user)
return contribution_type_row(contrib_type)
return jsonify_form(form)
def _process(self):
form = NewsForm(obj=self.item)
if form.validate_on_submit():
old_title = self.item.title
form.populate_obj(self.item)
db.session.flush()
get_recent_news.clear_cached()
logger.info('News %r modified by %s', self.item, session.user)
flash(
_("News '{title}' has been updated").format(title=old_title),
'success')
return jsonify_data(flash=False)
return jsonify_form(form)
def _process(self):
form = PapersScheduleForm(
obj=FormDefaults(**paper_reviewing_settings.get_all(self.event)),
event=self.event)
if form.validate_on_submit():
rescheduled = self.event.cfp.start_dt is not None
schedule_cfp(self.event, **form.data)
if rescheduled:
flash(_("Call for papers has been rescheduled"), 'success')
else:
flash(_("Call for papers has been scheduled"), 'success')
return jsonify_data(html=_render_paper_dashboard(self.event))
return jsonify_form(form)
def _process(self):
settings = abstracts_settings.get_all(self.event)
form = AbstractSubmissionSettingsForm(event=self.event,
obj=FormDefaults(**settings))
if form.validate_on_submit():
abstracts_settings.set_multi(self.event, form.data)
flash(_('Abstract submission settings have been saved'), 'success')
return jsonify_data()
elif not form.is_submitted():
handle_legacy_description(form.announcement, settings,
get_render_mode=itemgetter('announcement_render_mode'),
get_value=itemgetter('announcement'))
return jsonify_form(form)
