def clone_event(event, start_dt, cloners, category=None):
"""Clone an event on a given date/time.
Runs all required cloners.
:param start_dt: The start datetime of the new event;
:param cloners: A set containing the names of all enabled cloners;
:param category: The `Category` the new event will be created in.
"""
end_dt = start_dt + event.duration
data = {
'start_dt': start_dt,
'end_dt': end_dt,
'timezone': event.timezone,
'title': event.title,
'description': event.description,
}
new_event = create_event(category or event.category, event.type_, data,
features=features_event_settings.get(event, 'enabled'),
add_creator_as_manager=False)
# Run the modular cloning system
EventCloner.run_cloners(event, new_event, cloners)
signals.event.cloned.send(event, new_event=new_event)
# Grant access to the event creator -- must be done after modular cloners
# since cloning the event ACL would result in a duplicate entry
with new_event.logging_disabled:
new_event.update_principal(session.user, full_access=True)
return new_event
def clone_event(event, start_dt, cloners, category=None):
"""Clone an event on a given date/time.
Runs all required cloners.
:param start_dt: The start datetime of the new event;
:param cloners: A set containing the names of all enabled cloners;
:param category: The `Category` the new event will be created in.
"""
end_dt = start_dt + event.duration
data = {
'start_dt': start_dt,
'end_dt': end_dt,
'timezone': event.timezone,
'title': event.title,
'description': event.description,
}
new_event = create_event(category or event.category,
event.type_,
data,
features=features_event_settings.get(
event, 'enabled'),
add_creator_as_manager=False)
# Run the modular cloning system
EventCloner.run_cloners(event, new_event, cloners)
signals.event.cloned.send(event, new_event=new_event)
# Grant access to the event creator -- must be done after modular cloners
# since cloning the event ACL would result in a duplicate entry
with new_event.logging_disabled:
new_event.update_principal(session.user, full_access=True)
return new_event
def clone(self, startDate):
# startDate is in the timezone of the event
old_event = self.as_event
start_dt = old_event.tzinfo.localize(startDate).astimezone(utc)
end_dt = start_dt + old_event.duration
data = {
'start_dt': start_dt,
'end_dt': end_dt,
'timezone': old_event.timezone,
'title': old_event.title,
'description': old_event.description,
'visibility': old_event.visibility
}
event = create_event(old_event.category, old_event.type_, data,
features=features_event_settings.get(self, 'enabled'),
add_creator_as_manager=False)
# Run the new modular cloning system
EventCloner.run_cloners(old_event, event)
signals.event.cloned.send(old_event, new_event=event)
# Grant access to the event creator -- must be done after modular cloners
# since cloning the event ACL would result in a duplicate entry
with event.logging_disabled:
event.update_principal(session.user, full_access=True)
return event.as_legacy
def clone_into_event(source_event, target_event, cloners):
"""Clone data into an existing event.
Runs all required cloners.
:param source_event: The `Event` to clone data from;
:param target_event: The `Event` to clone data into;
:param cloners: A set containing the names of all enabled cloners.
"""
# Run the modular cloning system
g.importing_event = True
EventCloner.run_cloners(source_event,
target_event,
cloners,
event_exists=True)
del g.importing_event
signals.event.imported.send(target_event, source_event=source_event)
cloner_classes = {c.name: c for c in get_event_cloners().values()}
target_event.log(EventLogRealm.event,
LogKind.change,
'Event',
'Data imported',
session.user,
data={
'Modules':
', '.join(
orig_string(cloner_classes[c].friendly_name)
for c in cloners
if not cloner_classes[c].is_internal)
})
return target_event
def test_registration_clone(dummy_event, dummy_regform, create_event, dummy_user):
set_feature_enabled(dummy_event, 'registration', True)
assert dummy_regform.event == dummy_event
assert dummy_event.registrations.one().user == dummy_user
assert dummy_event.registrations.one().checked_in
copied_event = create_event()
EventCloner.run_cloners(dummy_event, copied_event, {'registrations', 'registration_forms'})
copied_registration = copied_event.registrations.one()
assert copied_registration.event == copied_event
assert copied_registration.user == dummy_user
assert not copied_registration.checked_in
def clone_event(event,
n_occurrence,
start_dt,
cloners,
category=None,
refresh_users=False):
"""Clone an event on a given date/time.
Runs all required cloners.
:param n_occurrence: The 1-indexed number of the occurrence, if this is a "recurring" clone, otherwise `0`
:param start_dt: The start datetime of the new event;
:param cloners: A set containing the names of all enabled cloners;
:param category: The `Category` the new event will be created in.
:aparam refresh_users: Whether `EventPerson` data should be updated from
their linked `User` object
"""
end_dt = start_dt + event.duration
data = {
'start_dt': start_dt,
'end_dt': end_dt,
'timezone': event.timezone,
'title': event.title,
'description': event.description,
'own_map_url': event.own_map_url
}
new_event = create_event(category or event.category,
event.type_,
data,
features=features_event_settings.get(
event, 'enabled'),
add_creator_as_manager=False,
cloning=True)
# Run the modular cloning system
EventCloner.run_cloners(event, new_event, cloners, n_occurrence)
if refresh_users:
new_event.refresh_event_persons(notify=False)
signals.event.cloned.send(event, new_event=new_event)
# Grant access to the event creator -- must be done after modular cloners
# since cloning the event ACL would result in a duplicate entry
with new_event.logging_disabled:
new_event.update_principal(session.user, full_access=True)
return new_event
def clone_into_event(source_event, target_event, cloners):
"""Clone data into an existing event.
Runs all required cloners.
:param source_event: The `Event` to clone data from;
:param target_event: The `Event` to clone data into;
:param cloners: A set containing the names of all enabled cloners.
"""
# Run the modular cloning system
EventCloner.run_cloners(source_event,
target_event,
cloners,
event_exists=True)
signals.event.imported.send(target_event, source_event=source_event)
return target_event
