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):
f = request.files['logo']
try:
img = Image.open(f)
except IOError:
flash(_('You cannot upload this file as a logo.'), 'error')
return jsonify_data(content=None)
if img.format.lower() not in {'jpeg', 'png', 'gif'}:
flash(_('The file has an invalid format ({format})').format(format=img.format), 'error')
return jsonify_data(content=None)
if img.mode == 'CMYK':
flash(_('The logo you uploaded is using the CMYK colorspace and has been converted to RGB. Please check if '
'the colors are correct and convert it manually if necessary.'), 'warning')
img = img.convert('RGB')
image_bytes = BytesIO()
img.save(image_bytes, 'PNG')
image_bytes.seek(0)
content = image_bytes.read()
self.event.logo = content
self.event.logo_metadata = {
'hash': crc32(content),
'size': len(content),
'filename': os.path.splitext(secure_filename(f.filename, 'logo'))[0] + '.png',
'content_type': 'image/png'
}
flash(_('New logo saved'), 'success')
logger.info("New logo '%s' uploaded by %s (%s)", f.filename, session.user, self.event)
return jsonify_data(content=get_logo_data(self.event))
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):
self.event.stylesheet = None
self.event.stylesheet_metadata = None
layout_settings.set(self.event, 'use_custom_css', False)
flash(_('CSS file deleted'), 'success')
logger.info("CSS file for %s deleted by %s", self.event, session.user)
return jsonify_data(content=None)
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):
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):
if self.entry.type not in (MenuEntryType.user_link, MenuEntryType.page,
MenuEntryType.separator):
raise BadRequest('Menu entry of type {} cannot be deleted'.format(
self.entry.type.name))
position_gen = count(self.entry.position)
if self.entry.children:
for child in self.entry.children:
child.parent_id = self.entry.parent_id
child.position = next(position_gen)
with db.session.no_autoflush:
entries = (MenuEntry.query.with_parent(self.event).filter(
MenuEntry.parent_id == self.entry.parent_id,
MenuEntry.position >= self.entry.position,
MenuEntry.id != self.entry.id).order_by(
MenuEntry.position).all())
for entry in entries:
entry.position = next(position_gen)
db.session.delete(self.entry)
db.session.flush()
return jsonify_data(flash=False,
menu=_render_menu_entries(self.event,
connect_menu=True))
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):
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 = 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 = 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):
if not request.is_xhr:
return WPCategory.render_template(
'display/calendar.html',
self.category,
start_dt=request.args.get('start_dt'))
tz = self.category.display_tzinfo
start = tz.localize(dateutil.parser.parse(
request.args['start'])).astimezone(utc)
end = tz.localize(dateutil.parser.parse(
request.args['end'])).astimezone(utc)
query = (Event.query.filter(Event.starts_between(start, end),
Event.is_visible_in(self.category),
~Event.is_deleted).options(
load_only('id', 'title', 'start_dt',
'end_dt', 'category_id')))
events = self._get_event_data(query)
ongoing_events = (Event.query.filter(
Event.is_visible_in(self.category), Event.start_dt < start,
Event.end_dt > end).options(
load_only('id', 'title', 'start_dt', 'end_dt',
'timezone')).order_by(Event.title).all())
return jsonify_data(
flash=False,
events=events,
ongoing_event_count=len(ongoing_events),
ongoing_events_html=self._render_ongoing_events(ongoing_events))
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):
form = PaperSubmissionForm()
if form.validate_on_submit():
if self.paper is None:
paper = Paper(self.contribution)
create_paper_revision(paper, session.user, form.files.data)
return jsonify_data(flash=False)
else:
create_paper_revision(self.paper, session.user,
form.files.data)
return jsonify_data(flash=False,
html=render_paper_page(self.paper))
return jsonify_form(
form,
form_header_kwargs={'action': request.relative_url},
disable_if_locked=False)
def _process(self):
db.session.delete(self.request)
tpl = get_template_module(
'users/emails/registration_request_rejected.txt', req=self.request)
send_email(make_email(self.request.email, template=tpl))
flash(_('The request has been rejected.'), 'success')
return jsonify_data()
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):
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):
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):
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):
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):
db.session.delete(self.contrib_type)
db.session.flush()
self.event.log(EventLogRealm.management, EventLogKind.negative,
'Contributions',
'Deleted type: {}'.format(self.contrib_type.name),
session.user)
return jsonify_data(flash=False)
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_assignment(self, assign):
update_reviewing_roles(self.event, self.users, self.contributions,
self.role, assign)
if assign:
flash(_("Paper reviewing roles have been assigned."), 'success')
else:
flash(_("Paper reviewing roles have been unassigned."), 'success')
return jsonify_data(**self.list_generator.render_list())
def _process(self):
events_by_month = self.group_by_month(self.events)
tpl = get_template_module('categories/display/event_list.html')
html = tpl.event_list_block(events_by_month=events_by_month,
format_event_date=self.format_event_date,
is_recent=self.is_recent,
happening_now=self.happening_now)
return jsonify_data(flash=False, html=html)
def _process(self):
signals.event_management.image_deleted.send(self.image,
user=session.user)
db.session.delete(self.image)
flash(
_("The image '{}' has been deleted").format(self.image.filename),
'success')
return jsonify_data(image_list=_render_image_list(self.event))
def _process(self):
form = build_review_form(review=self.review)
if form.validate_on_submit():
update_review(self.review, **form.split_data)
return jsonify_data(flash=False,
html=render_paper_page(self.paper))
tpl = get_template_module('events/reviews/forms.html')
return jsonify(html=tpl.render_review_form(form, review=self.review))
def _process(self):
db.session.delete(self.text)
db.session.flush()
flash(_('Text item deleted'), 'success')
logger.info('Survey question %s deleted by %s', self.text,
session.user)
return jsonify_data(
questionnaire=_render_questionnaire_preview(self.text.survey))
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 = 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)
