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)