def _get_form_defaults(self):
return FormDefaults(self.survey)
def get_form_defaults(self):
return FormDefaults(self.identity_info['data'])
def _get_form_defaults(self):
return FormDefaults(self.survey, limit_submissions=self.survey.submission_limit is not None)
def _process(self):
form = None
parent_session_block = self.entry.parent.object if self.entry.parent else None
if self.entry.contribution:
contrib = self.entry.contribution
tt_entry_dt = self.entry.start_dt.astimezone(self.event.tzinfo)
form = ContributionEntryForm(obj=FormDefaults(contrib, time=tt_entry_dt.time()),
event=self.event, contrib=contrib, to_schedule=False,
day=tt_entry_dt.date(), session_block=parent_session_block)
if form.validate_on_submit():
with (
track_time_changes(auto_extend=True, user=session.user) as changes,
track_location_changes(),
flash_if_unregistered(self.event, lambda: contrib.person_links)
):
update_contribution(contrib, *get_field_values(form.data))
notifications = get_time_changes_notifications(changes, tzinfo=self.event.tzinfo, entry=self.entry)
return jsonify_data(update=serialize_entry_update(self.entry, session_=self.session),
notifications=notifications)
elif not form.is_submitted():
handle_legacy_description(form.description, contrib)
return jsonify_template('events/contributions/forms/contribution.html', form=form,
fields=form._display_fields, can_manage=True)
elif self.entry.break_:
break_ = self.entry.break_
tt_entry_dt = self.entry.start_dt.astimezone(self.event.tzinfo)
form = BreakEntryForm(obj=FormDefaults(break_, time=tt_entry_dt.time()), event=self.event,
day=tt_entry_dt.date(), session_block=parent_session_block)
if form.validate_on_submit():
with (
track_time_changes(auto_extend=True, user=session.user) as changes,
track_location_changes()
):
update_break_entry(break_, form.data)
notifications = get_time_changes_notifications(changes, tzinfo=self.event.tzinfo, entry=self.entry)
return jsonify_data(update=serialize_entry_update(self.entry, session_=self.session),
notifications=notifications, flash=False)
elif self.entry.session_block:
if self.edit_session:
session_ = self.entry.session_block.session
form = SessionForm(obj=FormDefaults(session_), event=self.event)
if form.validate_on_submit():
with track_location_changes():
update_session(session_, form.data)
return jsonify_data(update=serialize_entry_update(self.entry, session_=self.session), flash=False)
else:
block = self.entry.session_block
tt_entry_dt = self.entry.start_dt.astimezone(self.event.tzinfo)
form = SessionBlockEntryForm(obj=FormDefaults(block, time=tt_entry_dt.time()),
event=self.event, session_block=block, to_schedule=False,
day=tt_entry_dt.date())
if form.validate_on_submit():
with (
track_time_changes(auto_extend=True, user=session.user) as changes,
track_location_changes()
):
update_session_block(block, form.data)
notifications = get_time_changes_notifications(changes, tzinfo=self.event.tzinfo,
entry=self.entry)
return jsonify_data(update=serialize_entry_update(self.entry, session_=self.session),
notifications=notifications, flash=False)
self.commit = False
return jsonify_form(form, fields=getattr(form, '_display_fields', None))
def _get_form_defaults(self, **kwargs):
location_parent = kwargs.pop('location_parent', None)
inherited_location = location_parent.location_data if location_parent else self.event.location_data
inherited_location['inheriting'] = True
return FormDefaults(location_data=inherited_location, **kwargs)
def _get_select_room_form_defaults(self):
start_dt, end_dt, date_changed = get_default_booking_interval(
duration=self.DEFAULT_BOOKING_DURATION,
precision=self.DEFAULT_START_TIME_PRECISION,
force_today=False)
return FormDefaults(start_dt=start_dt, end_dt=end_dt), date_changed
def _get_defaults(self):
permissions = [[serialize_principal(p.principal), list(get_principal_permissions(p, Category))]
for p in self.category.acl_entries]
permissions = [item for item in permissions if item[1]]
return FormDefaults(self.category, permissions=permissions)
def _render_location_field(event, **kwargs):
from indico.modules.events.forms import EventLocationForm
location_data = event.location_data if event else {'inheriting': False}
form = EventLocationForm(obj=FormDefaults(location_data=location_data))
tpl = get_template_module('forms/_form.html')
return tpl.form_row(form.location_data, skip_label=True)
def _get_form(self):
template = self.definition.get_email_body_template(self.event_new)
form_defaults = FormDefaults(body=template.get_html_body())
return AgreementEmailForm(obj=form_defaults,
definition=self.definition,
event=self.event_new)
def _get_defaults(self):
acl = {x.principal for x in self.category.acl_entries if x.read_access}
managers = {x.principal for x in self.category.acl_entries if x.full_access}
event_creators = {x.principal for x in self.category.acl_entries
if x.has_management_role('create', explicit=True)}
return FormDefaults(self.category, acl=acl, managers=managers, event_creators=event_creators)
def _process(self):
roles = {}
event_permissions = event_permissions_schema.dump(self.event).get(
'acl_entries', {})
roles['global'] = self._map_event_to_track_permissions(
event_permissions)
tracks = Track.query.with_parent(self.event).options(
subqueryload('acl_entries'))
tracks_by_id = {str(track.id): track for track in tracks}
for track in tracks:
roles[str(track.id)] = track_permissions_schema.dump(track).get(
'acl_entries', {})
form = AbstractReviewingRolesForm(event=self.event,
obj=FormDefaults(roles=roles))
if form.validate_on_submit():
role_data = form.data['roles']
# Update global permissions
global_conveners = []
global_reviewers = []
global_roles = role_data.pop('global')
for identifier, permissions in global_roles:
principal = principal_from_identifier(
identifier,
allow_groups=True,
allow_event_roles=True,
allow_category_roles=True,
event_id=self.event.id)
if 'convene' in permissions:
global_conveners.append(principal)
if 'review' in permissions:
global_reviewers.append(principal)
update_object_principals(self.event,
global_conveners,
permission='convene_all_abstracts')
update_object_principals(self.event,
global_reviewers,
permission='review_all_abstracts')
# Update track specific permissions
track_conveners = []
track_reviewers = []
for (track_id, track_roles) in role_data.items():
acl_entries = {}
for identifier, permissions in track_roles:
principal = principal_from_identifier(
identifier,
allow_groups=True,
allow_event_roles=True,
allow_category_roles=True,
event_id=self.event.id)
acl_entries[principal] = set(permissions)
if 'convene' in permissions:
track_conveners.append(principal)
if 'review' in permissions:
track_reviewers.append(principal)
track = tracks_by_id[track_id]
current = {
e.principal: get_unified_permissions(e)
for e in track.acl_entries
}
update_principals_permissions(track, current, acl_entries)
# Update event ACL for track and global permissions
all_conveners = set(global_conveners + track_conveners)
all_reviewers = set(global_reviewers + track_reviewers)
update_object_principals(self.event,
all_conveners,
permission='track_convener')
update_object_principals(self.event,
all_reviewers,
permission='abstract_reviewer')
flash(_("Abstract reviewing roles have been updated."), 'success')
logger.info(
"Abstract reviewing roles of %s have been updated by %s",
self.event, session.user)
return jsonify_data()
return jsonify_form(form,
skip_labels=True,
form_header_kwargs={'id': 'reviewing-role-form'},
disabled_until_change=False)
def _checkParams(self):
defaults = FormDefaults(location=Location.default_location)
self._form = SearchRoomsForm(self._get_form_data(), obj=defaults, csrf_enabled=False)
if (not session.user or not Room.user_owns_rooms(session.user)) and not hasattr(self, 'search_criteria'):
# Remove the form element if the user has no rooms and we are not using a shortcut
del self._form.is_only_my_rooms
def _process(self):
defaults = FormDefaults(self.attachment,
protected=self.attachment.is_self_protected,
skip_attrs={'file'})
if self.attachment.type == AttachmentType.file:
file_ = self.attachment.file
# file_attrs has to be manually "serialized", since it's going to be converted to JSON
file_attrs = {
'url':
url_for('attachments.download',
self.attachment,
filename=self.attachment.file.filename,
from_preview='1'),
'filename':
file_.filename,
'size':
file_.size,
'content_type':
file_.content_type
}
form = EditAttachmentFileForm(linked_object=self.object,
obj=defaults,
file=file_attrs)
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 = request.files['file'] if request.files else None
if file:
self.attachment.file = AttachmentFile(
user=session.user,
content_type=file.mimetype,
filename=secure_filename(file.filename, 'attachment'))
self.attachment.file.save(file.file)
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 = SearchForm(obj=FormDefaults(exact=True))
form_data = form.data
search_results = None
num_of_users = User.query.count()
num_deleted_users = User.query.filter_by(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.items() if v and v.strip()
}
matches = search_users(exact=exact,
include_deleted=include_deleted,
include_pending=include_pending,
include_blocked=True,
external=external,
allow_system_user=True,
**form_data)
for entry in matches:
if isinstance(entry, User):
search_results.append(
UserEntry(avatar_url=entry.avatar_url,
profile_url=url_for('.user_profile', entry),
user=entry,
**{
k: getattr(entry, k)
for k in IDENTITY_ATTRIBUTES
}))
else:
if not entry.data['first_name'] and not entry.data[
'last_name']:
full_name = '<no name>'
initial = '?'
else:
full_name = f'{entry.data["first_name"]} {entry.data["last_name"]}'.strip(
)
initial = full_name[0]
search_results.append(
UserEntry(avatar_url=url_for('assets.avatar',
name=initial),
profile_url=None,
user=None,
full_name=full_name,
**{
k: entry.data.get(k)
for k in (IDENTITY_ATTRIBUTES -
{'full_name'})
}))
search_results.sort(key=attrgetter('full_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 _get_form_defaults(self):
defaults = FormDefaults(**layout_settings.get_all(self.event_new))
defaults.timetable_theme = self.event_new.theme
return defaults
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 _get_form_defaults(self):
return FormDefaults(self.regform,
limit_registrations=self.regform.registration_limit
is not None)
def _create_form(self):
form_user = session.user or self.abstract.submitter
abstract_form_cls = make_abstract_form(self.event, form_user)
custom_field_values = {f'custom_{x.contribution_field_id}': x.data for x in self.abstract.field_values}
form_defaults = FormDefaults(self.abstract, **custom_field_values)
return abstract_form_cls(obj=form_defaults, event=self.event, abstract=self.abstract)
def _get_form_defaults(self):
defaults = FormDefaults(**layout_settings.get_all(self.event))
defaults.timetable_theme = self.event.theme
return defaults
def _render_keywords_field(event, **kwargs):
from indico.modules.events.forms import EventKeywordsForm
form = EventKeywordsForm(obj=FormDefaults(keywords=event.keywords))
tpl = get_template_module('forms/_form.html')
return tpl.form_row(form.keywords, skip_label=True)