def _clone_timetable(self, new_event):
offset = new_event.start_dt - self.old_event.start_dt
# no need to copy the type; it's set automatically based on the object
attrs = get_simple_column_attrs(TimetableEntry) - {'type', 'start_dt'}
break_strategy = defaultload('break_')
break_strategy.joinedload('own_venue')
break_strategy.joinedload('own_room').lazyload('*')
query = (self.old_event.timetable_entries.options(
joinedload('parent').lazyload('*'), break_strategy).order_by(
TimetableEntry.parent_id.is_(None).desc()))
# iterate over all timetable entries; start with top-level
# ones so we can build a mapping that can be used once we
# reach nested entries
entry_map = {}
for old_entry in query:
entry = TimetableEntry()
entry.start_dt = old_entry.start_dt + offset
entry.populate_from_attrs(old_entry, attrs)
if old_entry.parent is not None:
entry.parent = entry_map[old_entry.parent]
if old_entry.session_block is not None:
entry.session_block = self._session_block_map[
old_entry.session_block]
if old_entry.contribution is not None:
entry.contribution = self._contrib_map[old_entry.contribution]
if old_entry.break_ is not None:
entry.break_ = self._clone_break(old_entry.break_)
new_event.timetable_entries.append(entry)
entry_map[old_entry] = entry
def create_timetable_entry(event, data, parent=None, extend_parent=False):
entry = TimetableEntry(event_new=event, parent=parent)
entry.populate_from_dict(data)
object_type, object_title = _get_object_info(entry)
db.session.flush()
signals.event.timetable_entry_created.send(entry)
logger.info('Timetable entry %s created by %s', entry, session.user)
entry.event_new.log(EventLogRealm.management, EventLogKind.positive, 'Timetable',
"Entry for {} '{}' created".format(object_type, object_title), session.user,
data={'Time': format_datetime(entry.start_dt)})
if extend_parent:
entry.extend_parent()
return entry
def _clone_timetable(self, new_event):
offset = new_event.start_dt - self.old_event.start_dt
# no need to copy the type; it's set automatically based on the object
attrs = get_simple_column_attrs(TimetableEntry) - {'type', 'start_dt'}
break_strategy = defaultload('break_')
break_strategy.joinedload('own_venue')
break_strategy.joinedload('own_room').lazyload('*')
query = (self.old_event.timetable_entries
.options(joinedload('parent').lazyload('*'),
break_strategy)
.order_by(TimetableEntry.parent_id.is_(None).desc()))
# iterate over all timetable entries; start with top-level
# ones so we can build a mapping that can be used once we
# reach nested entries
entry_map = {}
for old_entry in query:
entry = TimetableEntry()
entry.start_dt = old_entry.start_dt + offset
entry.populate_from_attrs(old_entry, attrs)
if old_entry.parent is not None:
entry.parent = entry_map[old_entry.parent]
if old_entry.session_block is not None:
entry.session_block = self._session_block_map[old_entry.session_block]
if old_entry.contribution is not None:
entry.contribution = self._contrib_map[old_entry.contribution]
if old_entry.break_ is not None:
entry.break_ = self._clone_break(old_entry.break_)
new_event.timetable_entries.append(entry)
entry_map[old_entry] = entry
def _create_entry(obj, start_dt):
entry = TimetableEntry(event=dummy_event,
object=obj,
start_dt=start_dt)
db.session.add(entry)
db.session.flush()
return entry
def _migrate_contribution_timetable_entry(self, old_entry, session_block=None):
old_contrib = old_entry._LinkedTimeSchEntry__owner
contrib = self.event_ns.legacy_contribution_map[old_contrib]
contrib.timetable_entry = TimetableEntry(event_new=self.event,
start_dt=self.context._fix_naive(old_contrib.startDate))
self._migrate_location(old_contrib, contrib)
if session_block:
contrib.session = session_block.session
contrib.session_block = session_block
contrib.timetable_entry.parent = session_block.timetable_entry
return contrib.timetable_entry
def _migrate_break_timetable_entry(self, old_entry, session_block=None):
break_ = Break(title=convert_to_unicode(old_entry.title), description=convert_to_unicode(old_entry.description),
duration=old_entry.duration)
try:
break_.colors = ColorTuple(old_entry._textColor, old_entry._color)
except (AttributeError, ValueError) as e:
self.print_warning('%[yellow]Break has no colors: "{}" [{}]'.format(break_.title, e))
break_.timetable_entry = TimetableEntry(event_new=self.event,
start_dt=self.context._fix_naive(old_entry.startDate))
self._migrate_location(old_entry, break_)
if session_block:
break_.timetable_entry.parent = session_block.timetable_entry
return break_.timetable_entry
def create_timetable_entry(event, data, parent=None, extend_parent=False):
entry = TimetableEntry(event_new=event, parent=parent)
entry.populate_from_dict(data)
object_type, object_title = _get_object_info(entry)
db.session.flush()
signals.event.timetable_entry_created.send(entry)
logger.info('Timetable entry %s created by %s', entry, session.user)
entry.event_new.log(EventLogRealm.management, EventLogKind.positive, 'Timetable',
"Entry for {} '{}' created".format(object_type, object_title), session.user,
data={'Time': format_datetime(entry.start_dt)})
if extend_parent:
entry.extend_parent()
return entry
def _migrate_block_timetable_entry(self, old_entry):
old_block = old_entry._LinkedTimeSchEntry__owner
try:
session = self.event_ns.legacy_session_map[old_block.session]
except KeyError:
self.print_warning('%[yellow!]Found zombie session {}'.format(old_block.session))
session = self._migrate_session(old_block.session)
session_block = SessionBlock(session=session, title=convert_to_unicode(old_block.title),
duration=old_block.duration)
session_block.timetable_entry = TimetableEntry(event_new=self.event,
start_dt=self.context._fix_naive(old_block.startDate))
if session.legacy_mapping is not None:
session_block.legacy_mapping = LegacySessionBlockMapping(event_new=self.event,
legacy_session_id=old_block.session.id,
legacy_session_block_id=old_block.id)
self._migrate_location(old_block, session_block)
session_block.person_links = list(self._migrate_session_block_person_links(old_block))
self._migrate_timetable_entries(old_block._schedule._entries, session_block)
return session_block.timetable_entry
