def _process(self):
form = ParticipantsDisplayFormColumnsForm()
if form.validate_on_submit():
registration_settings.set_participant_list_columns(
self.event, form.json.data['columns'], self.regform)
flash(
_('The settings for "{}" have been saved.').format(
self.regform.title), 'success')
return jsonify_data()
available_fields = {
field.id: field
for field in self.regform.active_fields
}
enabled_fields = []
for field_id in registration_settings.get_participant_list_columns(
self.event, self.regform):
try:
field = available_fields[field_id]
except KeyError:
continue
enabled_fields.append(field)
del available_fields[field_id]
disabled_fields = available_fields.values()
return jsonify_template(
'events/registration/management/regform_display_form_columns.html',
form=form,
enabled_columns=enabled_fields,
disabled_columns=disabled_fields)
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(
to_unicode(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):
submitters = {abstract.submitter for abstract in self.abstracts}
abstract_persons = AbstractPersonLink.find_all(
AbstractPersonLink.abstract.has(self._membership_filter))
abstract_persons_dict = defaultdict(
lambda: {
'speaker': False,
'submitter': False,
'primary_author': False,
'secondary_author': False
})
for abstract_person in abstract_persons:
dict_key = abstract_person.person.user if abstract_person.person.user else abstract_person.person
person_roles = abstract_persons_dict[dict_key]
person_roles['speaker'] |= abstract_person.is_speaker
person_roles[
'primary_author'] |= abstract_person.author_type == AuthorType.primary
person_roles[
'secondary_author'] |= abstract_person.author_type == AuthorType.secondary
for submitter in submitters:
abstract_persons_dict[submitter]['submitter'] |= True
return jsonify_template(
'events/abstracts/management/abstract_person_list.html',
event_persons=abstract_persons_dict,
event=self.event)
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_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):
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):
tpl = get_template_module(
'events/registration/emails/invitation_default.html',
event=self.event)
form_cls = InvitationFormExisting if request.args.get(
'existing') == '1' else InvitationFormNew
defaults = FormDefaults(email_body=tpl.get_html_body(),
email_subject=tpl.get_subject())
form = form_cls(obj=defaults, regform=self.regform)
skip_moderation = form.skip_moderation.data if 'skip_moderation' in form else False
if form.validate_on_submit():
for user in form.users.data:
self._create_invitation(user, skip_moderation,
form.email_from.data,
form.email_subject.data,
form.email_body.data)
num = len(form.users.data)
flash(
ngettext("The invitation has been sent.",
"{n} invitations have been sent.", num).format(n=num),
'success')
return jsonify_data(
invitation_list=_render_invitation_list(self.regform))
return jsonify_template(
'events/registration/management/regform_invite.html',
regform=self.regform,
form=form)
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 _process(self):
contrib_form_class = make_contribution_form(self.event)
custom_field_values = {
'custom_{}'.format(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(), 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)
self.commit = False
return jsonify_template('events/contributions/forms/contribution.html',
form=form)
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 '{room.name}'"
.format(room=vc_room)), '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):
form_class = make_competences_form(self.event)
user_competences = self.event.cfp.user_competences
defaults = {
'competences_{}'.format(user_id): competences.competences
for user_id, competences in user_competences.iteritems()
}
form = form_class(obj=FormDefaults(defaults))
if form.validate_on_submit():
key_prefix = 'competences_'
form_data = {
int(key[len(key_prefix):]): value
for key, value in form.data.iteritems()
}
users = {
u.id: u
for u in User.query.filter(User.id.in_(form_data),
~User.is_deleted)
}
for user_id, competences in form_data.iteritems():
if user_id in user_competences:
update_competences(user_competences[user_id], competences)
elif competences:
create_competences(self.event, users[user_id], competences)
flash(_("Team competences were updated successfully"), 'success')
return jsonify_data()
return jsonify_template('events/papers/management/competences.html',
event=self.event,
form=form)
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]
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):
action = request.args.get('vc_room_action', '.manage_vc_rooms_create')
attach = request.args.get('attach', '')
return jsonify_template('vc/manage_event_select.html',
event=self.event,
vc_room_action=action,
plugins=get_vc_plugins().values(),
attach=attach)
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):
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_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 = 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):
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.event, **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):
custom_fields = self.event.contribution_fields.order_by(
ContributionField.position)
custom_field_types = sorted(get_contrib_field_types().values(),
key=attrgetter('friendly_name'))
return jsonify_template(
'events/contributions/management/fields_dialog.html',
event=self.event,
custom_fields=custom_fields,
custom_field_types=custom_field_types)
def _process(self):
form = CreateMultipleRegistrationsForm(regform=self.regform, open_add_user_dialog=(request.method == 'GET'),
notify_users=session.get('registration_notify_user_default', True))
if form.validate_on_submit():
session['registration_notify_user_default'] = form.notify_users.data
for user in form.user_principals.data:
self._register_user(user, form.notify_users.data)
return jsonify_data(**self.list_generator.render_list())
return jsonify_template('events/registration/management/registration_create_multiple.html', form=form)
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_GET(self):
query = (self.network_group.in_event_acls.join(Event).options(
contains_eager('event')).order_by(Event.title))
events = [principal.event for principal in query]
query = (self.network_group.in_category_acls.join(Category).order_by(
Category.title).options(contains_eager('category')))
categories = [principal.category for principal in query]
return jsonify_template('networks/delete_network.html',
network_group=self.network_group,
categories=categories,
events=events)
def _process(self):
form = AbstractReviewedForTracksForm(event=self.event,
obj=self.abstract)
if form.validate_on_submit():
update_reviewed_for_tracks(self.abstract,
form.reviewed_for_tracks.data)
return jsonify_data(flash=False,
html=render_abstract_page(
self.abstract, management=self.management))
return jsonify_template(
'events/abstracts/forms/edit_review_tracks.html', form=form)
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 = 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):
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):
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 = 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 _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(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))
