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)
self.commit = False
return jsonify_template('events/contributions/forms/contribution.html',
form=form)
def _process(self):
form = SessionForm(obj=self.session, event=self.event)
if form.validate_on_submit():
with track_location_changes():
update_session(self.session, form.data)
return jsonify_data(html=_render_session_list(self.event))
return jsonify_form(form)
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 update_session(event_session, data):
"""Update a session based on the information in the `data`."""
with track_location_changes():
event_session.populate_from_dict(data)
db.session.flush()
signals.event.session_updated.send(event_session)
event_session.event.log(
EventLogRealm.management,
EventLogKind.change,
'Sessions',
f'Session "{event_session.title}" has been updated',
session.user,
meta={'session_id': event_session.id})
logger.info('Session %s modified by %s', event_session, session.user)
def _process(self):
args = self.args
args.setdefault('booked_for_user', session.user)
admin_override = args['admin_override_enabled']
if not is_booking_start_within_grace_period(
args['start_dt'], session.user, admin_override):
raise ExpectedError(
_('You cannot create a booking which starts in the past'))
# Check that the booking is not longer than allowed
booking_limit_days = self.room.booking_limit_days or rb_settings.get(
'booking_limit')
if not self._validate_room_booking_limit(
args['start_dt'], args['end_dt'], booking_limit_days):
msg = (
_('Bookings for the room "{}" may not be longer than {} days'
).format(self.room.name, booking_limit_days))
raise ExpectedError(msg)
try:
resv = Reservation.create_from_data(
self.room,
args,
session.user,
prebook=self.prebook,
ignore_admin=(not admin_override))
with track_location_changes():
if args.get('link_type') is not None and args.get(
'link_id') is not None:
self._link_booking(resv, args['link_type'],
args['link_id'], args['link_back'])
db.session.flush()
except NoReportError as e:
db.session.rollback()
raise ExpectedError(str(e))
serialized_occurrences = serialize_occurrences(
group_by_occurrence_date(resv.occurrences.all()))
if self.prebook:
data = {'pre_bookings': serialized_occurrences}
else:
data = {'bookings': serialized_occurrences}
return jsonify(room_id=self.room.id,
booking=reservation_details_schema.dump(resv),
calendar_data=data)
def update_contribution(contrib, contrib_data, custom_fields_data=None):
"""Update a contribution.
:param contrib: The `Contribution` to update
:param contrib_data: A dict containing the data to update
:param custom_fields_data: A dict containing the data for custom
fields.
:return: A dictionary containing information related to the
update. `unscheduled` will be true if the modification
resulted in the contribution being unscheduled. In this
case `undo_unschedule` contains the necessary data to
re-schedule it (undoing the session change causing it to
be unscheduled)
"""
rv = {'unscheduled': False, 'undo_unschedule': None}
current_session_block = contrib.session_block
start_dt = contrib_data.pop('start_dt', None)
if start_dt is not None:
update_timetable_entry(contrib.timetable_entry, {'start_dt': start_dt})
with track_location_changes():
changes = contrib.populate_from_dict(contrib_data)
if custom_fields_data:
changes.update(set_custom_fields(contrib, custom_fields_data))
if 'session' in contrib_data:
timetable_entry = contrib.timetable_entry
if timetable_entry is not None and _ensure_consistency(contrib):
rv['unscheduled'] = True
rv['undo_unschedule'] = {
'start_dt':
timetable_entry.start_dt.isoformat(),
'contribution_id':
contrib.id,
'session_block_id':
current_session_block.id if current_session_block else None,
'force':
True
}
db.session.flush()
if changes:
signals.event.contribution_updated.send(contrib, changes=changes)
logger.info('Contribution %s updated by %s', contrib, session.user)
contrib.log(EventLogRealm.management, EventLogKind.change,
'Contributions',
f'Contribution "{contrib.title}" has been updated',
session.user)
return rv
def update_session_block(session_block, data):
"""Update a session block with data passed in the `data` argument."""
from indico.modules.events.timetable.operations import update_timetable_entry
start_dt = data.pop('start_dt', None)
if start_dt is not None:
session_block.timetable_entry.move(start_dt)
update_timetable_entry(session_block.timetable_entry,
{'start_dt': start_dt})
with track_location_changes():
session_block.populate_from_dict(data)
db.session.flush()
signals.event.session_block_updated.send(session_block)
session_block.event.log(
EventLogRealm.management,
EventLogKind.change,
'Sessions',
f'Session block "{session_block.title}" has been updated',
session.user,
meta={'session_block_id': session_block.id})
logger.info('Session block %s modified by %s', session_block, session.user)
def _clone_location(self, new_event):
with track_location_changes():
new_event.location_data = self.old_event.location_data
db.session.flush()
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)
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 _update(self, form_data):
with track_location_changes():
return super()._update(form_data)