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_new.tzinfo) form = ContributionEntryForm(obj=FormDefaults(contrib, time=tt_entry_dt.time()), event=self.event_new, 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: with flash_if_unregistered(self.event_new, lambda: contrib.person_links): update_contribution(contrib, *get_field_values(form.data)) notifications = get_time_changes_notifications(changes, tzinfo=self.event_new.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_new.tzinfo) form = BreakEntryForm(obj=FormDefaults(break_, time=tt_entry_dt.time()), event=self.event_new, 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: update_break_entry(break_, form.data) notifications = get_time_changes_notifications(changes, tzinfo=self.event_new.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_new) if form.validate_on_submit(): 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_new.tzinfo) form = SessionBlockEntryForm(obj=FormDefaults(block, time=tt_entry_dt.time()), event=self.event_new, 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: update_session_block(block, form.data) notifications = get_time_changes_notifications(changes, tzinfo=self.event_new.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 _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: with 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: 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(): 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: 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 _process(self): data = request.json required_keys = {'contribution_ids', 'day'} allowed_keys = required_keys | {'session_block_id'} if data.viewkeys() > allowed_keys: raise BadRequest('Invalid keys found') elif required_keys > data.viewkeys(): raise BadRequest('Required keys missing') entries = [] day = dateutil.parser.parse(data['day']).date() query = Contribution.query.with_parent(self.event_new).filter(Contribution.id.in_(data['contribution_ids'])) with track_time_changes(auto_extend='end', user=session.user) as changes: for contribution in query: start_dt = find_next_start_dt(contribution.duration, obj=self.session_block or self.event_new, day=None if self.session_block else day, force=True) entry = self._schedule(contribution, start_dt) if entry.end_dt.astimezone(entry.event_new.tzinfo).date() > day: raise UserValueError(_("Contribution '{}' could not be scheduled since it doesn't fit on this day.") .format(contribution.title)) entries.append(entry) notifications = get_time_changes_notifications(changes, tzinfo=self.event_new.tzinfo) return jsonify_data(update=serialize_entry_update(entries[0], session_=self.session) if entries else None, notifications=notifications, flash=False)
def _process_POST(self): self.serializer = TimetableSerializer(True) with track_time_changes(auto_extend=True, user=session.user) as changes: entry_data = self._move_entry(request.json) rv = dict(serialize_entry_update(self.entry), **entry_data) notifications = get_time_changes_notifications(changes, tzinfo=self.event_new.tzinfo, entry=self.entry) return jsonify_data(flash=False, entry=rv, notifications=notifications)
def _process(self): data = request.json required_keys = {'contribution_ids', 'day'} allowed_keys = required_keys | {'session_block_id'} if set(data.viewkeys()) > allowed_keys: raise BadRequest('Invalid keys found') elif required_keys > set(data.viewkeys()): raise BadRequest('Required keys missing') entries = [] day = dateutil.parser.parse(data['day']).date() query = Contribution.query.with_parent(self.event_new).filter( Contribution.id.in_(data['contribution_ids'])) with track_time_changes(auto_extend='end', user=session.user) as changes: for contribution in query: start_dt = find_next_start_dt( contribution.duration, obj=self.session_block or self.event_new, day=None if self.session_block else day, force=True) entry = self._schedule(contribution, start_dt) if entry.end_dt.astimezone( entry.event_new.tzinfo).date() > day: raise UserValueError( _("Contribution '{}' could not be scheduled since it doesn't fit on this day." ).format(contribution.title)) entries.append(entry) notifications = get_time_changes_notifications( changes, tzinfo=self.event_new.tzinfo) return jsonify_data(update=serialize_entry_update( entries[0], session_=self.session) if entries else None, notifications=notifications, flash=False)
def _process(self): item = self.entry.object entry_dt = self.entry.start_dt.astimezone(self.event_new.tzinfo) form = BaseEntryForm(obj=FormDefaults(item, time=entry_dt.time()), day=entry_dt.date(), event=self.event_new, entry=self.entry, session_block=self.entry.parent.object if self.entry.parent else None) data = form.data shift_later = data.pop('shift_later') updated_entries = [] if form.validate_on_submit(): with track_time_changes(auto_extend=True, user=session.user) as changes: if shift_later: new_end_dt = form.start_dt.data + form.duration.data shift = new_end_dt - self.entry.end_dt updated_entries += shift_following_entries(self.entry, shift, session_=self.session) if self.entry.contribution: update_timetable_entry(self.entry, {'start_dt': form.start_dt.data}) update_contribution(item, {'duration': form.duration.data}) elif self.entry.break_: update_break_entry(item, data) elif self.entry.session_block: update_session_block(item, data) notifications = get_time_changes_notifications(changes, tzinfo=self.event_new.tzinfo, entry=self.entry) updated_entries.append(item.timetable_entry) return jsonify_data(entries=[serialize_entry_update(entry) for entry in updated_entries], flash=False, shift_later=shift_later, notifications=notifications) self.commit = False return jsonify_form(form, back_button=False, disabled_until_change=True)
def _process(self): item = self.entry.object entry_dt = self.entry.start_dt.astimezone(self.event.tzinfo) form = BaseEntryForm(obj=FormDefaults(item, time=entry_dt.time()), day=entry_dt.date(), event=self.event, entry=self.entry, session_block=self.entry.parent.object if self.entry.parent else None) data = form.data shift_later = data.pop('shift_later') if form.validate_on_submit(): with track_time_changes(auto_extend=True, user=session.user) as changes: if shift_later: new_end_dt = form.start_dt.data + form.duration.data shift = new_end_dt - self.entry.end_dt shift_following_entries(self.entry, shift, session_=self.session) if self.entry.contribution: update_timetable_entry(self.entry, {'start_dt': form.start_dt.data}) update_contribution(item, {'duration': form.duration.data}) elif self.entry.break_: update_break_entry(item, data) elif self.entry.session_block: update_session_block(item, 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, back_button=False, disabled_until_change=True)
def _process(self): form = ContributionStartDateForm(obj=FormDefaults(start_dt=self.contrib.start_dt), contrib=self.contrib) if form.validate_on_submit(): with track_time_changes(): update_timetable_entry(self.contrib.timetable_entry, {'start_dt': form.start_dt.data}) return jsonify_data(new_value=format_datetime(self.contrib.start_dt, 'short')) return jsonify_form(form, back_button=False, disabled_until_change=True)
def _process(self): form = ContributionDurationForm(obj=FormDefaults(self.contrib), contrib=self.contrib) if form.validate_on_submit(): with track_time_changes(): update_contribution(self.contrib, {'duration': form.duration.data}) return jsonify_data(new_value=format_human_timedelta(self.contrib.duration)) return jsonify_form(form, back_button=False, disabled_until_change=True)
def _process(self): defaults = self._get_form_defaults(location_parent=self.session_block) form = ContributionEntryForm(obj=defaults, to_schedule=True, **self._get_form_params()) if form.validate_on_submit(): contrib = Contribution() with track_time_changes(auto_extend=True, user=session.user) as changes: with flash_if_unregistered(self.event_new, lambda: contrib.person_links): contrib = create_contribution( self.event_new, form.data, session_block=self.session_block, extend_parent=True) entry = contrib.timetable_entry notifications = get_time_changes_notifications( changes, tzinfo=self.event_new.tzinfo, entry=entry) return jsonify_data( entries=[serialize_entry_update(entry, session_=self.session)], notifications=notifications) self.commit = False return jsonify_template('events/contributions/forms/contribution.html', form=form, fields=form._display_fields)
def _process(self): direction = request.form['direction'] with track_time_changes(): swap_timetable_entry(self.entry, direction, session_=self.session) return jsonify_data(flash=False, update=serialize_entry_update( self.entry, session_=self.session))
def _process(self): contrib_form_class = make_contribution_form(self.event_new) 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_new, contrib=self.contrib, session_block=parent_session_block) if form.validate_on_submit(): with track_time_changes(): update_contribution(self.contrib, *_get_field_values(form.data)) flash( _("Contribution '{}' successfully updated").format( self.contrib.title), 'success') tpl_components = self.reporter.render_contrib_report(self.contrib) if tpl_components['hide_contrib']: self.reporter.flash_info_message(self.contrib) return jsonify_data(**tpl_components) self.commit = False return jsonify_template('events/contributions/forms/contribution.html', form=form)
def _process(self): new_start_dt = self.event_new.tzinfo.localize( dateutil.parser.parse( request.form.get('startDate'))).astimezone(utc) new_end_dt = self.event_new.tzinfo.localize( dateutil.parser.parse(request.form.get('endDate'))).astimezone(utc) new_duration = new_end_dt - new_start_dt is_session_block = self.entry.type == TimetableEntryType.SESSION_BLOCK tzinfo = self.event_new.tzinfo if is_session_block and new_end_dt.astimezone(tzinfo).date( ) != self.entry.start_dt.astimezone(tzinfo).date(): raise UserValueError( _('Session block cannot span more than one day')) with track_time_changes(auto_extend=True, user=session.user) as changes: update_timetable_entry_object(self.entry, {'duration': new_duration}) if is_session_block: self.entry.move(new_start_dt) if not is_session_block: update_timetable_entry(self.entry, {'start_dt': new_start_dt}) if is_session_block and self.entry.children: if new_end_dt < max(self.entry.children, key=attrgetter('end_dt')).end_dt: raise UserValueError( _("Session block cannot be shortened this much because contributions contained " "wouldn't fit.")) notifications = get_time_changes_notifications( changes, tzinfo=self.event_new.tzinfo, entry=self.entry) return jsonify_data(flash=False, update=serialize_entry_update( self.entry, session_=self.session), notifications=notifications)
def _process_POST(self): self.serializer = TimetableSerializer(self.event, management=True) with track_time_changes(auto_extend=True, user=session.user) as changes: entry_data = self._move_entry(request.json) rv = serialize_entry_update(self.entry) | entry_data notifications = get_time_changes_notifications(changes, tzinfo=self.event.tzinfo, entry=self.entry) return jsonify_data(flash=False, entry=rv, notifications=notifications)
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): defaults = FormDefaults(self.event, update_timetable=True) form = EventDatesForm(obj=defaults, event=self.event) if form.validate_on_submit(): with track_time_changes(): update_event(self.event, **form.data) return self.jsonify_success() show_screen_dates = form.has_displayed_dates and (form.start_dt_override.data or form.end_dt_override.data) return jsonify_template('events/management/event_dates.html', form=form, show_screen_dates=show_screen_dates)
def _process(self): defaults = self._get_form_defaults(location_parent=self.session) form = SessionBlockEntryForm(obj=defaults, **self._get_form_params()) if form.validate_on_submit(): with track_time_changes(auto_extend=True, user=session.user) as changes: entry = create_session_block_entry(self.session, form.data) notifications = get_time_changes_notifications(changes, tzinfo=self.event_new.tzinfo, entry=entry) return jsonify_data(entry=serialize_entry_update(entry), notifications=notifications, flash=False) self.commit = False return jsonify_form(form, fields=form._display_fields, disabled_until_change=False)
def _process(self): new_start_dt = (self.event_new.tzinfo.localize(dateutil.parser.parse(request.form.get('startDate'))) .astimezone(utc)) shift = new_start_dt - self.entry.start_dt with track_time_changes(auto_extend=True, user=session.user) as changes: shift_following_entries(self.entry, shift, session_=self.session) self.entry.move(new_start_dt) notifications = get_time_changes_notifications(changes, tzinfo=self.event_new.tzinfo, entry=self.entry) return jsonify_data(flash=False, update=serialize_entry_update(self.entry, session_=self.session), notifications=notifications)
def _process(self): colors = self._get_default_colors() defaults = self._get_form_defaults(colors=colors, location_parent=self.session_block) form = BreakEntryForm(obj=defaults, **self._get_form_params()) if form.validate_on_submit(): with track_time_changes(auto_extend=True, user=session.user) as changes: entry = create_break_entry(self.event_new, form.data, session_block=self.session_block) notifications = get_time_changes_notifications(changes, tzinfo=self.event_new.tzinfo, entry=entry) return jsonify_data(entry=serialize_entry_update(entry), notifications=notifications, flash=False) return jsonify_form(form, fields=form._display_fields)
def _process(self): new_start_dt = (self.event.tzinfo.localize(dateutil.parser.parse(request.form.get('startDate'))) .astimezone(utc)) shift = new_start_dt - self.entry.start_dt with track_time_changes(auto_extend=True, user=session.user) as changes: shift_following_entries(self.entry, shift, session_=self.session) self.entry.move(new_start_dt) notifications = get_time_changes_notifications(changes, tzinfo=self.event.tzinfo, entry=self.entry) return jsonify_data(flash=False, update=serialize_entry_update(self.entry, session_=self.session), notifications=notifications)
def _process(self): colors = self._get_default_colors() defaults = self._get_form_defaults(colors=colors, location_parent=self.session_block) form = BreakEntryForm(obj=defaults, **self._get_form_params()) if form.validate_on_submit(): with track_time_changes(auto_extend=True, user=session.user) as changes: entry = create_break_entry(self.event, form.data, session_block=self.session_block) notifications = get_time_changes_notifications(changes, tzinfo=self.event.tzinfo, entry=entry) return jsonify_data(update=serialize_entry_update(entry, session_=self.session), notifications=notifications, flash=False) return jsonify_form(form, fields=form._display_fields)
def _process(self): sess = self.session if not self.session_block else None rescheduler = Rescheduler(self.event, RescheduleMode[request.json['mode']], self.day, session=sess, session_block=self.session_block, fit_blocks=request.json['fit_blocks'], gap=timedelta(minutes=request.json['gap'])) with track_time_changes(auto_extend='end', user=session.user) as changes: rescheduler.run() notifications = get_time_changes_notifications(changes, tzinfo=self.event.tzinfo) for notification in notifications: flash(notification, 'highlight') return jsonify_data(flash=False)
def _process(self): defaults = self._get_form_defaults(location_parent=self.parent_session) form = SessionBlockEntryForm(obj=defaults, **self._get_form_params()) if form.validate_on_submit(): with track_time_changes(auto_extend=True, user=session.user) as changes: entry = create_session_block_entry(self.parent_session, form.data) notifications = get_time_changes_notifications(changes, tzinfo=self.event.tzinfo, entry=entry) return jsonify_data(update=serialize_entry_update(entry, session_=self.session), notifications=notifications, flash=False) self.commit = False return jsonify_form(form, fields=form._display_fields, disabled_until_change=False)
def _process(self): sess = self.session if not self.session_block else None rescheduler = Rescheduler(self.event_new, RescheduleMode[request.json['mode']], self.day, session=sess, session_block=self.session_block, fit_blocks=request.json['fit_blocks'], gap=timedelta(minutes=request.json['gap'])) with track_time_changes(auto_extend='end', user=session.user) as changes: rescheduler.run() notifications = get_time_changes_notifications(changes, tzinfo=self.event_new.tzinfo) for notification in notifications: flash(notification, 'highlight') return jsonify_data(flash=False)
def _process(self): defaults = self._get_form_defaults(location_parent=self.session_block) form = ContributionEntryForm(obj=defaults, to_schedule=True, **self._get_form_params()) if form.validate_on_submit(): with track_time_changes(auto_extend=True, user=session.user) as changes: contrib = create_contribution(self.event_new, form.data, session_block=self.session_block, extend_parent=True) entry = contrib.timetable_entry notifications = get_time_changes_notifications(changes, tzinfo=self.event_new.tzinfo, entry=entry) return jsonify_data(entries=[serialize_entry_update(entry)], notifications=notifications, flash=False) self.commit = False return jsonify_template('events/contributions/forms/contribution.html', form=form, fields=form._display_fields)
def _process_PATCH(self): """Update a timetable entry""" data = request.json # TODO: support breaks if set(data.viewkeys()) > {'start_dt'}: raise BadRequest('Invalid keys found') updates = {} if 'start_dt' in data: updates['start_dt'] = dateutil.parser.parse(data['start_dt']) if updates: with track_time_changes(): update_timetable_entry(self.entry, updates) return jsonify()
def _getAnswer(self): ContextManager.set("dateChangeNotificationProblems", {}) if self._shiftTimes: moveEntries = 1 else: moveEntries = 0 # first sanity check if self._startDate > self._endDate: raise ServiceError("ERR-E3", "Date/time of start cannot " "be greater than date/time of end") # catch TimingErrors that can be returned by the algorithm try: with track_time_changes(): self._target.setDates(self._startDate, self._endDate, moveEntries=moveEntries) except TimingError, e: raise TimingNoReportError(e.getMessage(), title=_("Cannot set event dates"), explanation=e.getExplanation())
def _process(self): contrib_form_class = make_contribution_form(self.event_new) 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_new, contrib=self.contrib, session_block=parent_session_block) if form.validate_on_submit(): with track_time_changes(): update_contribution(self.contrib, *_get_field_values(form.data)) flash(_("Contribution '{}' successfully updated").format(self.contrib.title), 'success') tpl_components = self.reporter.render_contrib_report(self.contrib) if tpl_components['hide_contrib']: self.reporter.flash_info_message(self.contrib) return jsonify_data(**tpl_components) self.commit = False return jsonify_template('events/contributions/forms/contribution.html', 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): new_start_dt = self.event_new.tzinfo.localize( dateutil.parser.parse(request.form.get('startDate'))).astimezone(utc) new_end_dt = self.event_new.tzinfo.localize(dateutil.parser.parse(request.form.get('endDate'))).astimezone(utc) new_duration = new_end_dt - new_start_dt is_session_block = self.entry.type == TimetableEntryType.SESSION_BLOCK tzinfo = self.event_new.tzinfo if is_session_block and new_end_dt.astimezone(tzinfo).date() != self.entry.start_dt.astimezone(tzinfo).date(): raise UserValueError(_('Session block cannot span more than one day')) with track_time_changes(auto_extend=True, user=session.user) as changes: update_timetable_entry_object(self.entry, {'duration': new_duration}) if is_session_block: self.entry.move(new_start_dt) if not is_session_block: update_timetable_entry(self.entry, {'start_dt': new_start_dt}) if is_session_block and self.entry.children: if new_end_dt < max(self.entry.children, key=attrgetter('end_dt')).end_dt: raise UserValueError(_("Session block cannot be shortened this much because contributions contained " "wouldn't fit.")) notifications = get_time_changes_notifications(changes, tzinfo=self.event_new.tzinfo, entry=self.entry) return jsonify_data(flash=False, entry=serialize_entry_update(self.entry), notifications=notifications)
def _getAnswer(self): ContextManager.set('dateChangeNotificationProblems', {}) if (self._shiftTimes): moveEntries = 1 else: moveEntries = 0 # first sanity check if (self._startDate > self._endDate): raise ServiceError("ERR-E3", "Date/time of start cannot " "be greater than date/time of end") # catch TimingErrors that can be returned by the algorithm try: with track_time_changes(): self._target.setDates(self._startDate, self._endDate, moveEntries=moveEntries) except TimingError, e: raise TimingNoReportError(e.getMessage(), title=_("Cannot set event dates"), explanation=e.getExplanation())
class UtilsConference: @staticmethod def get_start_dt(params): tz = params['Timezone'] try: return timezone(tz).localize( datetime(int(params['sYear']), int(params['sMonth']), int(params['sDay']), int(params['sHour']), int(params['sMinute']))) except ValueError as e: raise FormValuesError( 'The start date you have entered is not correct: {}'.format(e), 'Event') @staticmethod def get_end_dt(params, start_dt): tz = params['Timezone'] if params.get('duration'): end_dt = start_dt + timedelta(minutes=params['duration']) else: try: end_dt = timezone(tz).localize( datetime(int(params['eYear']), int(params['eMonth']), int(params['eDay']), int(params['eHour']), int(params['eMinute']))) except ValueError as e: raise FormValuesError( 'The end date you have entered is not correct: {}'.format( e), 'Event') return end_dt @staticmethod def get_location_data(params): location_data = json.loads(params['location_data']) if location_data.get('room_id'): location_data['room'] = Room.get_one(location_data['room_id']) if location_data.get('venue_id'): location_data['venue'] = Location.get_one( location_data['venue_id']) return location_data @classmethod def setValues(cls, c, confData, notify=False): c.setTitle(confData["title"]) c.setDescription(confData["description"]) c.setOrgText(confData.get("orgText", "")) c.setComments(confData.get("comments", "")) c.as_event.keywords = confData["keywords"] c.setChairmanText(confData.get("chairText", "")) if "shortURLTag" in confData.keys(): tag = confData["shortURLTag"].strip() if tag: try: UtilsConference.validateShortURL(tag, c) except ValueError, e: raise FormValuesError(e.message) if c.getUrlTag() != tag: mapper = ShortURLMapper() mapper.remove(c) c.setUrlTag(tag) if tag: mapper.add(tag, c) c.setContactInfo(confData.get("contactInfo", "")) ################################# # Fermi timezone awareness # ################################# c.setTimezone(confData["Timezone"]) sDate = cls.get_start_dt(confData) eDate = cls.get_end_dt(confData, sDate) moveEntries = int(confData.get("move", 0)) with track_time_changes(): c.setDates(sDate.astimezone(timezone('UTC')), eDate.astimezone(timezone('UTC')), moveEntries=moveEntries) ################################# # Fermi timezone awareness(end) # ################################# old_location_data = c.as_event.location_data location_data = cls.get_location_data(confData) update_event(c.as_event, {'location_data': location_data}) if old_location_data != location_data: signals.event.data_changed.send(c, attr='location', old=old_location_data, new=location_data) emailstr = setValidEmailSeparators(confData.get("supportEmail", "")) if (emailstr != "") and not validMail(emailstr): raise FormValuesError( "One of the emails specified or one of the separators is invalid" ) c.getSupportInfo().setEmail(emailstr) c.getSupportInfo().setCaption(confData.get("supportCaption", "Support")) # TODO: remove TODO once visibility has been updated if c.getVisibility() != confData.get( "visibility", 999) and confData.get('visibility') != 'TODO': c.setVisibility(confData.get("visibility", 999)) theme = confData.get('defaultStyle', '') new_type = EventType.legacy_map[confData[ 'eventType']] if 'eventType' in confData else c.as_event.type_ if new_type != c.as_event.type_: c.as_event.type_ = new_type elif not theme or theme == theme_settings.defaults.get( new_type.legacy_name): # if it's the default theme or nothing was set (does this ever happen?!), we don't store it layout_settings.delete(c, 'timetable_theme') else: # set the new theme layout_settings.set(c, 'timetable_theme', theme)
def import_contributions_from_csv(event, f): """Import timetable contributions from a CSV file into an event.""" with csv_text_io_wrapper(f) as ftxt: reader = csv.reader(ftxt.read().splitlines()) contrib_data = [] for num_row, row in enumerate(reader, 1): try: start_dt, duration, title, first_name, last_name, affiliation, email = ( value.strip() for value in row) email = email.lower() except ValueError: raise UserValueError( _('Row {}: malformed CSV data - please check that the number of columns is correct' ).format(num_row)) try: parsed_start_dt = event.tzinfo.localize( dateutil.parser.parse(start_dt)) if start_dt else None except ValueError: raise UserValueError( _('Row {row}: can\'t parse date: "{date}"').format( row=num_row, date=start_dt)) try: parsed_duration = timedelta( minutes=int(duration)) if duration else None except ValueError: raise UserValueError( _("Row {row}: can't parse duration: {duration}").format( row=num_row, duration=duration)) if not title: raise UserValueError( _('Row {}: contribution title is required').format(num_row)) if email and not validate_email(email): raise UserValueError( _('Row {row}: invalid email address: {email}').format( row=num_row, email=email)) contrib_data.append({ 'start_dt': parsed_start_dt, 'duration': parsed_duration or timedelta(minutes=20), 'title': title, 'speaker': { 'first_name': first_name, 'last_name': last_name, 'affiliation': affiliation, 'email': email } }) # now that we're sure the data is OK, let's pre-allocate the friendly ids # for the contributions in question Contribution.allocate_friendly_ids(event, len(contrib_data)) contributions = [] all_changes = defaultdict(list) for contrib_fields in contrib_data: speaker_data = contrib_fields.pop('speaker') with track_time_changes() as changes: contribution = create_contribution(event, contrib_fields, extend_parent=True) contributions.append(contribution) for key, val in changes[event].items(): all_changes[key].append(val) email = speaker_data['email'] if not email: continue # set the information of the speaker person = get_event_person(event, speaker_data) link = ContributionPersonLink(person=person, is_speaker=True) link.populate_from_dict({ 'first_name': speaker_data['first_name'], 'last_name': speaker_data['last_name'], 'affiliation': speaker_data['affiliation'] }) contribution.person_links.append(link) return contributions, all_changes
def _process(self): direction = request.form['direction'] with track_time_changes(): swap_timetable_entry(self.entry, direction, session_=self.session) return jsonify_data(flash=False, update=serialize_entry_update(self.entry, session_=self.session))
def import_contributions_from_csv(event, f): """Import timetable contributions from a CSV file into an event.""" reader = csv.reader(f) contributions = [] all_changes = defaultdict(list) for num_row, row in enumerate(reader, 1): try: start_dt, duration, title, first_name, last_name, affiliation, email = row except ValueError: raise UserValueError( _('Row {}: malformed CSV data - please check that the number of columns is correct' ).format(num_row)) try: parsed_start_dt = event.tzinfo.localize( dateutil.parser.parse(start_dt)) if start_dt else None except ValueError: raise UserValueError( _("Row {}: can't parse date: \"{}\"").format( num_row, start_dt)) try: parsed_duration = timedelta( minutes=int(duration)) if duration else None except ValueError: raise UserValueError( _("Row {}: can't parse duration: {}").format( num_row, duration)) if not title: raise UserValueError( _("Row {}: contribution title is required").format(num_row)) with track_time_changes() as changes: contribution = create_contribution( event, { 'start_dt': parsed_start_dt, 'duration': parsed_duration or timedelta(minutes=20), 'title': title }, extend_parent=True) contributions.append(contribution) for key, val in changes[event].viewitems(): all_changes[key].append(val) if not email: continue # set the information of the speaker person = get_event_person( event, { 'firstName': first_name, 'familyName': last_name, 'affiliation': affiliation, 'email': email }) link = ContributionPersonLink(person=person, is_speaker=True) link.populate_from_dict({ 'first_name': first_name, 'last_name': last_name, 'affiliation': affiliation, 'email': email }) contribution.person_links.append(link) return contributions, all_changes
def _process(self): with track_time_changes(): fit_session_block_entry(self.session_block.timetable_entry) return jsonify_data(flash=False)
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_new.tzinfo) form = ContributionEntryForm(obj=FormDefaults( contrib, time=tt_entry_dt.time()), event=self.event_new, 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: update_contribution(contrib, *_get_field_values(form.data)) notifications = get_time_changes_notifications( changes, tzinfo=self.event_new.tzinfo, entry=self.entry) return jsonify_data( entries=[serialize_entry_update(contrib.timetable_entry)], notifications=notifications, flash=False) 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_new.tzinfo) form = BreakEntryForm(obj=FormDefaults(break_, time=tt_entry_dt.time()), event=self.event_new, 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: update_break_entry(break_, form.data) notifications = get_time_changes_notifications( changes, tzinfo=self.event_new.tzinfo, entry=self.entry) return jsonify_data( entries=[serialize_entry_update(break_.timetable_entry)], 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_new) if form.validate_on_submit(): update_session(session_, form.data) return jsonify_data(entries=[ serialize_entry_update(x.timetable_entry) for x in session_.blocks ], flash=False) else: block = self.entry.session_block tt_entry_dt = self.entry.start_dt.astimezone( self.event_new.tzinfo) form = SessionBlockEntryForm(obj=FormDefaults( block, time=tt_entry_dt.time()), event=self.event_new, 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: update_session_block(block, form.data) notifications = get_time_changes_notifications( changes, tzinfo=self.event_new.tzinfo, entry=self.entry) return jsonify_data(entries=[ serialize_entry_update(block.timetable_entry) ], notifications=notifications, flash=False) self.commit = False return jsonify_form(form, fields=getattr(form, '_display_fields', None))
def import_contributions_from_csv(event, f): """Import timetable contributions from a CSV file into an event.""" reader = csv.reader(f.read().splitlines()) contrib_data = [] for num_row, row in enumerate(reader, 1): try: start_dt, duration, title, first_name, last_name, affiliation, email = \ [to_unicode(value).strip() for value in row] email = email.lower() except ValueError: raise UserValueError(_('Row {}: malformed CSV data - please check that the number of columns is correct') .format(num_row)) try: parsed_start_dt = event.tzinfo.localize(dateutil.parser.parse(start_dt)) if start_dt else None except ValueError: raise UserValueError(_("Row {row}: can't parse date: \"{date}\"").format(row=num_row, date=start_dt)) try: parsed_duration = timedelta(minutes=int(duration)) if duration else None except ValueError: raise UserValueError(_("Row {row}: can't parse duration: {duration}").format(row=num_row, duration=duration)) if not title: raise UserValueError(_("Row {}: contribution title is required").format(num_row)) if email and not validate_email(email): raise UserValueError(_("Row {row}: invalid email address: {email}").format(row=num_row, email=email)) contrib_data.append({ 'start_dt': parsed_start_dt, 'duration': parsed_duration or timedelta(minutes=20), 'title': title, 'speaker': { 'first_name': first_name, 'last_name': last_name, 'affiliation': affiliation, 'email': email } }) # now that we're sure the data is OK, let's pre-allocate the friendly ids # for the contributions in question Contribution.allocate_friendly_ids(event, len(contrib_data)) contributions = [] all_changes = defaultdict(list) for contrib_fields in contrib_data: speaker_data = contrib_fields.pop('speaker') with track_time_changes() as changes: contribution = create_contribution(event, contrib_fields, extend_parent=True) contributions.append(contribution) for key, val in changes[event].viewitems(): all_changes[key].append(val) email = speaker_data['email'] if not email: continue # set the information of the speaker person = get_event_person(event, { 'firstName': speaker_data['first_name'], 'familyName': speaker_data['last_name'], 'affiliation': speaker_data['affiliation'], 'email': email }) link = ContributionPersonLink(person=person, is_speaker=True) link.populate_from_dict({ 'first_name': speaker_data['first_name'], 'last_name': speaker_data['last_name'], 'affiliation': speaker_data['affiliation'] }) contribution.person_links.append(link) return contributions, all_changes