def _process(self):
form = make_registration_form(self.regform, management=self.management, registration=self.registration)()
if form.validate_on_submit():
data = form.data
notify_user = data.pop('notify_user', False)
modify_registration(self.registration, data, management=self.management, notify_user=notify_user)
return redirect(self.success_url)
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')
registration_data = {r.field_data.field.html_field_name: camelize_keys(r.user_data)
for r in self.registration.data}
section_data = camelize_keys(get_event_section_data(self.regform, management=self.management,
registration=self.registration))
registration_metadata = {
'paid': self.registration.is_paid,
'manager': self.management
}
return self.view_class.render_template(self.template_file, self.event, event=self.event,
sections=section_data, regform=self.regform,
registration_data=registration_data,
registration_metadata=registration_metadata,
registration=self.registration)
def test_registration_modified_inactive(dummy_regform, api_delete, api_post):
"""Modify the name of the registrant, request inactive, ADAMS not contacted."""
registration = dummy_regform.registrations[0]
modify_registration(registration, {
'first_name': 'Conan',
'last_name': 'Osiris',
'email': '*****@*****.**'
})
assert api_delete.call_count == 0
assert api_post.call_count == 0
def _process_POST(self):
optional_fields = self._get_optional_fields()
schema = make_registration_schema(
self.regform, management=self.management, registration=self.registration
)(partial=optional_fields)
form_data = parser.parse(schema)
notify_user = not self.management or form_data.pop('notify_user', False)
if self.management:
session['registration_notify_user_default'] = notify_user
modify_registration(self.registration, form_data, management=self.management, notify_user=notify_user)
return jsonify({'redirect': self.success_url})
def test_registration_modified_active(dummy_regform, api_delete, api_post):
"""Modify the name of the registrant, request active, ADAMS contacted (POST)."""
registration = dummy_regform.registrations[0]
grant_access([registration], dummy_regform, email_body='body', email_subject='subject')
# grant_access will already contact ADAMS
assert api_post.call_count == 1
modify_registration(registration, {
'first_name': 'Conan',
'last_name': 'Osiris',
'email': '*****@*****.**'
})
api_delete.call_count == 0
assert api_post.call_count == 2
api_post.assert_called_with(dummy_regform.event, [registration], update=True)
def _process(self):
form = make_registration_form(self.regform,
management=self.management,
registration=self.registration)()
verif_field, reg_field = ('', '')
for k in form._fields:
if form._fields[k].label.text.lower() == 'registration option':
reg_field = form._fields[k].label.field_id
if form._fields[k].label.text.lower() == 'verification code':
verif_field = form._fields[k].label.field_id
verif_code = ''
if verif_field and form._fields[verif_field].data:
verif_code = form._fields[verif_field].data
elif request.form.get(verif_field):
verif_code = request.form.get(verif_field)
reg_opt = ''
if reg_field and form._fields[reg_field].data:
reg_opt = form._fields[reg_field].data
opt_text = ''
if reg_opt:
for i in self.regform.active_fields:
if i.title.lower() == 'registration option':
for k in i.data['captions']:
if k == next(iter(reg_opt)):
opt_text = i.data['captions'][k]
else:
continue
members_choice = False
if opt_text and re.search(r' members', opt_text, flags=re.IGNORECASE):
members_choice = True
registration_data = {
r.field_data.field.html_field_name: camelize_keys(r.user_data)
for r in self.registration.data
}
reg_allowed = False
if members_choice:
str_list = [
registration_data['first_name'] +
registration_data['last_name'] + '/' + str(self.event.id) +
'/' + datetime.today().strftime('%Y-%m-%d'),
registration_data['first_name'] +
registration_data['last_name'] + '/' + str(self.event.id) +
'/' +
(datetime.now() + timedelta(days=-1)).strftime('%Y-%m-%d'),
registration_data['first_name'] +
registration_data['last_name'] + '/' + str(self.event.id) +
'/' +
(datetime.now() + timedelta(days=-2)).strftime('%Y-%m-%d')
]
for strn in str_list:
sha = hmac.new(u''.encode(),
strn.lower().encode('utf-8'),
hashlib.sha256).hexdigest()
md = hmac.new(''.encode(), sha.encode(),
hashlib.md5).hexdigest()
enc = codecs.encode(codecs.decode(
md, 'hex'), 'base64').decode().replace("\n", "").replace(
"=", "").replace("/", "9").replace("+", "8")
print(strn.lower())
print(enc)
if enc == verif_code:
reg_allowed = True
setattr(self.regform, 'member_attempt', False)
if (members_choice and reg_allowed) or not members_choice:
if form.validate_on_submit():
data = form.data
notify_user = not self.management or data.pop(
'notify_user', False)
if self.management:
session['registration_notify_user_default'] = notify_user
modify_registration(self.registration,
data,
management=self.management,
notify_user=notify_user)
return redirect(self.success_url)
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')
else:
setattr(self.regform, 'member_attempt', True)
section_data = camelize_keys(
get_event_section_data(self.regform,
management=self.management,
registration=self.registration))
registration_metadata = {
'paid': self.registration.is_paid,
'manager': self.management
}
return self.view_class.render_template(
self.template_file,
self.event,
sections=section_data,
regform=self.regform,
registration_data=registration_data,
registration_metadata=registration_metadata,
registration=self.registration)
def test_modify_registration(monkeypatch, dummy_event, dummy_user,
dummy_regform):
session.set_session_user(dummy_user)
monkeypatch.setattr('indico.modules.users.util.get_user_by_email',
lambda *args, **kwargs: dummy_user)
# Extend the dummy_regform with more sections and fields
user_section = RegistrationFormSection(registration_form=dummy_regform,
title='dummy_section',
is_manager_only=False)
db.session.add(user_section)
db.session.flush()
boolean_field = RegistrationFormField(parent_id=user_section.id,
registration_form=dummy_regform)
_fill_form_field_with_data(boolean_field, {
'input_type': 'bool',
'default_value': False,
'title': 'Yes/No'
})
db.session.add(boolean_field)
multi_choice_field = RegistrationFormField(parent_id=user_section.id,
registration_form=dummy_regform)
_fill_form_field_with_data(
multi_choice_field, {
'input_type':
'multi_choice',
'with_extra_slots':
False,
'title':
'Multi Choice',
'choices': [
{
'caption': 'A',
'id': 'new:test1',
'is_enabled': True
},
{
'caption': 'B',
'id': 'new:test2',
'is_enabled': True
},
]
})
choice_uuid = next(k
for k, v in multi_choice_field.data['captions'].items()
if v == 'A')
db.session.add(multi_choice_field)
db.session.flush()
# Add a manager-only section
management_section = RegistrationFormSection(
registration_form=dummy_regform,
title='manager_section',
is_manager_only=True)
db.session.add(management_section)
db.session.flush()
checkbox_field = RegistrationFormField(parent_id=management_section.id,
registration_form=dummy_regform)
_fill_form_field_with_data(checkbox_field, {
'input_type': 'checkbox',
'is_required': True,
'title': 'Checkbox'
})
db.session.add(checkbox_field)
db.session.flush()
# Create a registration
data = {
boolean_field.html_field_name: True,
multi_choice_field.html_field_name: {
choice_uuid: 2
},
checkbox_field.html_field_name: True,
'email': dummy_user.email,
'first_name': dummy_user.first_name,
'last_name': dummy_user.last_name
}
reg = create_registration(dummy_regform,
data,
invitation=None,
management=True,
notify_user=False)
assert reg.data_by_field[boolean_field.id].data
assert reg.data_by_field[multi_choice_field.id].data == {choice_uuid: 2}
assert reg.data_by_field[checkbox_field.id].data
# Modify the registration
data = {
boolean_field.html_field_name: True,
multi_choice_field.html_field_name: {
choice_uuid: 1
},
checkbox_field.html_field_name: False,
}
modify_registration(reg, data, management=False, notify_user=False)
assert reg.data_by_field[boolean_field.id].data
assert reg.data_by_field[multi_choice_field.id].data == {choice_uuid: 1}
# Assert that the manager field is not changed
assert reg.data_by_field[checkbox_field.id].data
# Modify as a manager
data = {
multi_choice_field.html_field_name: {
choice_uuid: 3
},
checkbox_field.html_field_name: False,
}
modify_registration(reg, data, management=True, notify_user=False)
assert reg.data_by_field[boolean_field.id].data
assert reg.data_by_field[multi_choice_field.id].data == {choice_uuid: 3}
assert not reg.data_by_field[checkbox_field.id].data
# Add a new field after registering
new_multi_choice_field = RegistrationFormField(
parent_id=user_section.id, registration_form=dummy_regform)
_fill_form_field_with_data(
new_multi_choice_field, {
'input_type': 'multi_choice',
'with_extra_slots': False,
'title': 'Multi Choice',
'choices': [
{
'caption': 'A',
'id': 'new:test3',
'is_enabled': True
},
]
})
db.session.add(new_multi_choice_field)
db.session.flush()
modify_registration(reg, {}, management=False, notify_user=False)
assert reg.data_by_field[boolean_field.id].data
assert reg.data_by_field[multi_choice_field.id].data == {choice_uuid: 3}
assert not reg.data_by_field[checkbox_field.id].data
# Assert that the new field got a default value
assert reg.data_by_field[new_multi_choice_field.id].data == {}
# Remove a field after registering
multi_choice_field.is_deleted = True
db.session.flush()
data = {
multi_choice_field.html_field_name: {
choice_uuid: 7
},
}
modify_registration(reg, data, management=True, notify_user=False)
assert reg.data_by_field[boolean_field.id].data
# Assert that the removed field keeps its old value
assert reg.data_by_field[multi_choice_field.id].data == {choice_uuid: 3}
assert not reg.data_by_field[checkbox_field.id].data
assert reg.data_by_field[new_multi_choice_field.id].data == {}
