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))