def _process(self):
form = RegistrationFormForm(
event=self.event,
publish_registrations_enabled=(self.event.type_ !=
EventType.conference))
if form.validate_on_submit():
regform = RegistrationForm(event=self.event)
create_personal_data_fields(regform)
form.populate_obj(regform)
db.session.add(regform)
db.session.flush()
signals.event.registration_form_created.send(regform)
flash(_('Registration form has been successfully created'),
'success')
self.event.log(
EventLogRealm.management, EventLogKind.positive,
'Registration',
'Registration form "{}" has been created'.format(
regform.title), session.user)
return redirect(url_for('.manage_regform', regform))
return WPManageRegistration.render_template(
'management/regform_edit.html',
self.event,
form=form,
regform=None)
def migrate_regforms(self):
try:
self.old_participation = self.conf._participation
except AttributeError:
self.print_info('Event has no participation')
return
if not self.old_participation._participantList and not self.old_participation._pendingParticipantList:
self.print_info('Participant lists are empty')
return
set_feature_enabled(self.event, 'registration', True)
with db.session.no_autoflush:
self.regform = RegistrationForm(
event_id=self.event.id,
title=PARTICIPATION_FORM_TITLE,
is_participation=True,
currency=payment_settings.get('currency'))
if not self.quiet:
self.print_success('%[cyan]{}'.format(self.regform.title))
self._migrate_settings()
self._create_form()
self._migrate_participants()
db.session.add(self.regform)
db.session.flush()
def _process(self):
participant_visibility = (PublishRegistrationsMode.hide_all
if self.event.type_ == EventType.conference
else PublishRegistrationsMode.show_all)
public_visibility = PublishRegistrationsMode.hide_all
form = RegistrationFormCreateForm(event=self.event,
visibility=[participant_visibility.name, public_visibility.name, None])
if form.validate_on_submit():
regform = RegistrationForm(event=self.event, currency=payment_settings.get('currency'))
create_personal_data_fields(regform)
form.populate_obj(regform, skip=['visibility'])
participant_visibility, public_visibility, visibility_duration = form.visibility.data
regform.publish_registrations_participants = PublishRegistrationsMode[participant_visibility]
regform.publish_registrations_public = PublishRegistrationsMode[public_visibility]
regform.publish_registrations_duration = (timedelta(days=visibility_duration*30)
if visibility_duration is not None else None)
db.session.add(regform)
db.session.flush()
signals.event.registration_form_created.send(regform)
flash(_('Registration form has been successfully created'), 'success')
self.event.log(EventLogRealm.management, LogKind.positive, 'Registration',
f'Registration form "{regform.title}" has been created', session.user)
return redirect(url_for('.manage_regform', regform))
return WPManageRegistration.render_template('management/regform_create.html', self.event,
form=form, regform=None)
def _process(self):
regform = self.event.participation_regform
registration_enabled = self.event.has_feature('registration')
participant_visibility = (PublishRegistrationsMode.show_with_consent
if self.event.type_ == EventType.lecture
else PublishRegistrationsMode.show_all)
public_visibility = (PublishRegistrationsMode.show_with_consent
if self.event.type_ == EventType.lecture
else PublishRegistrationsMode.show_all)
form = RegistrationFormCreateForm(title='Participants',
visibility=[participant_visibility.name, public_visibility.name, None])
if form.validate_on_submit():
set_feature_enabled(self.event, 'registration', True)
if not regform:
regform = RegistrationForm(event=self.event, is_participation=True,
currency=payment_settings.get('currency'))
create_personal_data_fields(regform)
form.populate_obj(regform, skip=['visibility'])
participant_visibility, public_visibility, visibility_duration = form.visibility.data
regform.publish_registrations_participants = PublishRegistrationsMode[participant_visibility]
regform.publish_registrations_public = PublishRegistrationsMode[public_visibility]
regform.publish_registrations_duration = (timedelta(days=visibility_duration*30)
if visibility_duration is not None else None)
db.session.add(regform)
db.session.flush()
signals.event.registration_form_created.send(regform)
self.event.log(EventLogRealm.management, LogKind.positive, 'Registration',
f'Registration form "{regform.title}" has been created', session.user)
return redirect(url_for('event_registration.manage_regform', regform))
if not regform or not registration_enabled:
return WPManageParticipants.render_template('management/participants.html', self.event, form=form,
regform=regform, registration_enabled=registration_enabled)
return redirect(url_for('event_registration.manage_regform', regform))
def dummy_regform(dummy_event, db):
# event has to be in the future (badge request)
dummy_event.start_dt += timedelta(days=1)
dummy_event.end_dt += timedelta(days=1)
regform = RegistrationForm(event=dummy_event, title="Dummy Registration Form", currency="CHF")
create_personal_data_fields(regform)
db.session.flush()
return regform
def dummy_regform(db, dummy_event):
regform = RegistrationForm(event=dummy_event, title='Registration Form', currency='USD')
create_personal_data_fields(regform)
# enable all fields
for field in regform.sections[0].fields:
field.is_enabled = True
db.session.add(regform)
db.session.flush()
return regform
def run(self):
self.regform = RegistrationForm(event_id=int(self.event.id),
title=PARTICIPATION_FORM_TITLE,
is_participation=True)
if not self.importer.quiet:
self.importer.print_success(cformat('%{cyan}{}').format(
self.regform.title),
event_id=self.event.id)
self._migrate_settings()
self._create_form()
self._migrate_participants()
def _process_POST(self):
regform = self.event_new.participation_regform
set_feature_enabled(self.event_new, 'registration', True)
if not regform:
regform = RegistrationForm(event_new=self.event_new, title="Participants", is_participation=True,
currency=payment_settings.get('currency'))
create_personal_data_fields(regform)
db.session.add(regform)
db.session.flush()
signals.event.registration_form_created.send(regform)
self.event_new.log(EventLogRealm.management, EventLogKind.positive, 'Registration',
'Registration form "{}" has been created'.format(regform.title), session.user)
return redirect(url_for('event_registration.manage_regform', regform))
def run(self, new_event, cloners, shared_data):
# if the registration cloner is also enabled, we have to keep
# all revisions since they are likely to be in use
clone_all_revisions = 'registrations' in cloners
attrs = get_simple_column_attrs(RegistrationForm) - {'start_dt', 'end_dt', 'modification_end_dt'}
self._field_data_map = {}
self._form_map = {}
for old_form in self.old_event.registration_forms:
new_form = RegistrationForm(**{attr: getattr(old_form, attr) for attr in attrs})
self._clone_form_items(old_form, new_form, clone_all_revisions)
new_event.registration_forms.append(new_form)
db.session.flush()
self._form_map[old_form] = new_form
return {'form_map': self._form_map,
'field_data_map': self._field_data_map}
def clone(self, new_event, options):
if not options:
return
self._clone_with_registrations = 'registrations' in options
attrs = get_simple_column_attrs(RegistrationForm) - {
'start_dt', 'end_dt', 'modification_end_dt'
}
with db.session.no_autoflush:
for old_form in self._find_registration_forms():
new_form = RegistrationForm(
event_new=new_event.as_event,
**{attr: getattr(old_form, attr)
for attr in attrs})
self._clone_form_items(old_form, new_form)
if self._clone_with_registrations:
self._clone_registrations(old_form, new_form, new_event)
db.session.add(new_form)
db.session.flush()
def test_filter_contrib_entries(app, db, dummy_event, create_user,
create_contribution, create_registration):
registered_user = create_user(1)
registered_speaker = create_user(2)
unregistered_user = create_user(3)
dummy_regform = RegistrationForm(event=dummy_event,
title='Registration Form',
currency='USD')
dummy_event.registrations.append(
create_registration(registered_user, dummy_regform))
dummy_event.registrations.append(
create_registration(registered_speaker, dummy_regform))
registered_speaker_contribution = create_contribution(
dummy_event,
'Registered Speaker',
person_links=[
ContributionPersonLink(person=EventPerson.create_from_user(
registered_speaker, dummy_event),
is_speaker=True)
])
registered_speaker_author_contribution = create_contribution(
dummy_event,
'Registered Speaker Author',
person_links=[
ContributionPersonLink(person=EventPerson.for_user(
registered_speaker, dummy_event),
is_speaker=True,
author_type=AuthorType.primary)
])
unregistered_speaker_registered_author_contribution = create_contribution(
dummy_event,
'Unregistered Speaker, Registered Author',
person_links=[
ContributionPersonLink(person=EventPerson.for_user(
unregistered_user, dummy_event),
is_speaker=True),
ContributionPersonLink(person=EventPerson.for_user(
registered_user, dummy_event),
author_type=AuthorType.primary)
])
registered_speaker_unregistered_author_contribution = create_contribution(
dummy_event,
'Registered Speaker, Unregistered Author',
person_links=[
ContributionPersonLink(person=EventPerson.for_user(
registered_user, dummy_event),
is_speaker=True),
ContributionPersonLink(person=EventPerson.for_user(
unregistered_user, dummy_event),
author_type=AuthorType.primary)
])
# Filter contributions with registered users
with app.test_request_context():
list_gen = ContributionListGenerator(dummy_event)
list_gen.list_config['filters'] = {'items': {'people': {'registered'}}}
result = list_gen.get_list_kwargs()
assert result['contribs'] == [
registered_speaker_contribution,
registered_speaker_author_contribution,
unregistered_speaker_registered_author_contribution,
registered_speaker_unregistered_author_contribution
]
# Filter contributions with registered speakers
list_gen.list_config['filters'] = {'items': {'speakers': {'registered'}}}
with app.test_request_context():
result = list_gen.get_list_kwargs()
assert result['contribs'] == [
registered_speaker_contribution,
registered_speaker_author_contribution,
registered_speaker_unregistered_author_contribution
]
# Filter contributions with unregistered speakers and registered users
list_gen.list_config['filters'] = {
'items': {
'speakers': {'not_registered'},
'people': {'registered'}
}
}
with app.test_request_context():
result = list_gen.get_list_kwargs()
assert result['contribs'] == [
unregistered_speaker_registered_author_contribution
]
