def create_registration(regform, data, invitation=None, management=False, notify_user=True, skip_moderation=None):
user = session.user if session else None
registration = Registration(registration_form=regform, user=get_user_by_email(data['email']),
base_price=regform.base_price, currency=regform.currency)
if skip_moderation is None:
skip_moderation = management
for form_item in regform.active_fields:
if form_item.parent.is_manager_only:
value = form_item.field_impl.default_value
else:
value = data.get(form_item.html_field_name)
data_entry = RegistrationData()
registration.data.append(data_entry)
for attr, value in form_item.field_impl.process_form_data(registration, value).iteritems():
setattr(data_entry, attr, value)
if form_item.type == RegistrationFormItemType.field_pd and form_item.personal_data_type.column:
setattr(registration, form_item.personal_data_type.column, value)
if invitation is None:
# Associate invitation based on email in case the user did not use the link
invitation = (RegistrationInvitation
.find(email=data['email'], registration_id=None)
.with_parent(regform)
.first())
if invitation:
invitation.state = InvitationState.accepted
invitation.registration = registration
registration.sync_state(_skip_moderation=skip_moderation)
db.session.flush()
notify_registration_creation(registration, notify_user)
logger.info('New registration %s by %s', registration, user)
regform.event.log(EventLogRealm.management if management else EventLogRealm.participants,
EventLogKind.positive, 'Registration',
'New registration: {}'.format(registration.full_name), user, data={'Email': registration.email})
return registration
def create_registration(regform, data, invitation=None, management=False, notify_user=True):
registration = Registration(registration_form=regform, user=get_user_by_email(data['email']),
base_price=regform.base_price, currency=regform.currency)
for form_item in regform.active_fields:
if form_item.parent.is_manager_only:
with db.session.no_autoflush:
value = form_item.field_impl.default_value
else:
value = data.get(form_item.html_field_name)
with db.session.no_autoflush:
data_entry = RegistrationData()
registration.data.append(data_entry)
for attr, value in form_item.field_impl.process_form_data(registration, value).iteritems():
setattr(data_entry, attr, value)
if form_item.type == RegistrationFormItemType.field_pd and form_item.personal_data_type.column:
setattr(registration, form_item.personal_data_type.column, value)
if invitation is None:
# Associate invitation based on email in case the user did not use the link
with db.session.no_autoflush:
invitation = (RegistrationInvitation
.find(email=data['email'], registration_id=None)
.with_parent(regform)
.first())
if invitation:
invitation.state = InvitationState.accepted
invitation.registration = registration
registration.sync_state(_skip_moderation=management)
db.session.flush()
notify_registration_creation(registration, notify_user)
logger.info('New registration %s by %s', registration, session.user)
return registration
def create_registration(regform, data, invitation=None, management=False, notify_user=True, skip_moderation=None):
user = session.user if session else None
registration = Registration(registration_form=regform, user=get_user_by_email(data['email']),
base_price=regform.base_price, currency=regform.currency)
if skip_moderation is None:
skip_moderation = management
for form_item in regform.active_fields:
if form_item.parent.is_manager_only:
value = form_item.field_impl.default_value
else:
value = data.get(form_item.html_field_name)
data_entry = RegistrationData()
registration.data.append(data_entry)
for attr, value in form_item.field_impl.process_form_data(registration, value).iteritems():
setattr(data_entry, attr, value)
if form_item.type == RegistrationFormItemType.field_pd and form_item.personal_data_type.column:
setattr(registration, form_item.personal_data_type.column, value)
if invitation is None:
# Associate invitation based on email in case the user did not use the link
invitation = (RegistrationInvitation
.find(email=data['email'], registration_id=None)
.with_parent(regform)
.first())
if invitation:
invitation.state = InvitationState.accepted
invitation.registration = registration
registration.sync_state(_skip_moderation=skip_moderation)
db.session.flush()
signals.event.registration_created.send(registration, management=management)
notify_registration_creation(registration, notify_user)
logger.info('New registration %s by %s', registration, user)
regform.event.log(EventLogRealm.management if management else EventLogRealm.participants,
EventLogKind.positive, 'Registration',
'New registration: {}'.format(registration.full_name), user, data={'Email': registration.email})
return registration
def _associate_registrations(user, **kwargs):
from indico.modules.events.registration.models.registrations import Registration
reg_alias = db.aliased(Registration)
subquery = db.session.query(reg_alias).filter(
reg_alias.user_id == user.id,
reg_alias.registration_form_id == Registration.registration_form_id,
~reg_alias.is_deleted)
registrations = (
Registration.find(
Registration.user_id == None, # noqa
Registration.email.in_(user.all_emails),
~subquery.exists(),
~Registration.is_deleted).order_by(
Registration.submitted_dt.desc()).all())
if not registrations:
return
done = set()
for registration in registrations:
if registration.registration_form_id in done:
continue
logger.info('Associating %s with %s', registration, user)
registration.user = user
done.add(registration.registration_form_id)
db.session.flush()
num = len(done)
flash(
ngettext("A registration has been linked to your account.",
"{n} registrations have been linked to your account.",
num).format(n=num), 'info')
def __init__(self, template, config, event, registration_ids):
super(RegistrantsListToBadgesPDF, self).__init__(template, config)
self.event = event
self.registrations = (Registration.find(
Registration.id.in_(registration_ids), Registration.is_active,
Registration.event_new == event).order_by(
*Registration.order_by_name).all())
def _process_args(self):
matches = re.search(r'r(\d+)$', request.values['orderID'])
if matches is None:
raise BadRequest
self.registration = Registration.find_first(id=matches.group(1))
if self.registration is None:
raise BadRequest
def _clone_registrations(self, old_form, new_form, field_data_map):
registration_attrs = get_simple_column_attrs(Registration) - {
'uuid', 'ticket_uuid'
}
for old_registration in old_form.registrations:
if old_registration.is_deleted:
continue
new_registration = Registration(user=old_registration.user,
registration_form=new_form,
**{
attr: getattr(
old_registration, attr)
for attr in registration_attrs
})
reg_data_attrs = get_simple_column_attrs(RegistrationData) - {
'storage_file_id', 'storage_backend', 'size'
}
for old_registration_data in old_registration.data:
new_registration_data = RegistrationData(
registration=new_registration,
**{
attr: getattr(old_registration_data, attr)
for attr in reg_data_attrs
})
new_registration_data.field_data = field_data_map[
old_registration_data.field_data]
if old_registration_data.storage_file_id is not None:
with old_registration_data.open() as fd:
new_registration_data.save(fd)
db.session.flush()
signals.event.registration_state_updated.send(new_registration,
previous_state=None)
def _process(self):
regforms = RegistrationForm.find_all(
RegistrationForm.publish_registrations_enabled,
event_id=int(self.event.id))
query = (Registration.find(
Registration.event_id == self.event.id,
RegistrationForm.publish_registrations_enabled,
~RegistrationForm.is_deleted,
~Registration.is_deleted,
_join=Registration.registration_form).order_by(
db.func.lower(Registration.last_name),
db.func.lower(Registration.first_name)))
registrations = [(reg.get_full_name(), reg.get_personal_data())
for reg in query]
enabled_pd_fields = {
field.personal_data_type
for reg in regforms for field in reg.active_fields
}
affiliation_enabled = PersonalDataType.affiliation in enabled_pd_fields
position_enabled = PersonalDataType.position in enabled_pd_fields
published = bool(
RegistrationForm.find(
RegistrationForm.publish_registrations_enabled,
RegistrationForm.event_id == int(self.event.id)).count())
return self.view_class.render_template(
'display/participant_list.html',
self.event,
event=self.event,
regforms=regforms,
show_affiliation=affiliation_enabled
and any(pd.get('affiliation') for reg, pd in registrations),
show_position=position_enabled
and any(pd.get('position') for reg, pd in registrations),
registrations=registrations,
published=published)
def get_unique_published_registrations(event):
"""Get a list of unique published registrations for an event.
Uniqueness is determined by associated user, so if someone has
registered in more than one registration form in the event, they
will be included only once.
:param event: The Event to get registrations for
"""
registrations = Registration.find_all(
Registration.is_active,
~RegistrationForm.is_deleted,
RegistrationForm.event_id == event.id,
RegistrationForm.publish_registrations_enabled,
_join=Registration.registration_form)
linked_participants = {
reg.user_id: reg
for reg in registrations if reg.user_id is not None
}
non_linked_participants = {
reg
for reg in registrations if reg.user_id is None
}
return sorted(
set(linked_participants.viewvalues()) | non_linked_participants,
key=lambda x: (x.first_name.lower(), x.last_name.lower(), x.id))
def _checkParams(self, params):
RHManageRegFormBase._checkParams(self, params)
ids = set(request.form.getlist("registration_id"))
self.registrations = (
Registration.find(Registration.id.in_(ids), ~Registration.is_deleted)
.with_parent(self.regform)
.order_by(*Registration.order_by_name)
.all()
)
def validate_email(self, field):
if RegistrationInvitation.find(email=field.data).with_parent(
self.regform).count():
raise ValidationError(
_("There is already an invitation with this email address."))
if Registration.find(email=field.data,
is_active=True).with_parent(self.regform).count():
raise ValidationError(
_("There is already a registration with this email address."))
def get_registrations_with_tickets(user, event):
return Registration.find(Registration.user == user,
Registration.state == RegistrationState.complete,
RegistrationForm.event_id == event.id,
RegistrationForm.tickets_enabled,
RegistrationForm.ticket_on_event_page,
~RegistrationForm.is_deleted,
~Registration.is_deleted,
_join=Registration.registration_form).all()
def get_registrations_with_tickets(user, event):
return Registration.find(Registration.user == user,
Registration.state == RegistrationState.complete,
RegistrationForm.event_id == event.id,
RegistrationForm.tickets_enabled,
RegistrationForm.ticket_on_event_page,
~RegistrationForm.is_deleted,
~Registration.is_deleted,
_join=Registration.registration_form).all()
def _create_registration(user, regform, **kwargs):
return Registration(first_name='Guinea',
last_name='Pig',
checked_in=True,
state=RegistrationState.complete,
currency='USD',
email=user.email,
user=user,
registration_form=regform,
**kwargs)
def _checkParams(self, params):
RHManageRegFormBase._checkParams(self, params)
self.registration = (Registration.find(
Registration.id == request.view_args['registration_id'],
~Registration.is_deleted, ~RegistrationForm.is_deleted).join(
Registration.registration_form).options(
contains_eager(Registration.registration_form).
defaultload('form_items').joinedload('children')).options(
defaultload(
Registration.data).joinedload('field_data')).one())
def all_recipients(self):
"""Returns all recipients of the notifications.
This includes both explicit recipients and, if enabled,
participants of the event.
"""
recipients = set(self.recipients)
if self.send_to_participants:
recipients.update(reg.email for reg in Registration.get_all_for_event(self.event))
recipients.discard('') # just in case there was an empty email address somewhere
return recipients
def _process_args(self):
# TODO: Validation?
# Stripe-specific form data.
self.stripe_token = request.form['stripeToken']
self.stripe_token_type = request.form['stripeTokenType']
self.stripe_email = request.form['stripeEmail']
# Indico-specific form data.
self.token = request.args['token']
self.registration = Registration.find_first(uuid=self.token)
if not self.registration:
raise BadRequest
def start_notification_recipients(self):
"""Return all recipients of the notifications.
This includes both explicit recipients and, if enabled,
participants of the event.
"""
recipients = set(self.start_notification_emails)
if self.notify_participants:
recipients.update(reg.email for reg in Registration.get_all_for_event(self.event))
recipients.discard('') # just in case there was an empty email address somewhere
return recipients
def _visible_registration(event):
if not event.has_feature('registration'):
return False
if RegistrationForm.find(RegistrationForm.is_scheduled, RegistrationForm.event_id == int(event.id)).count():
return True
if not session.user:
return False
return bool(Registration.find(Registration.user == session.user,
Registration.event_id == int(event.id),
~Registration.is_deleted,
~RegistrationForm.is_deleted,
_join=Registration.registration_form).count())
def create_registration(regform,
data,
invitation=None,
management=False,
notify_user=True,
skip_moderation=None):
user = session.user if session else None
registration = Registration(registration_form=regform,
user=get_user_by_email(data['email']),
base_price=regform.base_price,
currency=regform.currency)
if skip_moderation is None:
skip_moderation = management
for form_item in regform.active_fields:
default = form_item.field_impl.default_value
can_modify = management or not form_item.parent.is_manager_only
value = data.get(form_item.html_field_name,
default) if can_modify else default
data_entry = RegistrationData()
registration.data.append(data_entry)
if form_item.is_purged:
# Leave the registration data empty
continue
for attr, value in form_item.field_impl.process_form_data(
registration, value).items():
setattr(data_entry, attr, value)
if form_item.type == RegistrationFormItemType.field_pd and form_item.personal_data_type.column:
setattr(registration, form_item.personal_data_type.column, value)
if invitation is None:
# Associate invitation based on email in case the user did not use the link
invitation = (RegistrationInvitation.query.filter_by(
email=data['email'],
registration_id=None).with_parent(regform).first())
if invitation:
invitation.state = InvitationState.accepted
invitation.registration = registration
if not management and regform.needs_publish_consent:
registration.consent_to_publish = data.get(
'consent_to_publish', RegistrationVisibility.nobody)
registration.sync_state(_skip_moderation=skip_moderation)
db.session.flush()
signals.event.registration_created.send(registration,
management=management,
data=data)
notify_registration_creation(registration, notify_user)
logger.info('New registration %s by %s', registration, user)
registration.log(
EventLogRealm.management if management else EventLogRealm.participants,
LogKind.positive,
'Registration',
f'New registration: {registration.full_name}',
user,
data={'Email': registration.email})
return registration
def _create_registration(user_id):
user = create_user(user_id)
reg = Registration(first_name='Guinea',
last_name='Pig',
checked_in=True,
state=RegistrationState.complete,
currency='USD',
email=user.email,
user=user,
registration_form=dummy_regform)
dummy_event.registrations.append(reg)
db.session.flush()
return reg
def dummy_reg(db, dummy_event, dummy_regform, dummy_user):
"""Create a dummy registration for the dummy event."""
reg = Registration(registration_form_id=dummy_regform.id,
first_name='Guinea',
last_name='Pig',
checked_in=True,
state=RegistrationState.complete,
currency='USD',
email='*****@*****.**',
user=dummy_user)
dummy_event.registrations.append(reg)
db.session.flush()
return reg
def user_registered_in_event(user, event):
"""
Check whether there is a `Registration` entry for a user in any
form tied to a particular event.
:param user: the `User` object
:param event: the event in question
"""
return bool(
Registration.find(Registration.user == user,
RegistrationForm.event_id == int(event.id),
~RegistrationForm.is_deleted,
Registration.is_active).join(
Registration.registration_form).count())
def count_hidden_registrations(event, is_participant):
"""Get the number of hidden registrations for an event.
:param event: the `Event` to get registrations for
:param is_participant: whether the user accessing the registrations is a participant of the event
:return: number of registrations
"""
query = (Registration.query.with_parent(event).filter(
Registration.is_state_publishable,
~Registration.is_publishable(is_participant),
RegistrationForm.is_participant_list_visible(is_participant)).join(
Registration.registration_form))
return query.count()
def get_published_registrations(event):
"""Get a list of published registrations for an event.
:param event: the `Event` to get registrations for
:return: list of `Registration` objects
"""
return (Registration.find(Registration.is_active,
~RegistrationForm.is_deleted,
RegistrationForm.event_id == event.id,
RegistrationForm.publish_registrations_enabled,
_join=Registration.registration_form,
_eager=Registration.registration_form).order_by(
db.func.lower(Registration.first_name),
db.func.lower(Registration.last_name),
Registration.friendly_id).all())
def _process_args(self):
registration_uuid = request.args['registration_uuid']
self.registration = Registration.find_first(uuid=registration_uuid)
if not self.registration:
raise BadRequest("Registration UUID not provided in callback")
use_event_api_keys = self._get_event_settings('use_event_api_keys')
stripe.api_key = (self._get_event_settings('sec_key')
if use_event_api_keys else
current_plugin.settings.get('sec_key'))
self.session = stripe.checkout.Session.retrieve(
request.args['session_id'])
if not self.session:
raise BadRequest("Invalid stripe session")
def _visible_registration(event):
if not event.has_feature('registration'):
return False
if RegistrationForm.find(RegistrationForm.is_scheduled,
RegistrationForm.event_id == int(
event.id)).count():
return True
if not session.user:
return False
return bool(
Registration.find(Registration.user == session.user,
Registration.event_id == int(event.id),
~Registration.is_deleted,
~RegistrationForm.is_deleted,
_join=Registration.registration_form).count())
def get_published_registrations(event, is_participant):
"""Get a list of published registrations for an event.
:param event: the `Event` to get registrations for
:param is_participant: whether the user accessing the registrations is a participant of the event
:return: list of `Registration` objects
"""
query = (Registration.query.with_parent(event).filter(
Registration.is_publishable(is_participant),
~RegistrationForm.is_deleted,
~Registration.is_deleted).join(Registration.registration_form).options(
contains_eager(Registration.registration_form)).order_by(
db.func.lower(Registration.first_name),
db.func.lower(Registration.last_name),
Registration.friendly_id))
return query.all()
def _migrate_participant(self, old_part):
state = PARTICIPANT_STATUS_MAP.get(old_part._status,
RegistrationState.complete)
registration = Registration(
first_name=convert_to_unicode(old_part._firstName),
last_name=convert_to_unicode(old_part._familyName),
email=self._fix_email(old_part._email),
submitted_dt=self.event._creationDS,
base_price=0,
price_adjustment=0,
checked_in=old_part._present,
state=state)
self.importer.print_info(
cformat('%{yellow}Registration%{reset} - %{cyan}{}%{reset} [{}]').
format(registration.full_name, state.title))
self._migrate_participant_user(old_part, registration)
self._migrate_participant_data(old_part, registration)
self._migrate_participant_status(old_part, registration)
return registration
def get_unique_published_registrations(event):
"""Get a list of unique published registrations for an event.
Uniqueness is determined by associated user, so if someone has
registered in more than one registration form in the event, they
will be included only once.
:param event: The Event to get registrations for
"""
registrations = Registration.find_all(Registration.is_active,
~RegistrationForm.is_deleted,
RegistrationForm.event_id == event.id,
RegistrationForm.publish_registrations_enabled,
_join=Registration.registration_form)
linked_participants = {reg.user_id: reg for reg in registrations if reg.user_id is not None}
non_linked_participants = {reg for reg in registrations if reg.user_id is None}
return sorted(set(linked_participants.viewvalues()) | non_linked_participants,
key=lambda x: (x.first_name.lower(), x.last_name.lower(), x.id))
def all_recipients(self):
"""Return all recipients of the notifications.
This includes both explicit recipients and, if enabled,
participants/speakers of the event.
"""
recipients = set(self.recipients)
if self.send_to_participants:
recipients.update(reg.email for reg in Registration.get_all_for_event(self.event))
if self.send_to_speakers:
recipients.update(person_link.email for person_link in self.event.person_links)
# contribution/sub-contribution speakers are present only in meetings and conferences
if self.event.type != EventType.lecture:
contrib_speakers = (
ContributionPersonLink.query
.filter(
ContributionPersonLink.is_speaker,
ContributionPersonLink.contribution.has(is_deleted=False, event=self.event)
)
.all()
)
subcontrib_speakers = (
SubContributionPersonLink.query
.filter(
SubContributionPersonLink.is_speaker,
SubContributionPersonLink.subcontribution.has(
db.and_(
~SubContribution.is_deleted,
SubContribution.contribution.has(is_deleted=False, event=self.event)
)
)
)
.all()
)
recipients.update(speaker.email for speaker in contrib_speakers)
recipients.update(speaker.email for speaker in subcontrib_speakers)
recipients.discard('') # just in case there was an empty email address somewhere
return recipients
def _migrate_participant(self, old_part):
state = PARTICIPANT_STATUS_MAP.get(old_part._status,
RegistrationState.complete)
registration = Registration(
first_name=convert_to_unicode(old_part._firstName),
last_name=convert_to_unicode(old_part._familyName),
email=self._fix_email(old_part._email),
submitted_dt=self.event.created_dt,
base_price=0,
price_adjustment=0,
checked_in=old_part._present,
state=state,
currency=payment_settings.get('currency'))
self.print_info(
'%[yellow]Registration%[reset] - %[cyan]{}%[reset] [{}]'.format(
registration.full_name, state.title))
self._migrate_participant_user(old_part, registration)
self._migrate_participant_data(old_part, registration)
self._migrate_participant_status(old_part, registration)
return registration
def _process(self):
regforms = RegistrationForm.find_all(
RegistrationForm.publish_registrations_enabled, event_id=int(self.event.id)
)
query = Registration.find(
Registration.event_id == self.event.id,
RegistrationForm.publish_registrations_enabled,
~RegistrationForm.is_deleted,
~Registration.is_deleted,
_join=Registration.registration_form,
).order_by(db.func.lower(Registration.last_name), db.func.lower(Registration.first_name))
registrations = [(reg.get_full_name(), reg.get_personal_data()) for reg in query]
return self.view_class.render_template(
"display/participant_list.html",
self.event,
event=self.event,
regforms=regforms,
show_affiliation=any(pd.get("affiliation") for reg, pd in registrations),
show_position=any(pd.get("position") for reg, pd in registrations),
registrations=registrations,
)
def _send_email(with_event):
from flask import session
from indico.core.notifications import send_email, make_email
from indico.modules.events import Event
from indico.modules.users import User
from indico.web.flask.templating import get_template_module
tpl = get_template_module('users/emails/registration_request_accepted.txt',
user=User.get(6))
kwargs = {}
if with_event:
kwargs = {
'event': Event.get(654658),
'module': 'Test',
'user': session.user
}
# send_email(make_email('m\[email protected]', template=tpl), **kwargs)
# send_email(make_email('*****@*****.**', template=tpl), **kwargs)
from indico.modules.events.registration.notifications import _notify_registration
from indico.modules.events.registration.models.registrations import Registration
_notify_registration(Registration.get(56757),
'registration_creation_to_registrant.html')
def _associate_registrations(user, **kwargs):
from indico.modules.events.registration.models.registrations import Registration
reg_alias = db.aliased(Registration)
subquery = db.session.query(reg_alias).filter(
reg_alias.user_id == user.id,
reg_alias.registration_form_id == Registration.registration_form_id,
~reg_alias.is_deleted,
)
registrations = (
Registration.find(
Registration.user_id == None, # noqa
Registration.email.in_(user.all_emails),
~subquery.exists(),
~Registration.is_deleted,
)
.order_by(Registration.submitted_dt.desc())
.all()
)
if not registrations:
return
done = set()
for registration in registrations:
if registration.registration_form_id in done:
continue
logger.info("Associating %s with %s", registration, user)
registration.user = user
done.add(registration.registration_form_id)
db.session.flush()
num = len(done)
flash(
ngettext(
"A registration has been linked to your account.",
"{n} registrations have been linked to your account.",
num,
).format(n=num),
"info",
)
def _merged_participant_list_table(self):
def _process_registration(reg, column_names):
personal_data = reg.get_personal_data()
columns = [{
'text': personal_data.get(column_name, '')
} for column_name in column_names]
return {
'checked_in': self._is_checkin_visible(reg),
'columns': columns
}
column_names = registration_settings.get(self.event,
'participant_list_columns')
headers = [
PersonalDataType[column_name].get_title()
for column_name in column_names
]
query = (Registration.find(
Registration.event_id == self.event.id,
Registration.state.in_(
[RegistrationState.complete, RegistrationState.unpaid]),
RegistrationForm.publish_registrations_enabled,
~RegistrationForm.is_deleted,
~Registration.is_deleted,
_join=Registration.registration_form,
_eager=Registration.registration_form).options(
subqueryload('data').joinedload('field_data')).order_by(
*Registration.order_by_name))
registrations = [
_process_registration(reg, column_names) for reg in query
]
table = {'headers': headers, 'rows': registrations}
table['show_checkin'] = any(registration['checked_in']
for registration in registrations)
return table
def _checkParams(self):
self.token = request.args['token']
self.registration = Registration.find_first(uuid=self.token)
if not self.registration:
raise BadRequest
def validate_email(self, field):
if RegistrationInvitation.find(email=field.data).with_parent(self.regform).count():
raise ValidationError(_("There is already an invitation with this email address."))
if Registration.find(email=field.data, is_active=True).with_parent(self.regform).count():
raise ValidationError(_("There is already a registration with this email address."))
def _checkParams(self, params):
RHManageRegFormBase._checkParams(self, params)
ids = set(request.form.getlist('registration_id'))
self.registrations = (Registration.find(
Registration.id.in_(ids), ~Registration.is_deleted).with_parent(
self.regform).order_by(*Registration.order_by_name).all())
def _merge_users(target, source, **kwargs):
# registrations are unique per user, so we can only update the user
# if no registration for the merge target exists yet
from indico.modules.events.registration.models.registrations import Registration
Registration.merge_users(target, source)
