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 = TextForm() if form.validate_on_submit(): add_survey_text(self.section, form.data) flash(_('Text item added'), 'success') return jsonify_data(questionnaire=_render_questionnaire_preview(self.survey)) return jsonify_template('forms/form_common_fields_first.html', form=form)
def _process(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): endpoints = {'create': 'abstracts.create_reviewing_question', 'edit': 'abstracts.edit_reviewing_question', 'delete': 'abstracts.delete_reviewing_question', 'sort': 'abstracts.sort_reviewing_questions'} return jsonify_template('events/reviewing_questions_management.html', event=self.event, reviewing_questions=self.event.abstract_review_questions, field_types=get_reviewing_field_types('abstracts'), endpoints=endpoints, common_url_args={})
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): 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): tpl_args = {'linked_object': self.object, 'linked_object_type': self.object_type, 'attachments': get_attached_items(self.object)} if self.object_type in ('event', 'category'): return self.wp.render_template('attachments.html', self._target, **tpl_args) else: return jsonify_template('attachments/attachments.html', **tpl_args)
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 _render_form(self, users, action): user_competences = self.event.cfp.user_competences competences = {'competences_{}'.format(user_id): competences.competences for user_id, competences in user_competences.iteritems()} return jsonify_template('events/papers/assign_role.html', event=self.event, role=self.role.name, action=action, users=users, competences=competences, contribs=self.contributions)
def _process_GET(self): list_config = self.list_generator.list_config return jsonify_template('events/papers/paper_list_filter.html', event=self.event, static_items=self.list_generator.static_items, filters=list_config['filters'], visible_items=list_config['items'])
def _process(self): form = TicketsForm(obj=self.regform, event=self.event) if form.validate_on_submit(): form.populate_obj(self.regform) db.session.flush() return jsonify_data(flash=False, tickets_enabled=self.regform.tickets_enabled) return jsonify_template('events/registration/management/regform_tickets.html', regform=self.regform, form=form)
def _process(self): form = SessionProtectionForm(obj=FormDefaults(**self._get_defaults()), session=self.session, prefix='session-protection-') if form.validate_on_submit(): update_permissions(self.session, form) update_session(self.session, {'protection_mode': form.protection_mode.data}) return jsonify_data(flash=False, html=_render_session_list(self.event)) return jsonify_template('events/management/protection_dialog.html', form=form)
def _process_GET(self): list_config = self.list_generator._get_config() return jsonify_template('events/abstracts/management/abstract_list_filter.html', visible_items=list_config['items'], static_items=self.list_generator.static_items, extra_filters=self.list_generator.extra_filters, contrib_fields=self.list_generator.get_all_contribution_fields(), filters=list_config['filters'])
def _process(self): form = SubContributionForm(obj=FormDefaults(self.subcontrib), event=self.event_new, subcontrib=self.subcontrib) if form.validate_on_submit(): update_subcontribution(self.subcontrib, form.data) flash(_("Subcontribution '{}' updated successfully").format(self.subcontrib.title), 'success') return jsonify_data(html=_render_subcontribution_list(self.contrib)) self.commit = False return jsonify_template('events/contributions/forms/subcontribution.html', form=form)
def _process(self): form = ContributionProtectionForm(obj=FormDefaults(**self._get_defaults()), contrib=self.contrib, prefix='contribution-protection-') if form.validate_on_submit(): update_permissions(self.contrib, form) update_contribution(self.contrib, {'protection_mode': form.protection_mode.data}) return jsonify_data(flash=False, **self.list_generator.render_list(self.contrib)) return jsonify_template('events/management/protection_dialog.html', form=form)
def _process_GET(self): reg_list_config = self.list_generator._get_config() return jsonify_template('events/registration/management/reglist_filter.html', regform=self.regform, RegistrationFormItemType=RegistrationFormItemType, visible_items=reg_list_config['items'], static_items=self.list_generator.static_items, filters=reg_list_config['filters'])
def _process(self): inherited_templates = [tpl for tpl in get_inherited_templates(self.target) if not tpl.backside_template and tpl.type == TemplateType.badge] custom_templates = [tpl for tpl in self.target.designer_templates if not tpl.backside_template and tpl != self.template and tpl.type == TemplateType.badge] return jsonify_template('designer/backside_list.html', target=self.target, custom_templates=custom_templates, inherited_templates=inherited_templates, current_template=self.template, width=int(request.args['width']), height=int(request.args['height']))
def _process(self): tpl_args = {'linked_object': self.object, 'linked_object_type': self.object_type, 'attachments': get_attached_items(self.object)} if self.object_type == 'event': return self.wp.render_template('attachments.html', self._target, **tpl_args) elif self.object_type == 'category' and not request.is_xhr: return self.wp.render_template('management/attachments.html', self.category, 'attachments', **tpl_args) else: return jsonify_template('attachments/attachments.html', **tpl_args)
def _process(self): form = TextForm(obj=FormDefaults(self.text)) if form.validate_on_submit(): form.populate_obj(self.text) db.session.flush() flash(_('Text item updated'), 'success') logger.info('Survey text item {} modified by {}'.format(self.text, session.user)) return jsonify_data(questionnaire=_render_questionnaire_preview(self.survey)) return jsonify_template('events/surveys/management/edit_survey_item.html', form=form)
def _process(self): defaults = FormDefaults(self.event, update_timetable=True) form = EventDatesForm(obj=defaults, event=self.event) if form.validate_on_submit(): with track_time_changes(): update_event(self.event, **form.data) return self.jsonify_success() show_screen_dates = form.has_displayed_dates and (form.start_dt_override.data or form.end_dt_override.data) return jsonify_template('events/management/event_dates.html', form=form, show_screen_dates=show_screen_dates)
def _process(self): form = AddAttachmentLinkForm(linked_object=self.object) if form.validate_on_submit(): add_attachment_link(form.data, self.object) flash(_("The link has been added"), 'success') return jsonify_data(attachment_list=_render_attachment_list(self.object)) return jsonify_template('attachments/add_link.html', form=form, protection_message=_render_protection_message(self.object), folders_protection_info=_get_folders_protection_info(self.object))
def _process(self): is_submitted = 'confirmed' in request.form if not is_submitted: return jsonify_template('events/management/delete_events.html', events=self.events) for ev in self.events[:]: ev.delete('Bulk-deleted by category manager', session.user) flash(ngettext('You have deleted one event', 'You have deleted {} events', len(self.events)) .format(len(self.events)), 'success') return jsonify_data(flash=False, redirect=url_for('.manage_content', self.category))
def _process(self): if 'confirmed' in request.form: for subcategory in self.subcategories: if not subcategory.is_empty: raise BadRequest('Category "{}" is not empty'.format(subcategory.title)) delete_category(subcategory) return jsonify_data(flash=False, is_empty=self.category.is_empty) return jsonify_template('categories/management/delete_categories.html', categories=self.subcategories, category_ids=[x.id for x in self.subcategories])
def _process(self): form = TextForm(obj=FormDefaults(self.text)) if form.validate_on_submit(): form.populate_obj(self.text) db.session.flush() flash(_('Text item updated'), 'success') logger.info('Survey text item %s modified by %s', self.text, session.user) return jsonify_data(questionnaire=_render_questionnaire_preview(self.survey)) return jsonify_template('forms/form_common_fields_first.html', form=form)
def _process(self): form = CreateEmailTemplateForm(event=self.event_new) if form.validate_on_submit(): new_tpl = build_default_email_template(self.event_new, form.default_tpl.data) form.populate_obj(new_tpl) self.event_new.abstract_email_templates.append(new_tpl) db.session.flush() return _render_notification_list(self.event_new) return jsonify_template('events/abstracts/management/notification_tpl_form.html', form=form)
def _process(self): form = RegistrationFormScheduleForm(obj=FormDefaults(self.regform), regform=self.regform) if form.validate_on_submit(): self.regform.start_dt = form.start_dt.data self.regform.end_dt = form.end_dt.data flash(_("Registrations for {} have been scheduled").format(self.regform.title), 'success') logger.info("Registrations for %s scheduled by %s", self.regform, session.user) return jsonify_data(flash=False) return jsonify_template('events/registration/management/regform_schedule.html', form=form)
def _process(self): form = self.question.field.config_form(obj=FormDefaults(self.question, **self.question.field_data)) if form.validate_on_submit(): old_title = self.question.title self.question.field.save_config(form) db.session.flush() flash(_('Question "{title}" updated').format(title=old_title), 'success') logger.info('Survey question {} modified by {}'.format(self.question, session.user)) return jsonify_data(questionnaire=_render_questionnaire_preview(self.survey)) return jsonify_template('events/surveys/management/edit_survey_item.html', form=form)
def _process(self): form = SurveyForm(event=self.event, obj=self._get_form_defaults()) if form.validate_on_submit(): form.populate_obj(self.survey) db.session.flush() flash(_('Survey modified'), 'success') logger.info('Survey %s modified by %s', self.survey, session.user) return jsonify_data(flash=False) return jsonify_template('events/surveys/management/edit_survey.html', event=self.event, form=form, survey=self.survey)
def _process(self): abstract_form_class = make_abstract_form(self.event, session.user, management=self.management) form = abstract_form_class(event=self.event) if form.validate_on_submit(): abstract = create_abstract(self.event, *get_field_values(form.data), send_notifications=True) flash(_("Your abstract '{}' has been successfully submitted. It is registered with the number " "#{}. You will be notified by email with the submission details.") .format(abstract.title, abstract.friendly_id), 'success') return jsonify_data(flash=False, redirect=url_for('.call_for_abstracts', self.event)) return jsonify_template('events/abstracts/display/submission.html', event=self.event, form=form)
def _process(self): form = self.question.field.create_config_form(obj=FormDefaults(self.question, **self.question.field_data)) if form.validate_on_submit(): old_title = self.question.title self.question.field.update_object(form.data) db.session.flush() flash(_('Question "{title}" updated').format(title=old_title), 'success') logger.info('Survey question %s modified by %s', self.question, session.user) return jsonify_data(questionnaire=_render_questionnaire_preview(self.survey)) return jsonify_template('forms/form_common_fields_first.html', form=form)
def _process(self): form = ReminderForm(event=self.event, schedule_type='relative') if form.validate_on_submit(): reminder = EventReminder(creator=session.user, event=self.event) form.populate_obj(reminder, existing_only=True) db.session.add(reminder) db.session.flush() if form.schedule_type.data == 'now': _send_reminder(reminder) else: logger.info('Reminder created by %s: %s', session.user, reminder) flash( _("A reminder at {} has been created.").format( format_datetime(reminder.scheduled_dt)), 'success') return jsonify_data(flash=False) return jsonify_template('events/reminders/edit_reminder.html', event=self.event, reminder=None, form=form)
def _process(self): form = ImportContributionsForm() if form.validate_on_submit(): contributions, changes = import_contributions_from_csv( self.event, form.source_file.data) flash( ngettext("{} contribution has been imported.", "{} contributions have been imported.", len(contributions)).format(len(contributions)), 'success') if changes: flash(_("Event dates/times adjusted due to imported data."), 'warning') return jsonify_data(flash=False, redirect=url_for('.manage_contributions', self.event)) return jsonify_template( 'events/contributions/management/import_contributions.html', form=form, event=self.event)
def _process(self): form = AddAttachmentFilesForm(linked_object=self.object) if form.validate_on_submit(): files = form.files.data folder = form.folder.data or AttachmentFolder.get_or_create_default( linked_object=self.object) for f in files: filename = secure_filename(f.filename, 'attachment') attachment = Attachment( folder=folder, user=session.user, title=to_unicode(f.filename), type=AttachmentType.file, protection_mode=form.protection_mode.data) if attachment.is_self_protected: attachment.acl = form.acl.data content_type = mimetypes.guess_type( f.filename)[0] or f.mimetype or 'application/octet-stream' attachment.file = AttachmentFile(user=session.user, filename=filename, content_type=content_type) attachment.file.save(f.file) db.session.add(attachment) db.session.flush() logger.info('Attachment %s uploaded by %s', attachment, session.user) signals.attachments.attachment_created.send(attachment, user=session.user) flash( ngettext("The attachment has been uploaded", "{count} attachments have been uploaded", len(files)).format(count=len(files)), 'success') return jsonify_data( attachment_list=_render_attachment_list(self.object)) return jsonify_template( 'attachments/upload.html', form=form, action=url_for('.upload', self.object), protection_message=_render_protection_message(self.object), folders_protection_info=_get_folders_protection_info(self.object))
def _process(self): recordings_xml = get_recordings(self.event_vc_room) root = ET.fromstring(recordings_xml) data = [] for rec in root.iter('recording'): recording_data = { 'start_date': datetime.fromtimestamp( float(rec.find('startTime').text) / 1000).strftime('%Y-%M-%d %X'), 'end_date': datetime.fromtimestamp( float(rec.find('startTime').text) / 1000).strftime('%X'), 'state': rec.find('state').text, 'record_id': rec.find('recordID').text, 'participants': rec.find('participants').text } for format in rec.iter('format'): if format.find('type').text == 'presentation': recording_data.update({ 'url': format.find('url').text, 'length': format.find('length').text }) previews = [] for image in format.iter('image'): previews.append({ 'src': image.text, 'alt': image.attrib['alt'], 'width': image.attrib['width'], 'height': image.attrib['height'] }) recording_data.update({'previews': previews}) data.append(recording_data) return jsonify_template('list_recordings.html', render_plugin_template, recordings=data, event_vc_room=self.event_vc_room)
def _process_form(self, form, **kwargs): saved = False if form.validate_on_submit(): note = EventNote.get_or_create(self.object) is_new = note.id is None or note.is_deleted is_restored = is_new and note.is_deleted # TODO: get render mode from form data once it can be selected note.create_revision(RenderMode.html, form.source.data, session.user) is_changed = attrs_changed(note, 'current_revision') db.session.add(note) db.session.flush() if is_new: if is_restored: signals.event.notes.note_restored.send(note) else: signals.event.notes.note_added.send(note) logger.info('Note %s created by %s', note, session.user) self.event.log(EventLogRealm.participants, EventLogKind.positive, 'Minutes', 'Added minutes', session.user, data=note.link_event_log_data) elif is_changed: signals.event.notes.note_modified.send(note) logger.info('Note %s modified by %s', note, session.user) self.event.log(EventLogRealm.participants, EventLogKind.change, 'Minutes', 'Updated minutes', session.user, data=note.link_event_log_data) saved = is_new or is_changed return jsonify_template('events/notes/edit_note.html', form=form, object_type=self.object_type, object=self.object, saved=saved, **kwargs)
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 '{0}'").format(vc_room.name), '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): defaults = self._get_form_defaults(location_parent=self.session_block) form = ContributionEntryForm(obj=defaults, to_schedule=True, **self._get_form_params()) if form.validate_on_submit(): with track_time_changes(auto_extend=True, user=session.user) as changes: contrib = create_contribution(self.event_new, form.data, session_block=self.session_block, extend_parent=True) entry = contrib.timetable_entry notifications = get_time_changes_notifications( changes, tzinfo=self.event_new.tzinfo, entry=entry) return jsonify_data(entries=[serialize_entry_update(entry)], notifications=notifications, flash=False) self.commit = False return jsonify_template('events/contributions/forms/contribution.html', form=form, fields=form._display_fields)
def _process(self): form = TimetablePDFExportForm(formdata=request.args, csrf_enabled=False) if form.validate_on_submit(): form_data = form.data_for_format pdf_format = TimetablePDFFormat(form_data) if not form.advanced.data: pdf_class = SimplifiedTimeTablePlain additional_params = {} else: pdf_class = TimeTablePlain additional_params = {'firstPageNumber': form.firstPageNumber.data, 'showSpeakerAffiliation': form_data['showSpeakerAffiliation'], 'showSessionDescription': form_data['showSessionDescription']} if request.args.get('download') == '1': pdf = pdf_class(self.event_new, session.user, sortingCrit=None, ttPDFFormat=pdf_format, pagesize=form.pagesize.data, fontsize=form.fontsize.data, **additional_params) return send_file('timetable.pdf', BytesIO(pdf.getPDFBin()), 'application/pdf') else: url = url_for(request.endpoint, **dict(request.view_args, download='1', **request.args.to_dict(False))) return jsonify_data(flash=False, redirect=url, redirect_no_loading=True) return jsonify_template('events/timetable/timetable_pdf_export.html', form=form, back_url=url_for('.timetable', self.event_new))
def _process(self): form = ImportRegistrationsForm(regform=self.regform) if form.validate_on_submit(): registrations = import_registrations_from_csv( self.regform, form.source_file.data, skip_moderation=form.skip_moderation.data, notify_users=form.notify_users.data) flash( ngettext("{} registration has been imported.", "{} registrations have been imported.", len(registrations)).format(len(registrations)), 'success') return jsonify_data(flash=False, redirect=url_for('.manage_reglist', self.regform), redirect_no_loading=True) return jsonify_template( 'events/registration/management/import_registrations.html', form=form, regform=self.regform)
def _process(self): if not request.is_xhr: return redirect(url_for_index(_anchor=f'create-event:{self.event_type.name}')) form_cls = LectureCreationForm if self.event_type == EventType.lecture else EventCreationForm form = form_cls(obj=self._get_form_defaults(), prefix='event-creation-') if form.validate_on_submit(): if self.event_type == EventType.lecture: events = self._create_series(form.data) event = events[0] if len(events) > 1: flash(Markup(render_template('events/series_created_msg.html', events=events)), 'info') notify_event_creation(event, occurrences=events) else: event = self._create_event(form.data) notify_event_creation(event) return jsonify_data(flash=False, redirect=url_for('event_management.settings', event)) check_room_availability = rb_check_user_access(session.user) and config.ENABLE_ROOMBOOKING rb_excluded_categories = [c.id for c in rb_settings.get('excluded_categories')] return jsonify_template('events/forms/event_creation_form.html', form=form, fields=form._field_order, event_type=self.event_type.name, single_category=(not self.root_category.has_children), check_room_availability=check_room_availability, rb_excluded_categories=rb_excluded_categories)
def _process(self): form = AdminAccountRegistrationForm() if form.validate_on_submit(): data = form.data if data.pop('create_identity', False): identity = Identity(provider='indico', identifier=data.pop('username'), password=data.pop('password')) else: identity = None data.pop('username', None) data.pop('password', None) user = create_user(data.pop('email'), data, identity, from_moderation=True) msg = Markup('{} <a href="{}">{}</a>').format( escape(_('The account has been created.')), url_for('users.user_profile', user), escape(_('Show details'))) flash(msg, 'success') return jsonify_data() return jsonify_template('users/users_admin_create.html', form=form)
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': dates = [form.start_dt.data] else: clone_calculator = get_clone_calculator(form.repeatability.data, self.event) dates = clone_calculator.calculate(request.form)[0] clones = [clone_event(self.event, start_dt, set(form.selected_items.data), form.category.data) for start_dt in dates] if len(clones) == 1: flash(_('Welcome to your cloned event!'), 'success') return jsonify_data(redirect=url_for('event_management.settings', clones[0]), flash=False) else: 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): can_modify = bool(session.user) and self.plugin.can_be_modified( session.user, self.event) plugin_settings = self.plugin.settings.get_all() plugin_event_settings = self.plugin.event_settings.get_all(self.event) defaults = FormDefaults( { k: v for k, v in plugin_event_settings.iteritems() if v is not None }, **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, 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) return jsonify_template('events/payment/event_plugin_edit.html', event=self.event, form=form, plugin=self.plugin, can_modify=can_modify, widget_attrs=widget_attrs, invalid_regforms=invalid_regforms)
def _process_POST(self): original_url = self._make_absolute_url(request.args['original_url']) shortcut = request.form['shortcut'].strip() if not (set(shortcut) <= CUSTOM_SHORTCUT_ALPHABET): raise BadRequest('Invalid shortcut') result = register_shortcut(original_url, shortcut, session.user) if result.get('error'): kwargs = {'success': False, 'msg': self._get_error_msg(result)} else: kwargs = {'success': True, 'shorturl': result['short_url']} return jsonify_template('ursh_custom_shortener_page.html', render_plugin_template, event=self.event, ursh_host=self.ursh_host, shortcut=shortcut, original_url=original_url, submitted=True, **kwargs)
def _process(self): defaults = FormDefaults(self.folder, protected=self.folder.is_self_protected) form = AttachmentFolderForm(obj=defaults, linked_object=self.object) if form.validate_on_submit(): form.populate_obj(self.folder, skip={'acl'}) if self.folder.is_self_protected: # can't use `=` because of https://bitbucket.org/zzzeek/sqlalchemy/issues/3583 self.folder.acl |= form.acl.data self.folder.acl &= form.acl.data logger.info('Folder %s edited by %s', self.folder, session.user) signals.attachments.folder_updated.send(self.folder, user=session.user) flash( _("Folder \"{name}\" updated").format(name=self.folder.title), 'success') return jsonify_data( attachment_list=_render_attachment_list(self.object)) return jsonify_template('attachments/create_folder.html', form=form, protection_message=_render_protection_message( self.object))
def _process(self): form = MeetingSessionBlockForm( obj=FormDefaults(**self._get_form_defaults()), event=self.event, session_block=self.session_block) if form.validate_on_submit(): session_data = { k[8:]: v for k, v in form.data.items() if k in form.session_fields } block_data = { k[6:]: v for k, v in form.data.items() if k in form.block_fields } update_session(self.session, session_data) with track_location_changes(): update_session_block(self.session_block, block_data) return jsonify_data(flash=False) self.commit = False return jsonify_template('events/forms/session_block_form.html', form=form, block=self.session_block)
def _process(self): paper_persons_dict = {} for p in self.event.acl_entries: user = p.principal is_judge = p.has_management_role('paper_judge', explicit=True) is_content_reviewer = (self.event.cfp.content_reviewing_enabled and p.has_management_role( 'paper_content_reviewer', explicit=True)) is_layout_reviewer = (self.event.cfp.layout_reviewing_enabled and p.has_management_role( 'paper_layout_reviewer', explicit=True)) if is_judge or is_content_reviewer or is_layout_reviewer: paper_persons_dict[user] = { 'judge': is_judge, 'content_reviewer': is_content_reviewer, 'layout_reviewer': is_layout_reviewer } return jsonify_template( 'events/papers/management/paper_person_list.html', event_persons=paper_persons_dict, event=self.event)
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 = self.registrations or self.regform.registrations 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): inherited_location = self.event.location_data inherited_location['inheriting'] = True contrib_form_class = make_contribution_form(self.event) form = contrib_form_class( obj=FormDefaults(location_data=inherited_location), event=self.event) if form.validate_on_submit(): # Create empty contribution so it can be compared to the new one in flash_if_unregistered contrib = Contribution() with flash_if_unregistered(self.event, lambda: contrib.person_links): contrib = create_contribution(self.event, *get_field_values(form.data)) flash( _("Contribution '{}' created successfully").format( contrib.title), 'success') tpl_components = self.list_generator.render_list(contrib) if tpl_components['hide_contrib']: self.list_generator.flash_info_message(contrib) return jsonify_data(**tpl_components) return jsonify_template('events/contributions/forms/contribution.html', form=form)
def _process(self): allow_reschedule_start = self.survey.state in ( SurveyState.ready_to_open, SurveyState.active_and_clean, SurveyState.finished) form = ScheduleSurveyForm( obj=self._get_form_defaults(), survey=self.survey, allow_reschedule_start=allow_reschedule_start) if form.validate_on_submit(): if allow_reschedule_start: self.survey.start_dt = form.start_dt.data if getattr(form, 'resend_start_notification', False): self.survey.start_notification_sent = not form.resend_start_notification.data self.survey.end_dt = form.end_dt.data flash(_('Survey was scheduled'), 'success') logger.info('Survey {} scheduled by {}'.format( self.survey, session.user)) return jsonify_data(flash=False) disabled_fields = ('start_dt', ) if not allow_reschedule_start else () return jsonify_template( 'events/surveys/management/schedule_survey.html', form=form, disabled_fields=disabled_fields)
def _process(self): tpl = get_template_module( 'events/registration/emails/custom_email_default.html') default_body = tpl.get_html_body() registration_ids = request.form.getlist('registration_id') form = EmailRegistrantsForm( body=default_body, regform=self.regform, registration_id=registration_ids, recipients=[x.email for x in self.registrations]) if not self.regform.tickets_enabled: del form.attach_ticket if form.validate_on_submit(): self._send_emails(form) num_emails_sent = len(self.registrations) flash( ngettext("The email was sent.", "{num} emails were sent.", num_emails_sent).format(num=num_emails_sent), 'success') return jsonify_data() return jsonify_template('events/registration/management/email.html', form=form, regform=self.regform)
def _process(self): form = AddAttachmentLinkForm(linked_object=self.object) if form.validate_on_submit(): folder = form.folder.data or AttachmentFolder.get_or_create_default( linked_object=self.object) link = Attachment(user=session.user, type=AttachmentType.link) form.populate_obj(link, skip={'acl'}) if link.is_protected: link.acl = form.acl.data link.folder = folder db.session.flush() logger.info('Attachment {} added by {}'.format(link, session.user)) signals.attachments.attachment_created.send(link, user=session.user) flash(_("The link has been added"), 'success') return jsonify_data( attachment_list=_render_attachment_list(self.object)) return jsonify_template( 'attachments/add_link.html', form=form, protection_message=_render_protection_message(self.object), folders_protection_info=_get_folders_protection_info(self.object))
def _process(self): badge_templates = sorted((tpl for tpl in get_all_templates(self.event_new) if tpl.type.name == 'badge'), key=attrgetter('title')) settings = event_badge_settings.get_all(self.event_new.id) form = BadgeSettingsForm(self.event_new, template=self.template_id, **settings) registrations = self.registrations or self.regform.registrations if self.event_new.is_locked: del form.save_values if form.validate_on_submit(): data = form.data data.pop('submitted', None) template_id = data.pop('template') if data.pop('save_values', False): event_badge_settings.set_multi(self.event_new, 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_new, regform=self.regform, settings_form=form, templates=badge_templates, registrations=registrations)
def _process(self): contrib_form_class = make_contribution_form(self.event) custom_field_values = { f'custom_{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(), track_location_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) can_manage = self.contrib.can_manage(session.user) self.commit = False return jsonify_template('events/contributions/forms/contribution.html', form=form, can_manage=can_manage)
def _process(self): defaults = FormDefaults(self.chatroom) for name in EditChatroomForm.event_specific_fields: defaults[name] = getattr(self.event_chatroom, name) form = EditChatroomForm(obj=defaults) if form.validate_on_submit(): form.populate_obj(self.event_chatroom, fields=form.event_specific_fields) form.populate_obj(self.chatroom, skip=form.event_specific_fields) self.chatroom.modified_dt = now_utc() if attrs_changed(self.chatroom, 'name', 'description', 'password'): update_room(self.chatroom) notify_modified(self.chatroom, self.event, session.user) flash(_('Chatroom updated'), 'success') self.event.log(EventLogRealm.management, EventLogKind.change, 'Chat', 'Chatroom updated: {}'.format(self.chatroom.name), session.user) return jsonify_data(flash=False) return jsonify_template('manage_event_edit.html', render_plugin_template, form=form, event=self.event, event_chatroom=self.event_chatroom)
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): 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( 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 = ImportMembersCSVForm() if form.validate_on_submit(): new_members, users, unknown_emails = self.import_members_from_csv(form.source_file.data) if form.remove_existing.data: deleted_members = self.role.members - users for member in deleted_members: self.logger.info(f'User {member} removed from role {self.role} by {session.user}') self.role.members = users else: self.role.members |= users for user in new_members: self.logger.info(f'User {user} added to role {self.role} by {session.user}') flash(ngettext("{} member has been imported.", "{} members have been imported.", len(users)).format(len(users)), 'success') if unknown_emails: flash(ngettext("There is no user with this email address: {}", "There are no users with these email addresses: {}", len(unknown_emails)).format(', '.join(unknown_emails)), 'warning') tpl = get_template_module('events/roles/_roles.html') return jsonify_data(html=tpl.render_role(self.role, collapsed=False, email_button=False)) return jsonify_template('events/roles/import_members.html', form=form, role=self.role)
def _process(self): step = int(request.form.get('step', 1)) 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 elif step > 2: # last step - perform actual cloning form = ImportContentsForm(self.source_event, self.event) if form.validate_on_submit(): updated_event = clone_into_event(self.source_event, self.event, set(form.selected_items.data)) flash(_('Import successful!'), 'success') return jsonify_data(redirect=url_for('event_management.settings', updated_event), flash=False) else: # back to step 2, since there's been an error step = 2 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/import_event.html', event=self.event, step=step, form=form, cloner_dependencies=dependencies)
def _process_GET(self): return jsonify_template( 'events/contributions/contrib_list_filter.html', filters=self.list_generator.list_config['filters'], static_items=self.list_generator.static_items)