def create_form(self, event, existing_vc_room=None, existing_event_vc_room=None): """Creates the videoconference room form :param event: the event the videoconference room is for :param existing_vc_room: a vc_room from which to retrieve data for the form :param \*\*kwargs: extra data to pass to the form if an existing vc room is passed :return: an instance of an :class:`fossirForm` subclass """ if existing_vc_room and existing_event_vc_room: kwargs = { 'name': existing_vc_room.name, 'linking': existing_event_vc_room.link_type.name, 'show': existing_event_vc_room.show } if existing_event_vc_room.link_type == VCRoomLinkType.contribution: kwargs['contribution'] = existing_event_vc_room.contribution_id elif existing_event_vc_room.link_type == VCRoomLinkType.block: kwargs['block'] = existing_event_vc_room.session_block_id data = existing_vc_room.data data.update(existing_event_vc_room.data) defaults = FormDefaults(data, **kwargs) else: defaults = FormDefaults(self.get_vc_room_form_defaults(event)) with self.plugin_context(): return self.vc_room_form(prefix='vc-', obj=defaults, event=event, vc_room=existing_vc_room)
def _get_defaults(self, note=None, source=None): if source: return FormDefaults(source=source) elif note: return FormDefaults(note.current_revision) else: # TODO: set default render mode once it can be selected return FormDefaults()
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): 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): 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 _create_form(self): if self.user.local_identity: defaults = FormDefaults(username=self.user.local_identity.identifier) local_account_form = EditLocalIdentityForm(identity=self.user.local_identity, obj=defaults) else: local_account_form = AddLocalIdentityForm() return local_account_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): 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): 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): 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): extra_preferences = [ pref(self.user) for pref in values_from_signal( signals.users.preferences.send(self.user)) ] form_class = UserPreferencesForm defaults = FormDefaults(**self.user.settings.get_all(self.user)) for pref in extra_preferences: form_class = pref.extend_form(form_class) pref.extend_defaults(defaults) form = form_class(obj=defaults) if form.validate_on_submit(): data = form.data for pref in extra_preferences: pref.process_form_data(data) self.user.settings.set_multi(data) session.lang = self.user.settings.get('lang') session.timezone = (self.user.settings.get('timezone') if self.user.settings.get('force_timezone') else 'LOCAL') flash(_('Preferences saved'), 'success') return redirect(url_for('.user_preferences')) return WPUser.render_template('preferences.html', 'preferences', user=self.user, 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): 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): defaults = FormDefaults( self.category, meeting_theme=self.category.default_event_themes['meeting'], lecture_theme=self.category.default_event_themes['lecture']) form = CategorySettingsForm(obj=defaults, category=self.category) icon_form = CategoryIconForm(obj=self.category) logo_form = CategoryLogoForm(obj=self.category) if form.validate_on_submit(): update_category(self.category, form.data, skip={'meeting_theme', 'lecture_theme'}) self.category.default_event_themes = { 'meeting': form.meeting_theme.data, 'lecture': form.lecture_theme.data } flash(_("Category settings saved!"), 'success') return redirect(url_for('.manage_settings', self.category)) else: if self.category.icon_metadata: icon_form.icon.data = self.category if self.category.logo_metadata: logo_form.logo.data = self.category return WPCategoryManagement.render_template('management/settings.html', self.category, 'settings', form=form, icon_form=icon_form, logo_form=logo_form)
def _process(self): form = EventPersonForm(obj=FormDefaults(self.person, skip_attrs={'title'}, title=self.person._title)) if form.validate_on_submit(): update_person(self.person, form.data) person_data = self.get_persons()[self.person.email or self.person.id] tpl = get_template_module('events/persons/management/_person_list_row.html') return jsonify_data(html=tpl.render_person_row(person_data)) return jsonify_form(form)
def _process(self): form = AdminSettingsForm(obj=FormDefaults(**api_settings.get_all())) if form.validate_on_submit(): api_settings.set_multi(form.data) flash(_('Settings saved'), 'success') return redirect(url_for('.admin_settings')) count = APIKey.find(is_active=True).count() return WPAPIAdmin.render_template('admin_settings.html', form=form, count=count)
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 = UpcomingEventsForm(obj=FormDefaults(**upcoming_events_settings.get_all())) if form.validate_on_submit(): upcoming_events_settings.set_multi(form.data) get_upcoming_events.clear_cached() flash(_('Settings saved!'), 'success') return redirect(url_for('categories.manage_upcoming')) return WPManageUpcomingEvents.render_template('admin/upcoming_events.html', 'upcoming_events', form=form)
def _process_args(self): self._blocking = Blocking.get(request.view_args['blocking_id']) if self._blocking is None: raise NotFound('A blocking with this ID does not exist.') defaults = FormDefaults(self._blocking, attrs={'reason'}, principals=self._blocking.allowed, blocked_rooms=[br.room_id for br in self._blocking.blocked_rooms]) self._form = BlockingForm(obj=defaults) self._form._blocking = self._blocking
def create_manager_form(cls, req): """Creates the request management form :param req: the :class:`Request` of the request :return: an instance of an :class:`fossirForm` subclass """ defaults = FormDefaults(req, **req.data) with plugin_context(cls.plugin): return cls.manager_form(prefix='request-manage-', obj=defaults)
def _process(self): form = BOASettingsForm(obj=FormDefaults( **boa_settings.get_all(self.event))) if form.validate_on_submit(): boa_settings.set_multi(self.event, form.data) clear_boa_cache(self.event) flash(_('Book of Abstract settings have been saved'), 'success') return jsonify_data() return jsonify_form(form)
def _process(self): current_event_settings = payment_event_settings.get_all(self.event) defaults = FormDefaults(current_event_settings, **payment_settings.get_all()) form = EventSettingsForm(prefix='payment-', obj=defaults) if form.validate_on_submit(): payment_event_settings.set_multi(self.event, form.data) flash(_('Settings saved'), 'success') return jsonify_data() return jsonify_form(form)
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): form = AnnouncementForm(obj=FormDefaults( **announcement_settings.get_all())) if form.validate_on_submit(): announcement_settings.set_multi(form.data) flash(_('Settings have been saved'), 'success') return redirect(url_for('announcement.manage')) return WPAnnouncement.render_template('settings.html', 'announcement', form=form)
def _process(self): inherited_location = self.event.location_data inherited_location['inheriting'] = True form = SessionForm(obj=FormDefaults(colors=get_random_color( self.event), location_data=inherited_location), event=self.event) if form.validate_on_submit(): new_session = create_session(self.event, form.data) return self._get_response(new_session) return jsonify_form(form)
def _process(self): settings = track_settings.get_all(self.event) form = ProgramForm(obj=FormDefaults(**settings)) if form.validate_on_submit(): update_program(self.event, form.data) flash(_("The program has been updated.")) return jsonify_data() elif not form.is_submitted(): handle_legacy_description(form.program, settings, get_render_mode=itemgetter('program_render_mode'), get_value=itemgetter('program')) return jsonify_form(form)
def _process(self): defaults = FormDefaults(**rb_settings.get_all()) form = SettingsForm(obj=defaults) if form.validate_on_submit(): rb_settings.set_multi(form.data) flash(_('Settings saved'), 'success') return redirect(url_for('.settings')) return WPAdmin.render_template('rb/settings.html', 'rb-settings', form=form)
def _process(self): form = SearchForm(obj=FormDefaults(exact=True)) form_data = form.data search_results = None num_of_users = User.query.count() num_deleted_users = User.find(is_deleted=True).count() if form.validate_on_submit(): search_results = [] exact = form_data.pop('exact') include_deleted = form_data.pop('include_deleted') include_pending = form_data.pop('include_pending') external = form_data.pop('external') form_data = { k: v for (k, v) in form_data.iteritems() if v and v.strip() } matches = search_users(exact=exact, include_deleted=include_deleted, include_pending=include_pending, external=external, allow_system_user=True, **form_data) for entry in matches: if isinstance(entry, User): search_results.append( UserEntry(profile_url=url_for('.user_profile', entry), user=entry, **{ k: getattr(entry, k) for k in IDENTITY_ATTRIBUTES })) else: search_results.append( UserEntry(profile_url=None, user=None, full_name="{first_name} {last_name}".format( **entry.data.to_dict()), **{ k: entry.data.get(k) for k in (IDENTITY_ATTRIBUTES - {'full_name'}) })) search_results.sort(key=attrgetter('first_name', 'last_name')) num_reg_requests = RegistrationRequest.query.count() return WPUsersAdmin.render_template( 'users_admin.html', 'users', form=form, search_results=search_results, num_of_users=num_of_users, num_deleted_users=num_deleted_users, num_reg_requests=num_reg_requests)
def build_review_form(abstract=None, track=None, review=None): if review: abstract = review.abstract track = review.track review_form_class = make_review_form(abstract.event) reviews_for_track = abstract.get_reviews(user=session.user, group=track) review_for_track = reviews_for_track[0] if reviews_for_track else None if review_for_track: answers = { 'question_{}'.format(rating.question.id): rating.value for rating in review_for_track.ratings } defaults = FormDefaults(obj=review_for_track, **answers) else: defaults = FormDefaults() return review_form_class(prefix='track-{}'.format(track.id), obj=defaults, abstract=abstract, edit=review is not None)