def _process(self):
form = SubContributionForm(event=self.event)
if form.validate_on_submit():
subcontrib = create_subcontribution(self.contrib, form.data)
flash(_("Subcontribution '{}' created successfully").format(subcontrib.title), 'success')
return jsonify_data(html=_render_subcontribution_list(self.contrib))
return jsonify_template('events/contributions/forms/subcontribution.html', form=form)
def _process(self):
form = TextForm()
if form.validate_on_submit():
add_survey_text(self.section, form.data)
flash(_('Text item added'), 'success')
return jsonify_data(questionnaire=_render_questionnaire_preview(self.survey))
return jsonify_template('forms/form_common_fields_first.html', form=form)
def _process(self):
cfp = self.event.cfp
form_data = {
'managers': cfp.managers,
'judges': cfp.judges,
'content_reviewers': cfp.content_reviewers,
'layout_reviewers': cfp.layout_reviewers
}
form = PaperTeamsForm(event=self.event, **form_data)
if form.validate_on_submit():
teams = {
'managers': form.managers.data,
'judges': form.judges.data
}
if cfp.content_reviewing_enabled:
teams['content_reviewers'] = form.content_reviewers.data
if cfp.layout_reviewing_enabled:
teams['layout_reviewers'] = form.layout_reviewers.data
unassigned_contribs = update_team_members(self.event, **teams)
flash(_("The members of the teams were updated successfully"), 'success')
if unassigned_contribs:
flash(ngettext("Users have been removed from 1 contribution",
"Users have been removed from {} contributions",
len(unassigned_contribs)).format(len(unassigned_contribs)),
'warning')
return jsonify_data()
return jsonify_template('events/papers/management/teams.html', form=form)
def _process(self):
endpoints = {'create': 'abstracts.create_reviewing_question', 'edit': 'abstracts.edit_reviewing_question',
'delete': 'abstracts.delete_reviewing_question', 'sort': 'abstracts.sort_reviewing_questions'}
return jsonify_template('events/reviewing_questions_management.html', event=self.event,
reviewing_questions=self.event.abstract_review_questions,
field_types=get_reviewing_field_types('abstracts'), endpoints=endpoints,
common_url_args={})
def _process(self):
can_modify = bool(session.user) and self.plugin.can_be_modified(session.user, self.event_new)
plugin_settings = self.plugin.settings.get_all()
defaults = FormDefaults(self.plugin.event_settings.get_all(self.event_new), **plugin_settings)
form = self.plugin.event_settings_form(prefix="payment-", obj=defaults, plugin_settings=plugin_settings)
if can_modify and form.validate_on_submit():
self.plugin.event_settings.set_multi(self.event_new, form.data)
flash(_("Settings for {} saved").format(self.plugin.title), "success")
if self.protection_overridden:
return jsonify_data()
else:
return jsonify_data(plugin=self.plugin.name, enabled=form.enabled.data)
widget_attrs = {}
if not can_modify:
widget_attrs = {field.short_name: {"disabled": True} for field in form}
invalid_regforms = self.plugin.get_invalid_regforms(self.event_new)
return jsonify_template(
"events/payment/event_plugin_edit.html",
event=self.event_new,
form=form,
plugin=self.plugin,
can_modify=can_modify,
widget_attrs=widget_attrs,
invalid_regforms=invalid_regforms,
)
def _process(self):
defaults = FormDefaults(get_default_values(MenuEntry))
entry_type = request.args['type']
if entry_type == MenuEntryType.separator.name:
entry = MenuEntry(event_id=self._conf.id, 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_id=self._conf.id,
type=MenuEntryType[entry_type]
)
form.populate_obj(entry, skip={'html'})
if entry.is_page:
page = EventPage(html=form.html.data)
self._conf.as_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_template('events/layout/menu_entry_form.html', form=form)
def _process(self):
tpl_args = {'linked_object': self.object, 'linked_object_type': self.object_type,
'attachments': get_attached_items(self.object)}
if self.object_type in ('event', 'category'):
return self.wp.render_template('attachments.html', self._target, **tpl_args)
else:
return jsonify_template('attachments/attachments.html', **tpl_args)
def _process(self):
defaults = FormDefaults(self.attachment, protected=self.attachment.is_self_protected, skip_attrs={'file'})
if self.attachment.type == AttachmentType.file:
form = EditAttachmentFileForm(linked_object=self.object, obj=defaults, file=self.attachment)
else:
form = EditAttachmentLinkForm(linked_object=self.object, obj=defaults)
if form.validate_on_submit():
folder = form.folder.data or AttachmentFolder.get_or_create_default(linked_object=self.object)
logger.info('Attachment %s edited by %s', self.attachment, session.user)
form.populate_obj(self.attachment, skip={'acl', 'file'})
self.attachment.folder = folder
if self.attachment.is_self_protected:
# can't use `=` because of https://bitbucket.org/zzzeek/sqlalchemy/issues/3583
self.attachment.acl |= form.acl.data
self.attachment.acl &= form.acl.data
# files need special handling; links are already updated in `populate_obj`
if self.attachment.type == AttachmentType.file:
file = form.file.data['added']
if file:
self.attachment.file = AttachmentFile(user=session.user, content_type=file.mimetype,
filename=secure_filename(file.filename, 'attachment'))
self.attachment.file.save(file.stream)
signals.attachments.attachment_updated.send(self.attachment, user=session.user)
flash(_("The attachment \"{name}\" has been updated").format(name=self.attachment.title), 'success')
return jsonify_data(attachment_list=_render_attachment_list(self.object))
template = ('attachments/upload.html' if self.attachment.type == AttachmentType.file else
'attachments/add_link.html')
return jsonify_template(template, form=form, existing_attachment=self.attachment,
action=url_for('.modify_attachment', self.attachment),
protection_message=_render_protection_message(self.object),
folders_protection_info=_get_folders_protection_info(self.object))
def _render_form(self, users, action):
user_competences = self.event.cfp.user_competences
competences = {'competences_{}'.format(user_id): competences.competences
for user_id, competences in user_competences.iteritems()}
return jsonify_template('events/papers/assign_role.html', event=self.event, role=self.role.name,
action=action, users=users, competences=competences,
contribs=self.contributions)
def _process_GET(self):
list_config = self.list_generator.list_config
return jsonify_template('events/papers/paper_list_filter.html',
event=self.event,
static_items=self.list_generator.static_items,
filters=list_config['filters'],
visible_items=list_config['items'])
def _process(self):
form = TicketsForm(obj=self.regform, event=self.event)
if form.validate_on_submit():
form.populate_obj(self.regform)
db.session.flush()
return jsonify_data(flash=False, tickets_enabled=self.regform.tickets_enabled)
return jsonify_template('events/registration/management/regform_tickets.html', regform=self.regform, form=form)
def _process(self):
form = SessionProtectionForm(obj=FormDefaults(**self._get_defaults()), session=self.session,
prefix='session-protection-')
if form.validate_on_submit():
update_permissions(self.session, form)
update_session(self.session, {'protection_mode': form.protection_mode.data})
return jsonify_data(flash=False, html=_render_session_list(self.event))
return jsonify_template('events/management/protection_dialog.html', form=form)
def _process_GET(self):
list_config = self.list_generator._get_config()
return jsonify_template('events/abstracts/management/abstract_list_filter.html',
visible_items=list_config['items'],
static_items=self.list_generator.static_items,
extra_filters=self.list_generator.extra_filters,
contrib_fields=self.list_generator.get_all_contribution_fields(),
filters=list_config['filters'])
def _process(self):
form = SubContributionForm(obj=FormDefaults(self.subcontrib), event=self.event_new, subcontrib=self.subcontrib)
if form.validate_on_submit():
update_subcontribution(self.subcontrib, form.data)
flash(_("Subcontribution '{}' updated successfully").format(self.subcontrib.title), 'success')
return jsonify_data(html=_render_subcontribution_list(self.contrib))
self.commit = False
return jsonify_template('events/contributions/forms/subcontribution.html', form=form)
def _process(self):
form = ContributionProtectionForm(obj=FormDefaults(**self._get_defaults()), contrib=self.contrib,
prefix='contribution-protection-')
if form.validate_on_submit():
update_permissions(self.contrib, form)
update_contribution(self.contrib, {'protection_mode': form.protection_mode.data})
return jsonify_data(flash=False, **self.list_generator.render_list(self.contrib))
return jsonify_template('events/management/protection_dialog.html', form=form)
def _process_GET(self):
reg_list_config = self.list_generator._get_config()
return jsonify_template('events/registration/management/reglist_filter.html',
regform=self.regform,
RegistrationFormItemType=RegistrationFormItemType,
visible_items=reg_list_config['items'],
static_items=self.list_generator.static_items,
filters=reg_list_config['filters'])
def _process(self):
inherited_templates = [tpl for tpl in get_inherited_templates(self.target)
if not tpl.backside_template and tpl.type == TemplateType.badge]
custom_templates = [tpl for tpl in self.target.designer_templates
if not tpl.backside_template and tpl != self.template and tpl.type == TemplateType.badge]
return jsonify_template('designer/backside_list.html', target=self.target, custom_templates=custom_templates,
inherited_templates=inherited_templates, current_template=self.template,
width=int(request.args['width']), height=int(request.args['height']))
def _process(self):
tpl_args = {'linked_object': self.object, 'linked_object_type': self.object_type,
'attachments': get_attached_items(self.object)}
if self.object_type == 'event':
return self.wp.render_template('attachments.html', self._target, **tpl_args)
elif self.object_type == 'category' and not request.is_xhr:
return self.wp.render_template('management/attachments.html', self.category, 'attachments', **tpl_args)
else:
return jsonify_template('attachments/attachments.html', **tpl_args)
def _process(self):
form = TextForm(obj=FormDefaults(self.text))
if form.validate_on_submit():
form.populate_obj(self.text)
db.session.flush()
flash(_('Text item updated'), 'success')
logger.info('Survey text item {} modified by {}'.format(self.text, session.user))
return jsonify_data(questionnaire=_render_questionnaire_preview(self.survey))
return jsonify_template('events/surveys/management/edit_survey_item.html', form=form)
def _process(self):
defaults = FormDefaults(self.event, update_timetable=True)
form = EventDatesForm(obj=defaults, event=self.event)
if form.validate_on_submit():
with track_time_changes():
update_event(self.event, **form.data)
return self.jsonify_success()
show_screen_dates = form.has_displayed_dates and (form.start_dt_override.data or form.end_dt_override.data)
return jsonify_template('events/management/event_dates.html', form=form, show_screen_dates=show_screen_dates)
def _process(self):
form = AddAttachmentLinkForm(linked_object=self.object)
if form.validate_on_submit():
add_attachment_link(form.data, self.object)
flash(_("The link has been added"), 'success')
return jsonify_data(attachment_list=_render_attachment_list(self.object))
return jsonify_template('attachments/add_link.html', form=form,
protection_message=_render_protection_message(self.object),
folders_protection_info=_get_folders_protection_info(self.object))
def _process(self):
is_submitted = 'confirmed' in request.form
if not is_submitted:
return jsonify_template('events/management/delete_events.html', events=self.events)
for ev in self.events[:]:
ev.delete('Bulk-deleted by category manager', session.user)
flash(ngettext('You have deleted one event', 'You have deleted {} events', len(self.events))
.format(len(self.events)), 'success')
return jsonify_data(flash=False, redirect=url_for('.manage_content', self.category))
def _process(self):
if 'confirmed' in request.form:
for subcategory in self.subcategories:
if not subcategory.is_empty:
raise BadRequest('Category "{}" is not empty'.format(subcategory.title))
delete_category(subcategory)
return jsonify_data(flash=False, is_empty=self.category.is_empty)
return jsonify_template('categories/management/delete_categories.html', categories=self.subcategories,
category_ids=[x.id for x in self.subcategories])
def _process(self):
form = TextForm(obj=FormDefaults(self.text))
if form.validate_on_submit():
form.populate_obj(self.text)
db.session.flush()
flash(_('Text item updated'), 'success')
logger.info('Survey text item %s modified by %s', self.text, session.user)
return jsonify_data(questionnaire=_render_questionnaire_preview(self.survey))
return jsonify_template('forms/form_common_fields_first.html', form=form)
def _process(self):
form = CreateEmailTemplateForm(event=self.event_new)
if form.validate_on_submit():
new_tpl = build_default_email_template(self.event_new, form.default_tpl.data)
form.populate_obj(new_tpl)
self.event_new.abstract_email_templates.append(new_tpl)
db.session.flush()
return _render_notification_list(self.event_new)
return jsonify_template('events/abstracts/management/notification_tpl_form.html', form=form)
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_template('events/registration/management/regform_schedule.html', form=form)
def _process(self):
form = self.question.field.config_form(obj=FormDefaults(self.question, **self.question.field_data))
if form.validate_on_submit():
old_title = self.question.title
self.question.field.save_config(form)
db.session.flush()
flash(_('Question "{title}" updated').format(title=old_title), 'success')
logger.info('Survey question {} modified by {}'.format(self.question, session.user))
return jsonify_data(questionnaire=_render_questionnaire_preview(self.survey))
return jsonify_template('events/surveys/management/edit_survey_item.html', form=form)
def _process(self):
form = SurveyForm(event=self.event, obj=self._get_form_defaults())
if form.validate_on_submit():
form.populate_obj(self.survey)
db.session.flush()
flash(_('Survey modified'), 'success')
logger.info('Survey %s modified by %s', self.survey, session.user)
return jsonify_data(flash=False)
return jsonify_template('events/surveys/management/edit_survey.html', event=self.event, form=form,
survey=self.survey)
def _process(self):
abstract_form_class = make_abstract_form(self.event, session.user, management=self.management)
form = abstract_form_class(event=self.event)
if form.validate_on_submit():
abstract = create_abstract(self.event, *get_field_values(form.data), send_notifications=True)
flash(_("Your abstract '{}' has been successfully submitted. It is registered with the number "
"#{}. You will be notified by email with the submission details.")
.format(abstract.title, abstract.friendly_id), 'success')
return jsonify_data(flash=False, redirect=url_for('.call_for_abstracts', self.event))
return jsonify_template('events/abstracts/display/submission.html', event=self.event, form=form)
def _process(self):
form = self.question.field.create_config_form(obj=FormDefaults(self.question, **self.question.field_data))
if form.validate_on_submit():
old_title = self.question.title
self.question.field.update_object(form.data)
db.session.flush()
flash(_('Question "{title}" updated').format(title=old_title), 'success')
logger.info('Survey question %s modified by %s', self.question, session.user)
return jsonify_data(questionnaire=_render_questionnaire_preview(self.survey))
return jsonify_template('forms/form_common_fields_first.html', form=form)
def _process(self):
form = ReminderForm(event=self.event, schedule_type='relative')
if form.validate_on_submit():
reminder = EventReminder(creator=session.user, event=self.event)
form.populate_obj(reminder, existing_only=True)
db.session.add(reminder)
db.session.flush()
if form.schedule_type.data == 'now':
_send_reminder(reminder)
else:
logger.info('Reminder created by %s: %s', session.user,
reminder)
flash(
_("A reminder at {} has been created.").format(
format_datetime(reminder.scheduled_dt)), 'success')
return jsonify_data(flash=False)
return jsonify_template('events/reminders/edit_reminder.html',
event=self.event,
reminder=None,
form=form)
def _process(self):
form = ImportContributionsForm()
if form.validate_on_submit():
contributions, changes = import_contributions_from_csv(
self.event, form.source_file.data)
flash(
ngettext("{} contribution has been imported.",
"{} contributions have been imported.",
len(contributions)).format(len(contributions)),
'success')
if changes:
flash(_("Event dates/times adjusted due to imported data."),
'warning')
return jsonify_data(flash=False,
redirect=url_for('.manage_contributions',
self.event))
return jsonify_template(
'events/contributions/management/import_contributions.html',
form=form,
event=self.event)
def _process(self):
form = AddAttachmentFilesForm(linked_object=self.object)
if form.validate_on_submit():
files = form.files.data
folder = form.folder.data or AttachmentFolder.get_or_create_default(
linked_object=self.object)
for f in files:
filename = secure_filename(f.filename, 'attachment')
attachment = Attachment(
folder=folder,
user=session.user,
title=to_unicode(f.filename),
type=AttachmentType.file,
protection_mode=form.protection_mode.data)
if attachment.is_self_protected:
attachment.acl = form.acl.data
content_type = mimetypes.guess_type(
f.filename)[0] or f.mimetype or 'application/octet-stream'
attachment.file = AttachmentFile(user=session.user,
filename=filename,
content_type=content_type)
attachment.file.save(f.file)
db.session.add(attachment)
db.session.flush()
logger.info('Attachment %s uploaded by %s', attachment,
session.user)
signals.attachments.attachment_created.send(attachment,
user=session.user)
flash(
ngettext("The attachment has been uploaded",
"{count} attachments have been uploaded",
len(files)).format(count=len(files)), 'success')
return jsonify_data(
attachment_list=_render_attachment_list(self.object))
return jsonify_template(
'attachments/upload.html',
form=form,
action=url_for('.upload', self.object),
protection_message=_render_protection_message(self.object),
folders_protection_info=_get_folders_protection_info(self.object))
def _process(self):
recordings_xml = get_recordings(self.event_vc_room)
root = ET.fromstring(recordings_xml)
data = []
for rec in root.iter('recording'):
recording_data = {
'start_date':
datetime.fromtimestamp(
float(rec.find('startTime').text) /
1000).strftime('%Y-%M-%d %X'),
'end_date':
datetime.fromtimestamp(
float(rec.find('startTime').text) / 1000).strftime('%X'),
'state':
rec.find('state').text,
'record_id':
rec.find('recordID').text,
'participants':
rec.find('participants').text
}
for format in rec.iter('format'):
if format.find('type').text == 'presentation':
recording_data.update({
'url': format.find('url').text,
'length': format.find('length').text
})
previews = []
for image in format.iter('image'):
previews.append({
'src': image.text,
'alt': image.attrib['alt'],
'width': image.attrib['width'],
'height': image.attrib['height']
})
recording_data.update({'previews': previews})
data.append(recording_data)
return jsonify_template('list_recordings.html',
render_plugin_template,
recordings=data,
event_vc_room=self.event_vc_room)
def _process_form(self, form, **kwargs):
saved = False
if form.validate_on_submit():
note = EventNote.get_or_create(self.object)
is_new = note.id is None or note.is_deleted
is_restored = is_new and note.is_deleted
# TODO: get render mode from form data once it can be selected
note.create_revision(RenderMode.html, form.source.data,
session.user)
is_changed = attrs_changed(note, 'current_revision')
db.session.add(note)
db.session.flush()
if is_new:
if is_restored:
signals.event.notes.note_restored.send(note)
else:
signals.event.notes.note_added.send(note)
logger.info('Note %s created by %s', note, session.user)
self.event.log(EventLogRealm.participants,
EventLogKind.positive,
'Minutes',
'Added minutes',
session.user,
data=note.link_event_log_data)
elif is_changed:
signals.event.notes.note_modified.send(note)
logger.info('Note %s modified by %s', note, session.user)
self.event.log(EventLogRealm.participants,
EventLogKind.change,
'Minutes',
'Updated minutes',
session.user,
data=note.link_event_log_data)
saved = is_new or is_changed
return jsonify_template('events/notes/edit_note.html',
form=form,
object_type=self.object_type,
object=self.object,
saved=saved,
**kwargs)
def _process(self):
defaults = FormDefaults(self.plugin.get_vc_room_attach_form_defaults(self.event))
form = self.plugin.vc_room_attach_form(prefix='vc-', obj=defaults, event=self.event,
service=self.plugin.service_name)
if form.validate_on_submit():
vc_room = form.data['room']
if not self.plugin.can_manage_vc_rooms(session.user, self.event):
flash(_('You are not allowed to attach {plugin_name} rooms to this event.').format(
plugin_name=self.plugin.friendly_name), 'error')
elif not self.plugin.can_manage_vc_room(session.user, vc_room):
flash(_("You are not authorized to attach the room '{0}'").format(vc_room.name), 'error')
else:
event_vc_room = process_vc_room_association(self.plugin, self.event, vc_room, form)
if event_vc_room:
flash(_('The room has been attached to the event.'), 'success')
db.session.add(event_vc_room)
return jsonify_data(flash=False)
return jsonify_template('vc/attach_room.html', event=self.event, form=form,
skip_fields=form.conditional_fields | {'room'},
plugin=self.plugin)
def _process(self):
defaults = self._get_form_defaults(location_parent=self.session_block)
form = ContributionEntryForm(obj=defaults,
to_schedule=True,
**self._get_form_params())
if form.validate_on_submit():
with track_time_changes(auto_extend=True,
user=session.user) as changes:
contrib = create_contribution(self.event_new,
form.data,
session_block=self.session_block,
extend_parent=True)
entry = contrib.timetable_entry
notifications = get_time_changes_notifications(
changes, tzinfo=self.event_new.tzinfo, entry=entry)
return jsonify_data(entries=[serialize_entry_update(entry)],
notifications=notifications,
flash=False)
self.commit = False
return jsonify_template('events/contributions/forms/contribution.html',
form=form,
fields=form._display_fields)
def _process(self):
form = TimetablePDFExportForm(formdata=request.args, csrf_enabled=False)
if form.validate_on_submit():
form_data = form.data_for_format
pdf_format = TimetablePDFFormat(form_data)
if not form.advanced.data:
pdf_class = SimplifiedTimeTablePlain
additional_params = {}
else:
pdf_class = TimeTablePlain
additional_params = {'firstPageNumber': form.firstPageNumber.data,
'showSpeakerAffiliation': form_data['showSpeakerAffiliation'],
'showSessionDescription': form_data['showSessionDescription']}
if request.args.get('download') == '1':
pdf = pdf_class(self.event_new, session.user, sortingCrit=None, ttPDFFormat=pdf_format,
pagesize=form.pagesize.data, fontsize=form.fontsize.data, **additional_params)
return send_file('timetable.pdf', BytesIO(pdf.getPDFBin()), 'application/pdf')
else:
url = url_for(request.endpoint, **dict(request.view_args, download='1', **request.args.to_dict(False)))
return jsonify_data(flash=False, redirect=url, redirect_no_loading=True)
return jsonify_template('events/timetable/timetable_pdf_export.html', form=form,
back_url=url_for('.timetable', self.event_new))
def _process(self):
form = ImportRegistrationsForm(regform=self.regform)
if form.validate_on_submit():
registrations = import_registrations_from_csv(
self.regform,
form.source_file.data,
skip_moderation=form.skip_moderation.data,
notify_users=form.notify_users.data)
flash(
ngettext("{} registration has been imported.",
"{} registrations have been imported.",
len(registrations)).format(len(registrations)),
'success')
return jsonify_data(flash=False,
redirect=url_for('.manage_reglist',
self.regform),
redirect_no_loading=True)
return jsonify_template(
'events/registration/management/import_registrations.html',
form=form,
regform=self.regform)
def _process(self):
if not request.is_xhr:
return redirect(url_for_index(_anchor=f'create-event:{self.event_type.name}'))
form_cls = LectureCreationForm if self.event_type == EventType.lecture else EventCreationForm
form = form_cls(obj=self._get_form_defaults(), prefix='event-creation-')
if form.validate_on_submit():
if self.event_type == EventType.lecture:
events = self._create_series(form.data)
event = events[0]
if len(events) > 1:
flash(Markup(render_template('events/series_created_msg.html', events=events)), 'info')
notify_event_creation(event, occurrences=events)
else:
event = self._create_event(form.data)
notify_event_creation(event)
return jsonify_data(flash=False, redirect=url_for('event_management.settings', event))
check_room_availability = rb_check_user_access(session.user) and config.ENABLE_ROOMBOOKING
rb_excluded_categories = [c.id for c in rb_settings.get('excluded_categories')]
return jsonify_template('events/forms/event_creation_form.html', form=form, fields=form._field_order,
event_type=self.event_type.name, single_category=(not self.root_category.has_children),
check_room_availability=check_room_availability,
rb_excluded_categories=rb_excluded_categories)
def _process(self):
form = AdminAccountRegistrationForm()
if form.validate_on_submit():
data = form.data
if data.pop('create_identity', False):
identity = Identity(provider='indico',
identifier=data.pop('username'),
password=data.pop('password'))
else:
identity = None
data.pop('username', None)
data.pop('password', None)
user = create_user(data.pop('email'),
data,
identity,
from_moderation=True)
msg = Markup('{} <a href="{}">{}</a>').format(
escape(_('The account has been created.')),
url_for('users.user_profile', user), escape(_('Show details')))
flash(msg, 'success')
return jsonify_data()
return jsonify_template('users/users_admin_create.html', form=form)
def _process(self):
step = int(request.form.get('step', 1))
tpl_args = {}
form = self._form_for_step(step, set_defaults=True)
prev_form = self._form_for_step(step - 1)
if prev_form and not prev_form.validate():
form = prev_form
step = step - 1
if step == 4:
tpl_args.update({
'step_title': dict(CLONE_REPEAT_CHOICES)[request.form['repeatability']],
})
elif step > 4:
# last step - perform actual cloning
form = REPEAT_FORM_MAP[request.form['repeatability']](self.event)
if form.validate_on_submit():
if form.repeatability.data == 'once':
dates = [form.start_dt.data]
else:
clone_calculator = get_clone_calculator(form.repeatability.data, self.event)
dates = clone_calculator.calculate(request.form)[0]
clones = [clone_event(self.event, start_dt, set(form.selected_items.data), form.category.data)
for start_dt in dates]
if len(clones) == 1:
flash(_('Welcome to your cloned event!'), 'success')
return jsonify_data(redirect=url_for('event_management.settings', clones[0]), flash=False)
else:
flash(_('{} new events created.').format(len(dates)), 'success')
return jsonify_data(redirect=form.category.data.url, flash=False)
else:
# back to step 4, since there's been an error
step = 4
dependencies = {c.name: {'requires': list(c.requires_deep), 'required_by': list(c.required_by_deep)}
for c in EventCloner.get_cloners(self.event)}
return jsonify_template('events/management/clone_event.html', event=self.event, step=step, form=form,
cloner_dependencies=dependencies, **tpl_args)
def _process(self):
can_modify = bool(session.user) and self.plugin.can_be_modified(
session.user, self.event)
plugin_settings = self.plugin.settings.get_all()
plugin_event_settings = self.plugin.event_settings.get_all(self.event)
defaults = FormDefaults(
{
k: v
for k, v in plugin_event_settings.iteritems() if v is not None
}, **plugin_settings)
form = self.plugin.event_settings_form(prefix='payment-',
obj=defaults,
plugin_settings=plugin_settings)
if can_modify and form.validate_on_submit():
self.plugin.event_settings.set_multi(self.event, form.data)
flash(
_('Settings for {} saved').format(self.plugin.title),
'success')
if self.protection_overridden:
return jsonify_data()
else:
return jsonify_data(plugin=self.plugin.name,
enabled=form.enabled.data)
widget_attrs = {}
if not can_modify:
widget_attrs = {
field.short_name: {
'disabled': True
}
for field in form
}
invalid_regforms = self.plugin.get_invalid_regforms(self.event)
return jsonify_template('events/payment/event_plugin_edit.html',
event=self.event,
form=form,
plugin=self.plugin,
can_modify=can_modify,
widget_attrs=widget_attrs,
invalid_regforms=invalid_regforms)
def _process_POST(self):
original_url = self._make_absolute_url(request.args['original_url'])
shortcut = request.form['shortcut'].strip()
if not (set(shortcut) <= CUSTOM_SHORTCUT_ALPHABET):
raise BadRequest('Invalid shortcut')
result = register_shortcut(original_url, shortcut, session.user)
if result.get('error'):
kwargs = {'success': False, 'msg': self._get_error_msg(result)}
else:
kwargs = {'success': True, 'shorturl': result['short_url']}
return jsonify_template('ursh_custom_shortener_page.html',
render_plugin_template,
event=self.event,
ursh_host=self.ursh_host,
shortcut=shortcut,
original_url=original_url,
submitted=True,
**kwargs)
def _process(self):
defaults = FormDefaults(self.folder,
protected=self.folder.is_self_protected)
form = AttachmentFolderForm(obj=defaults, linked_object=self.object)
if form.validate_on_submit():
form.populate_obj(self.folder, skip={'acl'})
if self.folder.is_self_protected:
# can't use `=` because of https://bitbucket.org/zzzeek/sqlalchemy/issues/3583
self.folder.acl |= form.acl.data
self.folder.acl &= form.acl.data
logger.info('Folder %s edited by %s', self.folder, session.user)
signals.attachments.folder_updated.send(self.folder,
user=session.user)
flash(
_("Folder \"{name}\" updated").format(name=self.folder.title),
'success')
return jsonify_data(
attachment_list=_render_attachment_list(self.object))
return jsonify_template('attachments/create_folder.html',
form=form,
protection_message=_render_protection_message(
self.object))
def _process(self):
form = MeetingSessionBlockForm(
obj=FormDefaults(**self._get_form_defaults()),
event=self.event,
session_block=self.session_block)
if form.validate_on_submit():
session_data = {
k[8:]: v
for k, v in form.data.items() if k in form.session_fields
}
block_data = {
k[6:]: v
for k, v in form.data.items() if k in form.block_fields
}
update_session(self.session, session_data)
with track_location_changes():
update_session_block(self.session_block, block_data)
return jsonify_data(flash=False)
self.commit = False
return jsonify_template('events/forms/session_block_form.html',
form=form,
block=self.session_block)
def _process(self):
paper_persons_dict = {}
for p in self.event.acl_entries:
user = p.principal
is_judge = p.has_management_role('paper_judge', explicit=True)
is_content_reviewer = (self.event.cfp.content_reviewing_enabled
and p.has_management_role(
'paper_content_reviewer',
explicit=True))
is_layout_reviewer = (self.event.cfp.layout_reviewing_enabled
and p.has_management_role(
'paper_layout_reviewer', explicit=True))
if is_judge or is_content_reviewer or is_layout_reviewer:
paper_persons_dict[user] = {
'judge': is_judge,
'content_reviewer': is_content_reviewer,
'layout_reviewer': is_layout_reviewer
}
return jsonify_template(
'events/papers/management/paper_person_list.html',
event_persons=paper_persons_dict,
event=self.event)
def _process(self):
all_templates = set(self.event.designer_templates) | get_inherited_templates(self.event)
badge_templates = {tpl.id: {
'data': tpl.data,
'backside_tpl_id': tpl.backside_template_id,
'orientation': 'landscape' if tpl.data['width'] > tpl.data['height'] else 'portrait',
'format': self._get_format(tpl)
} for tpl in all_templates if tpl.type.name == 'badge'}
settings = event_badge_settings.get_all(self.event.id)
form = BadgeSettingsForm(self.event, template=self.template_id, tickets=self.TICKET_BADGES, **settings)
all_registrations = self.registrations or self.regform.registrations
registrations = self._filter_registrations(all_registrations)
if self.event.is_locked:
del form.save_values
if form.validate_on_submit():
data = form.data
if data['page_layout'] == PageLayout.foldable:
data['top_margin'] = 0
data['bottom_margin'] = 0
data['left_margin'] = 0
data['right_margin'] = 0
data['margin_columns'] = 0
data['margin_rows'] = 0
data['dashed_border'] = False
data.pop('submitted', None)
template_id = data.pop('template')
if data.pop('save_values', False):
event_badge_settings.set_multi(self.event, data)
data['registration_ids'] = [x.id for x in registrations]
key = unicode(uuid.uuid4())
badge_cache.set(key, data, time=1800)
download_url = url_for('.registrations_print_badges', self.regform, template_id=template_id, uuid=key)
return jsonify_data(flash=False, redirect=download_url, redirect_no_loading=True)
return jsonify_template('events/registration/management/print_badges.html', event=self.event,
regform=self.regform, settings_form=form, templates=badge_templates,
registrations=registrations, all_registrations=all_registrations)
def _process(self):
inherited_location = self.event.location_data
inherited_location['inheriting'] = True
contrib_form_class = make_contribution_form(self.event)
form = contrib_form_class(
obj=FormDefaults(location_data=inherited_location),
event=self.event)
if form.validate_on_submit():
# Create empty contribution so it can be compared to the new one in flash_if_unregistered
contrib = Contribution()
with flash_if_unregistered(self.event,
lambda: contrib.person_links):
contrib = create_contribution(self.event,
*get_field_values(form.data))
flash(
_("Contribution '{}' created successfully").format(
contrib.title), 'success')
tpl_components = self.list_generator.render_list(contrib)
if tpl_components['hide_contrib']:
self.list_generator.flash_info_message(contrib)
return jsonify_data(**tpl_components)
return jsonify_template('events/contributions/forms/contribution.html',
form=form)
def _process(self):
allow_reschedule_start = self.survey.state in (
SurveyState.ready_to_open, SurveyState.active_and_clean,
SurveyState.finished)
form = ScheduleSurveyForm(
obj=self._get_form_defaults(),
survey=self.survey,
allow_reschedule_start=allow_reschedule_start)
if form.validate_on_submit():
if allow_reschedule_start:
self.survey.start_dt = form.start_dt.data
if getattr(form, 'resend_start_notification', False):
self.survey.start_notification_sent = not form.resend_start_notification.data
self.survey.end_dt = form.end_dt.data
flash(_('Survey was scheduled'), 'success')
logger.info('Survey {} scheduled by {}'.format(
self.survey, session.user))
return jsonify_data(flash=False)
disabled_fields = ('start_dt', ) if not allow_reschedule_start else ()
return jsonify_template(
'events/surveys/management/schedule_survey.html',
form=form,
disabled_fields=disabled_fields)
def _process(self):
tpl = get_template_module(
'events/registration/emails/custom_email_default.html')
default_body = tpl.get_html_body()
registration_ids = request.form.getlist('registration_id')
form = EmailRegistrantsForm(
body=default_body,
regform=self.regform,
registration_id=registration_ids,
recipients=[x.email for x in self.registrations])
if not self.regform.tickets_enabled:
del form.attach_ticket
if form.validate_on_submit():
self._send_emails(form)
num_emails_sent = len(self.registrations)
flash(
ngettext("The email was sent.", "{num} emails were sent.",
num_emails_sent).format(num=num_emails_sent),
'success')
return jsonify_data()
return jsonify_template('events/registration/management/email.html',
form=form,
regform=self.regform)
def _process(self):
form = AddAttachmentLinkForm(linked_object=self.object)
if form.validate_on_submit():
folder = form.folder.data or AttachmentFolder.get_or_create_default(
linked_object=self.object)
link = Attachment(user=session.user, type=AttachmentType.link)
form.populate_obj(link, skip={'acl'})
if link.is_protected:
link.acl = form.acl.data
link.folder = folder
db.session.flush()
logger.info('Attachment {} added by {}'.format(link, session.user))
signals.attachments.attachment_created.send(link,
user=session.user)
flash(_("The link has been added"), 'success')
return jsonify_data(
attachment_list=_render_attachment_list(self.object))
return jsonify_template(
'attachments/add_link.html',
form=form,
protection_message=_render_protection_message(self.object),
folders_protection_info=_get_folders_protection_info(self.object))
def _process(self):
badge_templates = sorted((tpl
for tpl in get_all_templates(self.event_new)
if tpl.type.name == 'badge'),
key=attrgetter('title'))
settings = event_badge_settings.get_all(self.event_new.id)
form = BadgeSettingsForm(self.event_new,
template=self.template_id,
**settings)
registrations = self.registrations or self.regform.registrations
if self.event_new.is_locked:
del form.save_values
if form.validate_on_submit():
data = form.data
data.pop('submitted', None)
template_id = data.pop('template')
if data.pop('save_values', False):
event_badge_settings.set_multi(self.event_new, data)
data['registration_ids'] = [x.id for x in registrations]
key = unicode(uuid.uuid4())
badge_cache.set(key, data, time=1800)
download_url = url_for('.registrations_print_badges',
self.regform,
template_id=template_id,
uuid=key)
return jsonify_data(flash=False,
redirect=download_url,
redirect_no_loading=True)
return jsonify_template(
'events/registration/management/print_badges.html',
event=self.event_new,
regform=self.regform,
settings_form=form,
templates=badge_templates,
registrations=registrations)
def _process(self):
contrib_form_class = make_contribution_form(self.event)
custom_field_values = {
f'custom_{x.contribution_field_id}': x.data
for x in self.contrib.field_values
}
parent_session_block = (
self.contrib.timetable_entry.parent.session_block if
(self.contrib.timetable_entry
and self.contrib.timetable_entry.parent) else None)
form = contrib_form_class(obj=FormDefaults(
self.contrib,
start_date=self.contrib.start_dt,
**custom_field_values),
event=self.event,
contrib=self.contrib,
session_block=parent_session_block)
if form.validate_on_submit():
with (track_time_changes(), track_location_changes(),
flash_if_unregistered(self.event,
lambda: self.contrib.person_links)):
update_contribution(self.contrib, *get_field_values(form.data))
flash(
_("Contribution '{}' successfully updated").format(
self.contrib.title), 'success')
tpl_components = self.list_generator.render_list(self.contrib)
if tpl_components['hide_contrib']:
self.list_generator.flash_info_message(self.contrib)
return jsonify_data(flash=(request.args.get('flash') == '1'),
**tpl_components)
elif not form.is_submitted():
handle_legacy_description(form.description, self.contrib)
can_manage = self.contrib.can_manage(session.user)
self.commit = False
return jsonify_template('events/contributions/forms/contribution.html',
form=form,
can_manage=can_manage)
def _process(self):
defaults = FormDefaults(self.chatroom)
for name in EditChatroomForm.event_specific_fields:
defaults[name] = getattr(self.event_chatroom, name)
form = EditChatroomForm(obj=defaults)
if form.validate_on_submit():
form.populate_obj(self.event_chatroom,
fields=form.event_specific_fields)
form.populate_obj(self.chatroom, skip=form.event_specific_fields)
self.chatroom.modified_dt = now_utc()
if attrs_changed(self.chatroom, 'name', 'description', 'password'):
update_room(self.chatroom)
notify_modified(self.chatroom, self.event, session.user)
flash(_('Chatroom updated'), 'success')
self.event.log(EventLogRealm.management, EventLogKind.change,
'Chat',
'Chatroom updated: {}'.format(self.chatroom.name),
session.user)
return jsonify_data(flash=False)
return jsonify_template('manage_event_edit.html',
render_plugin_template,
form=form,
event=self.event,
event_chatroom=self.event_chatroom)
def _process(self):
try:
field_cls = get_field_types()[request.view_args['type']]
except KeyError:
raise NotFound
form = field_cls.create_config_form()
try:
clone_id = int(request.args['clone'])
except (KeyError, ValueError):
pass
else:
try:
question_to_clone = SurveyQuestion.query.with_parent(self.survey).filter_by(id=clone_id).one()
form = question_to_clone.field.create_config_form(
obj=FormDefaults(question_to_clone, **question_to_clone.field.copy_field_data()))
except NoResultFound:
pass
if form.validate_on_submit():
question = add_survey_question(self.section, field_cls, form.data)
flash(_('Question "{title}" added').format(title=question.title), 'success')
return jsonify_data(questionnaire=_render_questionnaire_preview(self.survey))
return jsonify_template('forms/form_common_fields_first.html', form=form)
def _process(self):
reminder = self.reminder
form = ReminderForm(obj=self._get_defaults(), event=self.event)
if form.validate_on_submit():
if reminder.is_sent:
flash(
_("This reminder has already been sent and cannot be modified anymore."
), 'error')
return redirect(url_for('.edit', reminder))
form.populate_obj(reminder, existing_only=True)
if form.schedule_type.data == 'now':
_send_reminder(reminder)
else:
logger.info('Reminder modified by %s: %s', session.user,
reminder)
flash(
_("The reminder at {} has been modified.").format(
format_datetime(reminder.scheduled_dt)), 'success')
return jsonify_data(flash=False)
return jsonify_template('events/reminders/edit_reminder.html',
event=self.event,
reminder=reminder,
form=form)
def _process(self):
form = ImportMembersCSVForm()
if form.validate_on_submit():
new_members, users, unknown_emails = self.import_members_from_csv(form.source_file.data)
if form.remove_existing.data:
deleted_members = self.role.members - users
for member in deleted_members:
self.logger.info(f'User {member} removed from role {self.role} by {session.user}')
self.role.members = users
else:
self.role.members |= users
for user in new_members:
self.logger.info(f'User {user} added to role {self.role} by {session.user}')
flash(ngettext("{} member has been imported.",
"{} members have been imported.",
len(users)).format(len(users)), 'success')
if unknown_emails:
flash(ngettext("There is no user with this email address: {}",
"There are no users with these email addresses: {}",
len(unknown_emails)).format(', '.join(unknown_emails)), 'warning')
tpl = get_template_module('events/roles/_roles.html')
return jsonify_data(html=tpl.render_role(self.role, collapsed=False, email_button=False))
return jsonify_template('events/roles/import_members.html', form=form, role=self.role)
def _process(self):
step = int(request.form.get('step', 1))
form = self._form_for_step(step, set_defaults=True)
prev_form = self._form_for_step(step - 1)
if prev_form and not prev_form.validate():
form = prev_form
step = step - 1
elif step > 2:
# last step - perform actual cloning
form = ImportContentsForm(self.source_event, self.event)
if form.validate_on_submit():
updated_event = clone_into_event(self.source_event, self.event, set(form.selected_items.data))
flash(_('Import successful!'), 'success')
return jsonify_data(redirect=url_for('event_management.settings', updated_event), flash=False)
else:
# back to step 2, since there's been an error
step = 2
dependencies = {c.name: {'requires': list(c.requires_deep), 'required_by': list(c.required_by_deep)}
for c in EventCloner.get_cloners(self.event)}
return jsonify_template('events/management/import_event.html', event=self.event, step=step, form=form,
cloner_dependencies=dependencies)
def _process_GET(self):
return jsonify_template(
'events/contributions/contrib_list_filter.html',
filters=self.list_generator.list_config['filters'],
static_items=self.list_generator.static_items)
