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}
def _deduplicate_reg_data(reg_data_iter):
used = set()
for reg_data in reg_data_iter:
reg_data_hash = tuple(tuple(sorted(x.items())) for x in reg_data['columns'])
if reg_data_hash not in used:
used.add(reg_data_hash)
yield reg_data
column_names = registration_settings.get(self.event_new, 'participant_list_columns')
headers = [PersonalDataType[column_name].get_title() for column_name in column_names]
query = (Registration.query.with_parent(self.event_new)
.filter(Registration.state.in_([RegistrationState.complete, RegistrationState.unpaid]),
RegistrationForm.publish_registrations_enabled,
~RegistrationForm.is_deleted,
~Registration.is_deleted)
.join(Registration.registration_form)
.options(subqueryload('data').joinedload('field_data'),
contains_eager('registration_form')))
registrations = sorted(_deduplicate_reg_data(_process_registration(reg, column_names) for reg in query),
key=lambda reg: tuple(x['text'].lower() for x in reg['columns']))
return {'headers': headers,
'rows': registrations,
'show_checkin': any(registration['checked_in'] for registration in registrations)}
def _process(self):
regforms = (RegistrationForm.query.with_parent(self.event)
.filter(RegistrationForm.is_participant_list_visible(self.event.is_user_registered(session.user)))
.options(subqueryload('registrations').subqueryload('data').joinedload('field_data'))
.all())
if registration_settings.get(self.event, 'merge_registration_forms'):
tables = [self._merged_participant_list_table()]
else:
tables = []
regforms_dict = {regform.id: regform for regform in regforms}
for form_id in registration_settings.get_participant_list_form_ids(self.event):
try:
regform = regforms_dict.pop(form_id)
except KeyError:
# The settings might reference forms that are not available
# anymore (publishing was disabled, etc.)
continue
tables.append(self._participant_list_table(regform))
# There might be forms that have not been sorted by the user yet
tables.extend(map(self._participant_list_table, regforms_dict.values()))
num_participants = sum(table['num_participants'] for table in tables)
return self.view_class.render_template(
'display/participant_list.html',
self.event,
tables=tables,
published=bool(regforms),
num_participants=num_participants
)
def _process(self):
regforms = (RegistrationForm.query.with_parent(self.event_new)
.filter(RegistrationForm.publish_registrations_enabled,
~RegistrationForm.is_deleted)
.options(subqueryload('registrations').subqueryload('data').joinedload('field_data'))
.all())
if registration_settings.get(self.event_new, 'merge_registration_forms'):
tables = [self._merged_participant_list_table()]
else:
tables = []
regforms_dict = {regform.id: regform for regform in regforms if regform.publish_registrations_enabled}
for form_id in registration_settings.get_participant_list_form_ids(self.event_new):
try:
regform = regforms_dict.pop(form_id)
except KeyError:
# The settings might reference forms that are not available
# anymore (publishing was disabled, etc.)
continue
tables.append(self._participant_list_table(regform))
# There might be forms that have not been sorted by the user yet
tables += map(self._participant_list_table, regforms_dict.viewvalues())
published = (RegistrationForm.query.with_parent(self.event_new)
.filter(RegistrationForm.publish_registrations_enabled)
.has_rows())
num_participants = sum(len(table['rows']) for table in tables)
return self.view_class.render_template(
'display/participant_list.html',
self._conf,
regforms=regforms,
tables=tables,
published=published,
num_participants=num_participants
)
def _process(self):
regforms = (self.event_new.registration_forms
.filter(RegistrationForm.publish_registrations_enabled,
~RegistrationForm.is_deleted)
.options(subqueryload('registrations').subqueryload('data').joinedload('field_data'))
.all())
if registration_settings.get(self.event, 'merge_registration_forms'):
tables = [self._merged_participant_list_table()]
else:
tables = []
regforms_dict = {regform.id: regform for regform in regforms if regform.publish_registrations_enabled}
for form_id in registration_settings.get_participant_list_form_ids(self.event):
try:
regform = regforms_dict.pop(form_id)
except KeyError:
# The settings might reference forms that are not available
# anymore (publishing was disabled, etc.)
continue
tables.append(self._participant_list_table(regform))
# There might be forms that have not been sorted by the user yet
tables += map(self._participant_list_table, regforms_dict.viewvalues())
published = bool(RegistrationForm.find(RegistrationForm.publish_registrations_enabled,
RegistrationForm.event_id == int(self.event.id)).count())
num_participants = sum(len(table['rows']) for table in tables)
return self.view_class.render_template(
'display/participant_list.html',
self.event,
event=self.event,
regforms=regforms,
tables=tables,
published=published,
num_participants=num_participants
)
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}
def _deduplicate_reg_data(reg_data_iter):
used = set()
for reg_data in reg_data_iter:
reg_data_hash = tuple(tuple(sorted(x.items())) for x in reg_data['columns'])
if reg_data_hash not in used:
used.add(reg_data_hash)
yield reg_data
column_names = registration_settings.get(self.event_new, 'participant_list_columns')
headers = [PersonalDataType[column_name].get_title() for column_name in column_names]
query = (Registration.query.with_parent(self.event_new)
.filter(Registration.state.in_([RegistrationState.complete, RegistrationState.unpaid]),
RegistrationForm.publish_registrations_enabled,
~RegistrationForm.is_deleted,
~Registration.is_deleted)
.join(Registration.registration_form)
.options(subqueryload('data').joinedload('field_data'),
contains_eager('registration_form')))
registrations = sorted(_deduplicate_reg_data(_process_registration(reg, column_names) for reg in query),
key=lambda x: x['columns'])
table = {'headers': headers,
'rows': registrations,
'show_checkin': any(registration['checked_in'] for registration in registrations)}
return table
def _process(self):
regforms = (self.event_new.registration_forms
.filter_by(is_deleted=False)
.order_by(db.func.lower(RegistrationForm.title))
.all())
form = ParticipantsDisplayForm()
if form.validate_on_submit():
data = form.json.data
registration_settings.set(self.event, 'merge_registration_forms', data['merge_forms'])
registration_settings.set_participant_list_form_ids(self.event, data['participant_list_forms'])
registration_settings.set_participant_list_columns(self.event, data['participant_list_columns'])
for regform in regforms:
regform.publish_registrations_enabled = regform.id in data['participant_list_forms']
flash(_("The participants display settings have been saved."), 'success')
return redirect(url_for('.manage_regforms_display', self.event_new))
available_columns = {field[0].name: field[1]['title'] for field in PersonalDataType.FIELD_DATA}
enabled_columns = []
disabled_columns = []
for column_name in registration_settings.get_participant_list_columns(self.event):
if column_name in available_columns:
enabled_columns.append({'id': column_name, 'title': available_columns[column_name]})
del available_columns[column_name]
for column_name, column_title in available_columns.iteritems():
disabled_columns.append({'id': column_name, 'title': column_title})
disabled_columns.sort(key=itemgetter('title'))
available_forms = {regform.id: regform for regform in regforms}
enabled_forms = []
disabled_forms = []
# Handle forms that have already been sorted by the user.
for form_id in registration_settings.get_participant_list_form_ids(self.event):
try:
regform = available_forms[form_id]
except KeyError:
continue
# Make sure publication was not disabled since the display settings were modified.
if regform.publish_registrations_enabled:
enabled_forms.append(regform)
del available_forms[form_id]
for form_id, regform in available_forms.iteritems():
# There might be forms with publication enabled that haven't been sorted by the user yet.
if regform.publish_registrations_enabled:
enabled_forms.append(regform)
else:
disabled_forms.append(regform)
disabled_forms.sort(key=attrgetter('title'))
merge_forms = registration_settings.get(self.event, 'merge_registration_forms')
return WPManageRegistration.render_template('management/regform_display.html', self.event, event=self.event,
regforms=regforms, enabled_columns=enabled_columns,
disabled_columns=disabled_columns, enabled_forms=enabled_forms,
disabled_forms=disabled_forms, merge_forms=merge_forms, form=form)
def _process(self):
regforms = sorted(self.event_new.registration_forms, key=lambda f: f.title.lower())
form = ParticipantsDisplayForm()
if form.validate_on_submit():
data = form.json.data
registration_settings.set(self.event_new, 'merge_registration_forms', data['merge_forms'])
registration_settings.set_participant_list_form_ids(self.event_new, data['participant_list_forms'])
registration_settings.set_participant_list_columns(self.event_new, data['participant_list_columns'])
for regform in regforms:
regform.publish_registrations_enabled = regform.id in data['participant_list_forms']
flash(_("The participants display settings have been saved."), 'success')
return redirect(url_for('.manage_regforms_display', self.event_new))
available_columns = {field[0].name: field[1]['title'] for field in PersonalDataType.FIELD_DATA}
enabled_columns = []
disabled_columns = []
for column_name in registration_settings.get_participant_list_columns(self.event_new):
if column_name in available_columns:
enabled_columns.append({'id': column_name, 'title': available_columns[column_name]})
del available_columns[column_name]
for column_name, column_title in available_columns.iteritems():
disabled_columns.append({'id': column_name, 'title': column_title})
disabled_columns.sort(key=itemgetter('title'))
available_forms = {regform.id: regform for regform in regforms}
enabled_forms = []
disabled_forms = []
# Handle forms that have already been sorted by the user.
for form_id in registration_settings.get_participant_list_form_ids(self.event_new):
try:
regform = available_forms[form_id]
except KeyError:
continue
# Make sure publication was not disabled since the display settings were modified.
if regform.publish_registrations_enabled:
enabled_forms.append(regform)
del available_forms[form_id]
for form_id, regform in available_forms.iteritems():
# There might be forms with publication enabled that haven't been sorted by the user yet.
if regform.publish_registrations_enabled:
enabled_forms.append(regform)
else:
disabled_forms.append(regform)
disabled_forms.sort(key=attrgetter('title'))
merge_forms = registration_settings.get(self.event_new, 'merge_registration_forms')
return WPManageRegistration.render_template('management/regform_display.html', self.event_new,
regforms=regforms, enabled_columns=enabled_columns,
disabled_columns=disabled_columns, enabled_forms=enabled_forms,
disabled_forms=disabled_forms, merge_forms=merge_forms, form=form)
def _process(self):
regforms = sorted(self.event.registration_forms, key=lambda f: f.title.lower())
form = ParticipantsDisplayForm(regforms=regforms)
if form.validate_on_submit():
data = form.json.data
registration_settings.set(self.event, 'merge_registration_forms', data['merge_forms'])
registration_settings.set_participant_list_form_ids(self.event, data['participant_list_forms'])
registration_settings.set_participant_list_columns(self.event, data['participant_list_columns'])
flash(_('The participants display settings have been saved.'), 'success')
return redirect(url_for('.manage_regforms_display', self.event))
elif form.is_submitted():
for error in form.error_list:
flash(error, 'error')
available_columns = {field[0].name: field[1]['title'] for field in PersonalDataType.FIELD_DATA}
enabled_columns = []
disabled_columns = []
for column_name in registration_settings.get_participant_list_columns(self.event):
if column_name in available_columns:
enabled_columns.append({'id': column_name, 'title': available_columns[column_name]})
del available_columns[column_name]
for column_name, column_title in available_columns.items():
disabled_columns.append({'id': column_name, 'title': column_title})
disabled_columns.sort(key=itemgetter('title'))
available_forms = {regform.id: regform for regform in regforms}
sorted_forms = []
# Handle forms that have already been sorted by the user.
for form_id in registration_settings.get_participant_list_form_ids(self.event):
try:
regform = available_forms[form_id]
except KeyError:
continue
sorted_forms.append(regform)
del available_forms[form_id]
for form_id, regform in available_forms.items():
sorted_forms.append(regform)
merge_forms = registration_settings.get(self.event, 'merge_registration_forms')
return WPManageRegistration.render_template('management/regform_display.html', self.event,
regforms=regforms, enabled_columns=enabled_columns,
disabled_columns=disabled_columns, sorted_forms=sorted_forms,
merge_forms=merge_forms, form=form)
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 _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
