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): 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): submitters = {abstract.submitter for abstract in self.abstracts} abstract_persons = AbstractPersonLink.find_all( AbstractPersonLink.abstract.has(self._membership_filter)) abstract_persons_dict = defaultdict( lambda: { 'speaker': False, 'submitter': False, 'primary_author': False, 'secondary_author': False }) for abstract_person in abstract_persons: dict_key = abstract_person.person.user if abstract_person.person.user else abstract_person.person person_roles = abstract_persons_dict[dict_key] person_roles['speaker'] |= abstract_person.is_speaker person_roles[ 'primary_author'] |= abstract_person.author_type == AuthorType.primary person_roles[ 'secondary_author'] |= abstract_person.author_type == AuthorType.secondary for submitter in submitters: abstract_persons_dict[submitter]['submitter'] |= True return jsonify_template( 'events/abstracts/management/abstract_person_list.html', event_persons=abstract_persons_dict, event=self.event)
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_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): 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): 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): 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): 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): 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): 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): 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] 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): action = request.args.get('vc_room_action', '.manage_vc_rooms_create') attach = request.args.get('attach', '') return jsonify_template('vc/manage_event_select.html', event=self.event, vc_room_action=action, plugins=get_vc_plugins().values(), attach=attach)
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): 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_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 = 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): 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.event, **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): custom_fields = self.event.contribution_fields.order_by( ContributionField.position) custom_field_types = sorted(get_contrib_field_types().values(), key=attrgetter('friendly_name')) return jsonify_template( 'events/contributions/management/fields_dialog.html', event=self.event, custom_fields=custom_fields, custom_field_types=custom_field_types)
def _process(self): form = CreateMultipleRegistrationsForm(regform=self.regform, open_add_user_dialog=(request.method == 'GET'), notify_users=session.get('registration_notify_user_default', True)) if form.validate_on_submit(): session['registration_notify_user_default'] = form.notify_users.data for user in form.user_principals.data: self._register_user(user, form.notify_users.data) return jsonify_data(**self.list_generator.render_list()) return jsonify_template('events/registration/management/registration_create_multiple.html', 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_GET(self): query = (self.network_group.in_event_acls.join(Event).options( contains_eager('event')).order_by(Event.title)) events = [principal.event for principal in query] query = (self.network_group.in_category_acls.join(Category).order_by( Category.title).options(contains_eager('category'))) categories = [principal.category for principal in query] return jsonify_template('networks/delete_network.html', network_group=self.network_group, categories=categories, events=events)
def _process(self): form = AbstractReviewedForTracksForm(event=self.event, obj=self.abstract) if form.validate_on_submit(): update_reviewed_for_tracks(self.abstract, form.reviewed_for_tracks.data) return jsonify_data(flash=False, html=render_abstract_page( self.abstract, management=self.management)) return jsonify_template( 'events/abstracts/forms/edit_review_tracks.html', form=form)
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 = 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): 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): 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 = 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 _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(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))