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)