def _process_POST(self):
f = request.files[self.IMAGE_TYPE]
try:
img = Image.open(f)
except IOError:
flash(_('You cannot upload this file as an icon/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 image 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')
img = self._resize(img)
image_bytes = BytesIO()
img.save(image_bytes, 'PNG')
image_bytes.seek(0)
content = image_bytes.read()
metadata = {
'hash': crc32(content),
'size': len(content),
'filename': os.path.splitext(secure_filename(f.filename, self.IMAGE_TYPE))[0] + '.png',
'content_type': 'image/png'
}
self._set_image(content, metadata)
flash(self.SAVED_FLASH_MSG, 'success')
logger.info("New {} '%s' uploaded by %s (%s)".format(self.IMAGE_TYPE), f.filename, session.user, self.category)
return jsonify_data(content=get_image_data(self.IMAGE_TYPE, self.category))
def _process(self):
f = request.files["file"]
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=_logo_data(self.event))
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):
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):
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 = 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):
form = None
parent_session_block = self.entry.parent.object if self.entry.parent else None
if self.entry.contribution:
contrib = self.entry.contribution
tt_entry_dt = self.entry.start_dt.astimezone(self.event_new.tzinfo)
form = ContributionEntryForm(obj=FormDefaults(contrib, time=tt_entry_dt.time()),
event=self.event_new, contrib=contrib, to_schedule=False,
day=tt_entry_dt.date(), session_block=parent_session_block)
if form.validate_on_submit():
with track_time_changes(auto_extend=True, user=session.user) as changes:
with flash_if_unregistered(self.event_new, lambda: contrib.person_links):
update_contribution(contrib, *get_field_values(form.data))
notifications = get_time_changes_notifications(changes, tzinfo=self.event_new.tzinfo, entry=self.entry)
return jsonify_data(update=serialize_entry_update(self.entry, session_=self.session),
notifications=notifications)
elif not form.is_submitted():
handle_legacy_description(form.description, contrib)
return jsonify_template('events/contributions/forms/contribution.html', form=form,
fields=form._display_fields)
elif self.entry.break_:
break_ = self.entry.break_
tt_entry_dt = self.entry.start_dt.astimezone(self.event_new.tzinfo)
form = BreakEntryForm(obj=FormDefaults(break_, time=tt_entry_dt.time()), event=self.event_new,
day=tt_entry_dt.date(), session_block=parent_session_block)
if form.validate_on_submit():
with track_time_changes(auto_extend=True, user=session.user) as changes:
update_break_entry(break_, form.data)
notifications = get_time_changes_notifications(changes, tzinfo=self.event_new.tzinfo, entry=self.entry)
return jsonify_data(update=serialize_entry_update(self.entry, session_=self.session),
notifications=notifications, flash=False)
elif self.entry.session_block:
if self.edit_session:
session_ = self.entry.session_block.session
form = SessionForm(obj=FormDefaults(session_), event=self.event_new)
if form.validate_on_submit():
update_session(session_, form.data)
return jsonify_data(update=serialize_entry_update(self.entry, session_=self.session), flash=False)
else:
block = self.entry.session_block
tt_entry_dt = self.entry.start_dt.astimezone(self.event_new.tzinfo)
form = SessionBlockEntryForm(obj=FormDefaults(block, time=tt_entry_dt.time()),
event=self.event_new, session_block=block, to_schedule=False,
day=tt_entry_dt.date())
if form.validate_on_submit():
with track_time_changes(auto_extend=True, user=session.user) as changes:
update_session_block(block, form.data)
notifications = get_time_changes_notifications(changes, tzinfo=self.event_new.tzinfo,
entry=self.entry)
return jsonify_data(update=serialize_entry_update(self.entry, session_=self.session),
notifications=notifications, flash=False)
self.commit = False
return jsonify_form(form, fields=getattr(form, '_display_fields', None))
def _process(self):
user, identity = register_user(self.request.email, self.request.extra_emails, self.request.user_data,
self.request.identity_data, self.request.settings)
tpl = get_template_module('users/emails/registration_request_accepted.txt', user=user)
send_email(make_email(self.request.email, template=tpl))
flash(_('The request has been approved.'), 'success')
return jsonify_data()
def _process(self):
form = EventKeywordsForm(obj=self.event_new)
if form.validate_on_submit():
update_event(self.event_new, form.data)
flash(_('The keywords for the event have been updated'))
return jsonify_data(html=Markup('<br>').join(self.event_new.keywords))
return jsonify_form(form)
def _process(self):
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):
files = request.files.getlist('image')
num = 0
for f in files:
filename = secure_filename(f.filename, 'image')
data = BytesIO()
shutil.copyfileobj(f, data)
data.seek(0)
try:
image_type = Image.open(data).format.lower()
except IOError:
# Invalid image data
continue
data.seek(0)
# XXX: mpo is basically JPEG and JPEGs from some cameras are (wrongfully) detected as mpo
if image_type == 'mpo':
image_type = 'jpeg'
elif image_type not in {'jpeg', 'gif', 'png'}:
flash(_("The image '{name}' has an invalid type ({type}); only JPG, GIF and PNG are allowed.")
.format(name=f.filename, type=image_type), 'error')
continue
content_type = 'image/' + image_type
image = ImageFile(event=self.event, filename=filename, content_type=content_type)
image.save(data)
num += 1
db.session.flush()
logger.info('Image %s uploaded by %s', image, session.user)
signals.event_management.image_created.send(image, user=session.user)
flash(ngettext("The image has been uploaded", "{count} images have been uploaded", num)
.format(count=len(files)), 'success')
return jsonify_data(image_list=_render_image_list(self.event))
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):
position = request.form.get('position')
try:
position = int(position)
except (TypeError, ValueError):
position = None
parent_id = request.form.get('parent_id')
try:
parent_id = int(parent_id)
except (TypeError, ValueError):
parent_id = None
if parent_id != self.entry.parent_id:
if self.entry.type not in {MenuEntryType.user_link, MenuEntryType.page}:
raise BadRequest('Menu entry "{0}" cannot be moved to another menu: Invalid type "{0.type.name}".'
.format(self.entry))
if self.entry.is_root and self.entry.children:
raise BadRequest('Menu entry "{0}" cannot be moved to another menu: Entry has nested entries.'
.format(self.entry))
if parent_id is not None:
parent_entry = MenuEntry.find_first(MenuEntry.type.in_({MenuEntryType.user_link, MenuEntryType.page}),
id=parent_id, parent_id=None, event_id=self.entry.event_id)
if not parent_entry:
raise BadRequest('New parent entry not found for Menu entry "{0}".'.format(self.entry))
self.entry.insert(parent_id, position)
else:
self.entry.move(position)
return jsonify_data(flash=False)
def _process_POST(self):
self.serializer = TimetableSerializer(True)
with track_time_changes(auto_extend=True, user=session.user) as changes:
entry_data = self._move_entry(request.json)
rv = dict(serialize_entry_update(self.entry), **entry_data)
notifications = get_time_changes_notifications(changes, tzinfo=self.event_new.tzinfo, entry=self.entry)
return jsonify_data(flash=False, entry=rv, notifications=notifications)
def _process(self):
files = request.files.getlist("image")
for f in files:
filename = secure_filename(f.filename, "image")
data = BytesIO()
shutil.copyfileobj(f, data)
data.seek(0)
try:
image_type = Image.open(data).format.lower()
except IOError:
# Invalid image data
continue
data.seek(0)
if image_type not in {"jpeg", "gif", "png"}:
continue
content_type = "image/" + image_type
image = ImageFile(event_new=self.event_new, filename=filename, content_type=content_type)
image.save(data)
db.session.flush()
logger.info("Image %s uploaded by %s", image, session.user)
signals.event_management.image_created.send(image, user=session.user)
flash(
ngettext("The image has been uploaded", "{count} images have been uploaded", len(files)).format(
count=len(files)
),
"success",
)
return jsonify_data(image_list=_render_image_list(self.event_new))
def _process(self):
files = request.files.getlist('file')
for f in files:
filename = secure_filename(f.filename, 'image')
data = BytesIO()
shutil.copyfileobj(f, data)
data.seek(0)
try:
image_type = Image.open(data).format.lower()
except IOError:
# Invalid image data
continue
data.seek(0)
if image_type not in {'jpeg', 'gif', 'png'}:
continue
content_type = 'image/' + image_type
image = ImageFile(event_id=self._conf.id, filename=filename, content_type=content_type)
image.save(data)
db.session.add(image)
db.session.flush()
logger.info('Image {} uploaded by {}'.format(image, session.user))
signals.event_management.image_created.send(image, user=session.user)
flash(ngettext("The image has been uploaded", "{count} images have been uploaded", len(files))
.format(count=len(files)), 'success')
return jsonify_data(image_list=_render_image_list(self._conf))
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):
item = self.entry.object
entry_dt = self.entry.start_dt.astimezone(self.event_new.tzinfo)
form = BaseEntryForm(obj=FormDefaults(item, time=entry_dt.time()), day=entry_dt.date(),
event=self.event_new, entry=self.entry,
session_block=self.entry.parent.object if self.entry.parent else None)
data = form.data
shift_later = data.pop('shift_later')
updated_entries = []
if form.validate_on_submit():
with track_time_changes(auto_extend=True, user=session.user) as changes:
if shift_later:
new_end_dt = form.start_dt.data + form.duration.data
shift = new_end_dt - self.entry.end_dt
updated_entries += shift_following_entries(self.entry, shift, session_=self.session)
if self.entry.contribution:
update_timetable_entry(self.entry, {'start_dt': form.start_dt.data})
update_contribution(item, {'duration': form.duration.data})
elif self.entry.break_:
update_break_entry(item, data)
elif self.entry.session_block:
update_session_block(item, data)
notifications = get_time_changes_notifications(changes, tzinfo=self.event_new.tzinfo, entry=self.entry)
updated_entries.append(item.timetable_entry)
return jsonify_data(entries=[serialize_entry_update(entry) for entry in updated_entries], flash=False,
shift_later=shift_later, notifications=notifications)
self.commit = False
return jsonify_form(form, back_button=False, disabled_until_change=True)
def _process(self):
form = 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 = ContributionDefaultDurationForm(duration=contribution_settings.get(self.event, 'default_duration'))
if form.validate_on_submit():
contribution_settings.set(self.event, 'default_duration', form.duration.data)
flash(_("Default contribution duration was changed successfully"))
return jsonify_data()
return jsonify_form(form)
def _process(self):
form = 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 = 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 = AbstractCommentForm(abstract=self.abstract, user=session.user)
if form.validate_on_submit():
create_abstract_comment(self.abstract, form.data)
return jsonify_data(flash=False, html=render_abstract_page(self.abstract, management=self.management))
tpl = get_template_module('events/reviews/forms.html')
return jsonify(html=tpl.render_comment_form(form, proposal=self.abstract))
def _process(self):
form = build_review_form(self.abstract, self.track)
if form.validate_on_submit():
create_abstract_review(self.abstract, self.track, session.user, **form.split_data)
return jsonify_data(flash=False, html=render_abstract_page(self.abstract, management=self.management))
tpl = get_template_module('events/reviews/forms.html')
return jsonify(html=tpl.render_review_form(form, proposal=self.abstract, group=self.track))
def _process(self):
form = build_review_form(review=self.review)
if form.validate_on_submit():
update_abstract_review(self.review, **form.split_data)
return jsonify_data(flash=False, html=render_abstract_page(self.abstract, management=self.management))
tpl = get_template_module('events/reviews/forms.html')
return jsonify(html=tpl.render_review_form(form, review=self.review))
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):
for event in self.events:
event.move(self.target_category)
flash(ngettext('You have moved one event to the category "{cat}"',
'You have moved {count} events to the category "{cat}"', len(self.events))
.format(count=len(self.events), cat=self.target_category.title), 'success')
return jsonify_data(flash=False)
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):
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_DELETE(self):
delete_contribution(self.contrib)
flash(
_("Contribution '{}' successfully deleted").format(
self.contrib.title), 'success')
return jsonify_data(**self.list_generator.render_list())
def _process(self):
question_ids = request.form.getlist('field_ids', type=int)
sort_reviewing_questions(self.event.abstract_review_questions,
question_ids)
return jsonify_data(flash=False)
def _process(self):
self.attachment.is_deleted = True
logger.info('Attachment %s deleted by %s', self.attachment, session.user)
signals.attachments.attachment_deleted.send(self.attachment, user=session.user)
flash(_("Attachment \"{name}\" deleted").format(name=self.attachment.title), 'success')
return jsonify_data(attachment_list=_render_attachment_list(self.object))
def _process_DELETE(self):
delete_subcontribution(self.subcontrib)
flash(
_("Subcontribution '{}' deleted successfully").format(
self.subcontrib.title), 'success')
return jsonify_data(html=_render_subcontribution_list(self.contrib))
def _process(self):
if self.paper.state != PaperRevisionState.submitted:
reset_paper_state(self.paper)
flash(_("The paper judgment has been reset"), 'success')
return jsonify_data(html=render_paper_page(self.paper))
def _process(self):
contrib = ContributionCloner.clone_single_contribution(
self.contrib, preserve_session=True)
return jsonify_data(update=serialize_entry_update(
contrib.timetable_entry, session_=contrib.session))
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':
# only one repetition
clone = clone_event(self.event, None, form.start_dt.data,
set(form.selected_items.data),
form.category.data,
form.refresh_users.data)
flash(_('Welcome to your cloned event!'), 'success')
return jsonify_data(redirect=url_for(
'event_management.settings', clone),
flash=False)
else:
# recurring event
clone_calculator = get_clone_calculator(
form.repeatability.data, self.event)
dates = clone_calculator.calculate(request.form)[0]
for n, start_dt in enumerate(dates, 1):
clone_event(self.event, n, start_dt,
set(form.selected_items.data),
form.category.data,
form.refresh_users.data)
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):
if not self.plugin.can_manage_vc_rooms(session.user, self.event):
flash(
_('You are not allowed to modify {} rooms for this event.').
format(self.plugin.friendly_name), 'error')
raise Forbidden
form = self.plugin.create_form(
self.event,
existing_vc_room=self.vc_room,
existing_event_vc_room=self.event_vc_room)
if form.validate_on_submit():
self.plugin.update_data_vc_room(self.vc_room, form.data)
event_vc_room = process_vc_room_association(
self.plugin,
self.event,
self.vc_room,
form,
event_vc_room=self.event_vc_room,
allow_same_room=True)
if not event_vc_room:
return jsonify_data(flash=False)
self.vc_room.modified_dt = now_utc()
try:
self.plugin.update_room(self.vc_room, self.event)
except VCRoomNotFoundError as err:
Logger.get('modules.vc').warning(
"VC room %r not found. Setting it as deleted.",
self.vc_room)
self.vc_room.status = VCRoomStatus.deleted
flash(err.message, 'error')
return jsonify_data(flash=False)
except VCRoomError as err:
if err.field is None:
raise
field = getattr(form, err.field)
field.errors.append(err.message)
db.session.rollback()
else:
# TODO
# notify_modified(self.vc_room, self.event, session.user)
flash(
_("{plugin_name} room '{room.name}' updated").format(
plugin_name=self.plugin.friendly_name,
room=self.vc_room), 'success')
return jsonify_data(flash=False)
form_html = self.plugin.render_form(plugin=self.plugin,
event=self.event,
form=form,
existing_vc_room=self.vc_room,
skip_fields=form.skip_fields
| {'name'})
return jsonify(html=form_html, js=_pop_injected_js())
def _process(self):
ContributionCloner.clone_single_contribution(self.contrib)
return jsonify_data(**self.list_generator.render_list())
def _process(self):
for subcontrib in self.subcontribs:
delete_subcontribution(subcontrib)
return jsonify_data(html=_render_subcontribution_list(self.contrib))
def _process_PUT(self):
self.registration.checked_in = True
return jsonify_data(html=_render_registration_details(self.registration))
def _process(self):
return jsonify_data(html=_render_subcontribution_list(self.contrib))
def _process(self):
revoke_access(self.registrations)
return jsonify_data(**self.list_generator.render_list())
def _process_POST(self):
self.list_generator.store_configuration()
return jsonify_data(**self.list_generator.render_list())
def _process_DELETE(self):
delete_reference_type(self.reference_type)
flash(
_("External ID type '{}' successfully deleted").format(
self.reference_type.name), 'success')
return jsonify_data(html=_render_reference_type_list())
def _process(self):
db.session.delete(self.paper_file)
return jsonify_data(html=_render_paper_file_list(self.contrib))
def _process(self):
delete_reviewing_question(self.question)
return jsonify_data(flash=False)
def contribution_type_row(contrib_type):
template = get_template_module('events/contributions/management/_types_table.html')
html = template.types_table_row(contrib_type=contrib_type)
return jsonify_data(html_row=html, flash=False)
def _process(self):
_modify_registration_status(self.registration, approve=False)
return jsonify_data(
html=_render_registration_details(self.registration))
def _process_DELETE(self):
self.registration.checked_in = False
signals.event.registration_checkin_updated.send(self.registration)
return jsonify_data(
html=_render_registration_details(self.registration))
def _process(self):
close_cfp(self.event_new)
flash(_("Call for papers is now closed"), 'success')
return jsonify_data(html=_render_paper_dashboard(self.event_new))
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 = [
r for r in (self.registrations or self.regform.registrations)
if r.is_active
]
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):
roles = {}
event_permissions = event_permissions_schema.dump(self.event).get(
'acl_entries', {})
roles['global'] = self._map_event_to_track_permissions(
event_permissions)
tracks = Track.query.with_parent(self.event).options(
subqueryload('acl_entries'))
tracks_by_id = {str(track.id): track for track in tracks}
for track in tracks:
roles[str(track.id)] = track_permissions_schema.dump(track).get(
'acl_entries', {})
form = AbstractReviewingRolesForm(event=self.event,
obj=FormDefaults(roles=roles))
if form.validate_on_submit():
role_data = form.data['roles']
# Update global permissions
global_conveners = []
global_reviewers = []
global_roles = role_data.pop('global')
for identifier, permissions in global_roles:
principal = principal_from_identifier(
identifier,
allow_groups=True,
allow_event_roles=True,
allow_category_roles=True,
event_id=self.event.id)
if 'convene' in permissions:
global_conveners.append(principal)
if 'review' in permissions:
global_reviewers.append(principal)
update_object_principals(self.event,
global_conveners,
permission='convene_all_abstracts')
update_object_principals(self.event,
global_reviewers,
permission='review_all_abstracts')
# Update track specific permissions
track_conveners = []
track_reviewers = []
for (track_id, track_roles) in role_data.items():
acl_entries = {}
for identifier, permissions in track_roles:
principal = principal_from_identifier(
identifier,
allow_groups=True,
allow_event_roles=True,
allow_category_roles=True,
event_id=self.event.id)
acl_entries[principal] = set(permissions)
if 'convene' in permissions:
track_conveners.append(principal)
if 'review' in permissions:
track_reviewers.append(principal)
track = tracks_by_id[track_id]
current = {
e.principal: get_unified_permissions(e)
for e in track.acl_entries
}
update_principals_permissions(track, current, acl_entries)
# Update event ACL for track and global permissions
all_conveners = set(global_conveners + track_conveners)
all_reviewers = set(global_reviewers + track_reviewers)
update_object_principals(self.event,
all_conveners,
permission='track_convener')
update_object_principals(self.event,
all_reviewers,
permission='abstract_reviewer')
flash(_("Abstract reviewing roles have been updated."), 'success')
logger.info(
"Abstract reviewing roles of %s have been updated by %s",
self.event, session.user)
return jsonify_data()
return jsonify_form(form,
skip_labels=True,
form_header_kwargs={'id': 'reviewing-role-form'},
disabled_until_change=False)
def _process(self):
approve = request.form['approve'] == '1'
for registration in self.registrations:
_modify_registration_status(registration, approve)
flash(_("The status of the selected registrations was updated successfully."), 'success')
return jsonify_data(**self.list_generator.render_list())
def _process_DELETE(self):
set_reviewing_state(
self.event_new,
PaperReviewType[request.view_args['reviewing_type']], False)
return jsonify_data(flash=False,
html=_render_paper_dashboard(self.event_new))
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 = None
parent_session_block = self.entry.parent.object if self.entry.parent else None
if self.entry.contribution:
contrib = self.entry.contribution
tt_entry_dt = self.entry.start_dt.astimezone(self.event.tzinfo)
form = ContributionEntryForm(obj=FormDefaults(
contrib, time=tt_entry_dt.time()),
event=self.event,
contrib=contrib,
to_schedule=False,
day=tt_entry_dt.date(),
session_block=parent_session_block)
if form.validate_on_submit():
with track_time_changes(auto_extend=True,
user=session.user) as changes:
with flash_if_unregistered(self.event,
lambda: contrib.person_links):
update_contribution(contrib,
*get_field_values(form.data))
notifications = get_time_changes_notifications(
changes, tzinfo=self.event.tzinfo, entry=self.entry)
return jsonify_data(update=serialize_entry_update(
self.entry, session_=self.session),
notifications=notifications)
elif not form.is_submitted():
handle_legacy_description(form.description, contrib)
return jsonify_template(
'events/contributions/forms/contribution.html',
form=form,
fields=form._display_fields)
elif self.entry.break_:
break_ = self.entry.break_
tt_entry_dt = self.entry.start_dt.astimezone(self.event.tzinfo)
form = BreakEntryForm(obj=FormDefaults(break_,
time=tt_entry_dt.time()),
event=self.event,
day=tt_entry_dt.date(),
session_block=parent_session_block)
if form.validate_on_submit():
with track_time_changes(auto_extend=True,
user=session.user) as changes:
update_break_entry(break_, form.data)
notifications = get_time_changes_notifications(
changes, tzinfo=self.event.tzinfo, entry=self.entry)
return jsonify_data(update=serialize_entry_update(
self.entry, session_=self.session),
notifications=notifications,
flash=False)
elif self.entry.session_block:
if self.edit_session:
session_ = self.entry.session_block.session
form = SessionForm(obj=FormDefaults(session_),
event=self.event)
if form.validate_on_submit():
update_session(session_, form.data)
return jsonify_data(update=serialize_entry_update(
self.entry, session_=self.session),
flash=False)
else:
block = self.entry.session_block
tt_entry_dt = self.entry.start_dt.astimezone(self.event.tzinfo)
form = SessionBlockEntryForm(obj=FormDefaults(
block, time=tt_entry_dt.time()),
event=self.event,
session_block=block,
to_schedule=False,
day=tt_entry_dt.date())
if form.validate_on_submit():
with track_time_changes(auto_extend=True,
user=session.user) as changes:
update_session_block(block, form.data)
notifications = get_time_changes_notifications(
changes, tzinfo=self.event.tzinfo, entry=self.entry)
return jsonify_data(update=serialize_entry_update(
self.entry, session_=self.session),
notifications=notifications,
flash=False)
self.commit = False
return jsonify_form(form,
fields=getattr(form, '_display_fields', None))
def _process_DELETE(self):
self.registration.checked_in = False
return jsonify_data(html=_render_registration_details(self.registration))
def _get_response(self, new_session):
return jsonify_data(session=serialize_session(new_session))
def _process(self):
form = PaperJudgmentForm(paper=self.paper)
if form.validate_on_submit():
judge_paper(self.paper, form.judgment.data, form.judgment_comment.data, judge=session.user)
return jsonify_data(flash=False, html=render_paper_page(self.paper))
