def _process(self):
return WPManageRegistration.render_template(
'management/regform_modify.html',
self.event,
event=self.event_new,
sections=get_event_section_data(self.regform, management=True),
regform=self.regform)
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):
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 _process(self):
invitations = _query_invitation_list(self.regform)
return WPManageRegistration.render_template(
'management/regform_invitations.html',
self._conf,
regform=self.regform,
invitations=invitations)
def _process_GET(self):
reg_list_config = self.list_generator._get_config()
return WPManageRegistration.render_template('management/reglist_filter.html', self._conf, regform=self.regform,
RegistrationFormItemType=RegistrationFormItemType,
visible_items=reg_list_config['items'],
static_items=self.list_generator.static_items,
filters=reg_list_config['filters'])
def _process(self):
form = make_registration_form(self.regform, management=True)()
if form.validate_on_submit():
data = form.data
session[
'registration_notify_user_default'] = notify_user = data.pop(
'notify_user', False)
create_registration(self.regform,
data,
management=True,
notify_user=notify_user)
flash(_("The registration was created."), 'success')
return redirect(url_for('.manage_reglist', self.regform))
elif form.is_submitted():
# not very pretty but usually this never happens thanks to client-side validation
for error in form.error_list:
flash(error, 'error')
return WPManageRegistration.render_template(
'display/regform_display.html',
self._conf,
event=self.event_new,
sections=get_event_section_data(self.regform),
regform=self.regform,
post_url=url_for('.create_registration', self.regform),
user_data=self._get_user_data(),
management=True)
def _process(self):
registration_details_html = _render_registration_details(self.registration)
return WPManageRegistration.render_template(
"management/registration_details.html",
self.event,
registration=self.registration,
registration_details_html=registration_details_html,
)
def _process(self):
regforms = (RegistrationForm.query
.with_parent(self.event_new)
.options(undefer('active_registration_count'))
.order_by(db.func.lower(RegistrationForm.title)).all())
return WPManageRegistration.render_template('management/regform_list.html', self._conf,
event=self.event_new, regforms=regforms)
def _process(self):
registration_details_html = _render_registration_details(
self.registration)
return WPManageRegistration.render_template(
'management/registration_details.html',
self._conf,
registration=self.registration,
registration_details_html=registration_details_html)
def _process(self):
return WPManageRegistration.render_template(
"management/regform_modify.html",
self.event,
event=self.event_new,
sections=get_event_section_data(self.regform, management=True),
regform=self.regform,
)
def _process(self):
form = RegistrationFormForm(obj=self._get_form_defaults(), event=self.event)
if form.validate_on_submit():
form.populate_obj(self.regform)
db.session.flush()
flash(_('Registration form has been successfully modified'), 'success')
return redirect(url_for('.manage_regform', self.regform))
return WPManageRegistration.render_template('management/regform_edit.html', self.event, form=form,
event=self.event, regform=self.regform)
def _process(self):
form = RegistrationFormForm(obj=self._get_form_defaults(), event=self.event_new)
if form.validate_on_submit():
form.populate_obj(self.regform)
db.session.flush()
flash(_('Registration form has been successfully modified'), 'success')
return redirect(url_for('.manage_regform', self.regform))
return WPManageRegistration.render_template('management/regform_edit.html', self.event_new, form=form,
regform=self.regform)
def _process_GET(self):
reg_list_config = _get_reg_list_config(self.regform)
visible_columns = reg_list_config['items']
return WPManageRegistration.render_template('management/reglist_filter.html', self.event, regform=self.regform,
event=self.event, RegistrationFormItemType=RegistrationFormItemType,
visible_cols_regform_items=visible_columns,
filters=reg_list_config['filters'],
special_items=SPECIAL_COLUMN_LABELS)
def _process_GET(self):
reg_list_config = _get_reg_list_config(self.regform)
visible_columns = reg_list_config['items']
return WPManageRegistration.render_template('management/reglist_filter.html', self.event, regform=self.regform,
event=self.event, RegistrationFormItemType=RegistrationFormItemType,
visible_cols_regform_items=visible_columns,
filters=reg_list_config['filters'],
special_items=SPECIAL_COLUMN_LABELS)
def _process(self):
if self.list_generator.static_link_used:
return redirect(self.list_generator.get_list_url())
reg_list_kwargs = self.list_generator.get_list_kwargs()
return WPManageRegistration.render_template(
'management/regform_reglist.html',
self.event_new,
regform=self.regform,
**reg_list_kwargs)
def _process(self):
form = TicketsForm(obj=self.regform)
if form.validate_on_submit():
form.populate_obj(self.regform)
db.session.flush()
return redirect(url_for('.tickets', self.regform))
return WPManageRegistration.render_template('management/regform_tickets.html', self.event,
regform=self.regform, form=form,
can_enable_tickets=self._check_ticket_app_enabled())
def _process(self):
if self.list_generator.static_link_used:
return redirect(self.list_generator.get_list_url())
reg_list_kwargs = self.list_generator.get_list_kwargs()
badge_templates = [tpl for tpl in set(self.event.designer_templates) | get_inherited_templates(self.event)
if tpl.type == TemplateType.badge]
has_tickets = any(tpl.is_ticket for tpl in badge_templates)
has_badges = any(not tpl.is_ticket for tpl in badge_templates)
return WPManageRegistration.render_template('management/regform_reglist.html', self.event,
has_badges=has_badges, has_tickets=has_tickets, **reg_list_kwargs)
def _process(self):
if self.list_generator.static_link_used:
return redirect(self.list_generator.get_list_url())
reg_list_kwargs = self.list_generator.get_list_kwargs()
badge_templates = [tpl for tpl in set(self.event.designer_templates) | get_inherited_templates(self.event)
if tpl.type == TemplateType.badge]
has_tickets = any(tpl.is_ticket for tpl in badge_templates)
has_badges = any(not tpl.is_ticket for tpl in badge_templates)
return WPManageRegistration.render_template('management/regform_reglist.html', self.event,
has_badges=has_badges, has_tickets=has_tickets, **reg_list_kwargs)
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):
badge_templates = self.event.getBadgeTemplateManager().getTemplates().items()
badge_templates.sort(key=lambda x: x[1].getName())
pdf_options = WConfModifBadgePDFOptions(self.event).getHTML()
badge_design_url = url_for('event_mgmt.confModifTools-badgePrinting', self.event)
create_pdf_url = url_for('event_mgmt.confModifTools-badgePrintingPDF', self.event)
return WPManageRegistration.render_template('management/print_badges.html', self.event, regform=self.regform,
templates=badge_templates, pdf_options=pdf_options,
registrations=self.registrations,
registration_ids=[x.id for x in self.registrations],
badge_design_url=badge_design_url, create_pdf_url=create_pdf_url)
def _process(self):
regforms = (self.event_new.registration_forms
.filter_by(is_deleted=False)
.order_by(db.func.lower(RegistrationForm.title))
.all())
registration_counts = dict(self.event_new.registrations
.with_entities(Registration.registration_form_id, db.func.count())
.filter(Registration.is_active)
.group_by(Registration.registration_form_id))
return WPManageRegistration.render_template('management/regform_list.html', self.event,
event=self.event, regforms=regforms,
registration_counts=registration_counts)
def _process(self):
badge_templates = self._conf.getBadgeTemplateManager().getTemplates().items()
badge_templates.sort(key=lambda x: x[1].getName())
pdf_options = WConfModifBadgePDFOptions(self._conf).getHTML()
badge_design_url = url_for('event_mgmt.confModifTools-badgePrinting', self.event_new)
create_pdf_url = url_for('event_mgmt.confModifTools-badgePrintingPDF', self.event_new)
return WPManageRegistration.render_template('management/print_badges.html', self._conf, regform=self.regform,
templates=badge_templates, pdf_options=pdf_options,
registrations=self.registrations,
registration_ids=[x.id for x in self.registrations],
badge_design_url=badge_design_url, create_pdf_url=create_pdf_url)
def _process(self):
form = TicketsForm(obj=self.regform)
if form.validate_on_submit():
form.populate_obj(self.regform)
db.session.flush()
return redirect(url_for('.tickets', self.regform))
return WPManageRegistration.render_template(
'management/regform_tickets.html',
self.event,
regform=self.regform,
form=form,
can_enable_tickets=self._check_ticket_app_enabled())
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):
form = RegistrationFormForm(event=self.event,
publish_registrations_enabled=(self.event.getType() != 'conference'))
if form.validate_on_submit():
regform = RegistrationForm(event_new=self.event_new)
create_personal_data_fields(regform)
form.populate_obj(regform)
db.session.add(regform)
db.session.flush()
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, event=self.event,
form=form)
def _process(self):
form = make_registration_form(self.regform)()
if form.validate_on_submit():
create_registration(self.regform, form.data, management=True)
flash(_("The registration was created."), 'success')
return redirect(url_for('.manage_reglist', self.regform))
elif form.is_submitted():
# not very pretty but usually this never happens thanks to client-side validation
for error in form.error_list:
flash(error, 'error')
user_data = {t.name: getattr(self.user, t.name, None) if self.user else '' for t in PersonalDataType}
return WPManageRegistration.render_template('display/regform_display.html', self.event, event=self.event,
sections=get_event_section_data(self.regform), regform=self.regform,
post_url=url_for('.create_registration', self.regform),
user_data=user_data, management=True)
def _process(self):
regforms = (self.event_new.registration_forms.filter_by(
is_deleted=False).order_by(db.func.lower(
RegistrationForm.title)).all())
registration_counts = dict(
self.event_new.registrations.with_entities(
Registration.registration_form_id,
db.func.count()).filter(Registration.is_active).group_by(
Registration.registration_form_id))
return WPManageRegistration.render_template(
'management/regform_list.html',
self.event,
event=self.event,
regforms=regforms,
registration_counts=registration_counts)
def _process(self):
reg_list_config = _get_reg_list_config(regform=self.regform)
if 'config' in request.args:
return redirect(url_for('.manage_reglist', self.regform))
item_ids, basic_item_ids = _split_column_ids(reg_list_config['items'])
basic_columns = _get_basic_columns(self.regform, basic_item_ids)
regform_items = _get_sorted_regform_items(self.regform, item_ids)
registrations_query = _query_registrations(self.regform)
total_regs = registrations_query.count()
registrations = _filter_registration(self.regform, registrations_query, reg_list_config['filters']).all()
return WPManageRegistration.render_template('management/regform_reglist.html', self.event, regform=self.regform,
event=self.event, visible_cols_regform_items=regform_items,
registrations=registrations, basic_columns=basic_columns,
total_registrations=total_regs,
filtering_enabled=total_regs != len(registrations))
def _process(self):
reg_list_config = _get_reg_list_config(regform=self.regform)
if 'config' in request.args:
return redirect(url_for('.manage_reglist', self.regform))
item_ids, basic_item_ids = _split_column_ids(reg_list_config['items'])
basic_columns = _get_basic_columns(self.regform, basic_item_ids)
regform_items = _get_sorted_regform_items(self.regform, item_ids)
registrations_query = _query_registrations(self.regform)
total_regs = registrations_query.count()
registrations = _filter_registration(self.regform, registrations_query, reg_list_config['filters']).all()
return WPManageRegistration.render_template('management/regform_reglist.html', self.event, regform=self.regform,
event=self.event, visible_cols_regform_items=regform_items,
registrations=registrations, basic_columns=basic_columns,
total_registrations=total_regs,
filtering_enabled=total_regs != len(registrations))
def _process(self):
form = make_registration_form(self.regform, management=True)()
if form.validate_on_submit():
data = form.data
session['registration_notify_user_default'] = notify_user = data.pop('notify_user', False)
create_registration(self.regform, data, management=True, notify_user=notify_user)
flash(_("The registration was created."), 'success')
return redirect(url_for('.manage_reglist', self.regform))
elif form.is_submitted():
# not very pretty but usually this never happens thanks to client-side validation
for error in form.error_list:
flash(error, 'error')
return WPManageRegistration.render_template('display/regform_display.html', self.event,
sections=get_event_section_data(self.regform), regform=self.regform,
post_url=url_for('.create_registration', self.regform),
user_data=self._get_user_data(), management=True)
def _process_GET(self):
user_data = self._get_user_data()
initial_values = get_initial_form_values(self.regform,
management=True) | user_data
form_data = get_flat_section_submission_data(self.regform,
management=True)
return WPManageRegistration.render_template(
'display/regform_display.html',
self.event,
regform=self.regform,
form_data=form_data,
initial_values=initial_values,
invitation=None,
registration=None,
management=True,
login_required=False,
is_restricted_access=False)
def _process(self):
form = make_registration_form(self.regform, management=True)()
if form.validate_on_submit():
data = form.data
notify_user = data.pop('notify_user', False)
create_registration(self.regform, data, management=True, notify_user=notify_user)
flash(_("The registration was created."), 'success')
return redirect(url_for('.manage_reglist', self.regform))
elif form.is_submitted():
# not very pretty but usually this never happens thanks to client-side validation
for error in form.error_list:
flash(error, 'error')
user_data = {t.name: getattr(self.user, t.name, None) if self.user else '' for t in PersonalDataType}
return WPManageRegistration.render_template('display/regform_display.html', self.event, event=self.event,
sections=get_event_section_data(self.regform), regform=self.regform,
post_url=url_for('.create_registration', self.regform),
user_data=user_data, management=True)
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 _process(self):
regforms = (RegistrationForm.query
.with_parent(self.event)
.options(undefer('active_registration_count'))
.order_by(db.func.lower(RegistrationForm.title)).all())
return WPManageRegistration.render_template('management/regform_list.html', self.event, regforms=regforms)
def _process(self):
registration_details_html = _render_registration_details(self.registration)
return WPManageRegistration.render_template('management/registration_details.html', self._conf,
registration=self.registration,
registration_details_html=registration_details_html)
def _process(self):
if self.list_generator.static_link_used:
return redirect(self.list_generator.get_list_url())
reg_list_kwargs = self.list_generator.get_list_kwargs()
return WPManageRegistration.render_template('management/regform_reglist.html', self._conf,
regform=self.regform, event=self.event_new, **reg_list_kwargs)
def _process(self):
return WPManageRegistration.render_template(
'management/registration_tags.html', self.event)
def _process(self):
invitations = _query_invitation_list(self.regform)
return WPManageRegistration.render_template('management/regform_invitations.html', self._conf,
regform=self.regform, invitations=invitations)
def _process(self):
return WPManageRegistration.render_template('management/regform.html', self.event, regform=self.regform,
event=self.event)
def _process(self):
return WPManageRegistration.render_template('management/regform_modify.html', self.event, event=self.event_new,
sections=get_event_section_data(self.regform, management=True),
regform=self.regform,
currency=event_settings.get(self.event, 'currency'))
def _process(self):
return WPManageRegistration.render_template('management/regform.html', self.event_new, regform=self.regform)
def _process(self):
return WPManageRegistration.render_template('management/regform_modify.html', self.event,
form_data=get_flat_section_setup_data(self.regform),
regform=self.regform,
has_predefined_affiliations=Affiliation.query.has_rows())