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)
