def _clone_form_items(self, old_form, new_form, clone_all_revisions):
old_sections = RegistrationFormSection.find(
RegistrationFormSection.registration_form_id == old_form.id)
items_attrs = get_simple_column_attrs(RegistrationFormSection)
for old_section in old_sections:
new_section = RegistrationFormSection(
**{attr: getattr(old_section, attr)
for attr in items_attrs})
for old_item in old_section.children:
new_item = RegistrationFormItem(
parent=new_section,
registration_form=new_form,
**{attr: getattr(old_item, attr)
for attr in items_attrs})
if new_item.is_field:
if clone_all_revisions:
self._clone_all_field_versions(old_item, new_item)
else:
field_data = RegistrationFormFieldData(
field=new_item,
versioned_data=old_item.versioned_data)
new_item.current_data = field_data
self._field_data_map[
old_item.current_data] = field_data
new_section.children.append(new_item)
new_form.form_items.append(new_section)
db.session.flush()
def _process(self):
section = RegistrationFormSection(registration_form=self.regform)
section.title = request.json['title']
section.description = request.json.get('description')
section.is_manager_only = request.json['is_manager_only']
db.session.add(section)
db.session.flush()
logger.info('Section %s created by %s', section, session.user)
return jsonify_data(**section.view_data)
def _process(self):
section = RegistrationFormSection(registration_form=self.regform)
section.title = request.json['title']
section.description = request.json.get('description')
section.is_manager_only = request.json['is_manager_only']
db.session.add(section)
db.session.flush()
logger.info('Section %s created by %s', section, session.user)
return jsonify_data(**section.view_data)
def _create_accompanying_persons_field(max_persons,
persons_count_against_limit,
registration=None,
data=None,
num_persons=0):
section = RegistrationFormSection(registration_form=dummy_regform,
title='dummy_section',
is_manager_only=False)
db.session.add(section)
db.session.flush()
field = RegistrationFormField(input_type='accompanying_persons',
title='Field',
parent=section,
registration_form=dummy_regform)
field.field_impl.form_item.data = {
'max_persons': max_persons,
'persons_count_against_limit': persons_count_against_limit,
}
field.versioned_data = field.field_impl.form_item.data
if registration:
registration.data.append(
RegistrationData(
field_data=field.current_data,
data=(data if data is not None else
_create_accompanying_persons(num_persons))))
db.session.flush()
return field
def _process(self):
new_position = request.json['endPos'] + 1
old_position = self.section.position
if new_position == old_position:
return jsonify(success=True)
elif new_position < old_position:
def fn(section):
return (section.position >= new_position
and section.id != self.section.id
and not section.is_deleted and section.is_enabled)
start_enum = new_position + 1
else:
def fn(section):
return (old_position < section.position <= new_position
and section.id != self.section.id
and not section.is_deleted and section.is_enabled)
start_enum = self.section.position
to_update = filter(
fn,
RegistrationFormSection.find(
registration_form=self.regform, is_deleted=False).order_by(
RegistrationFormSection.position).all())
self.section.position = new_position
for pos, section in enumerate(to_update, start_enum):
section.position = pos
db.session.flush()
return jsonify(success=True)
def _create_form(self):
create_personal_data_fields(self.regform)
for item in self.regform.form_items:
if not item.is_field:
item.position = 1 # pd section
continue
# we have nothing but personal data fields right now. no need for extra checks!
if item.personal_data_type != PersonalDataType.country:
self.pd_field_map[item.personal_data_type] = item
if item.personal_data_type == PersonalDataType.title:
self.title_map = {
v: k
for k, v in item.data['captions'].iteritems()
}
# create administrative section for statuses
if self.status_used:
section = RegistrationFormSection(registration_form=self.regform,
is_manager_only=True,
title='Status',
position=2)
if self.status_used:
choices = []
for status in ('refused', 'excused', 'invited', 'accepted',
'rejected', 'declined'):
uuid = unicode(uuid4())
caption = status.title()
choices.append({
'price': 0,
'is_billable': False,
'places_limit': 0,
'is_enabled': True,
'caption': caption,
'id': uuid
})
self.status_map[status] = {
'uuid': uuid,
'caption': caption
}
field_data = {
'item_type': 'dropdown',
'with_extra_slots': False,
'default_item': None,
'choices': choices
}
self.status_field = field = RegistrationFormField(
registration_form=self.regform,
parent=section,
input_type='single_choice',
title='Status')
field.data, field.versioned_data = field.field_impl.process_field_data(
field_data)
def _clone_form_items(self, old_form, new_form, clone_all_revisions):
old_sections = RegistrationFormSection.find(RegistrationFormSection.registration_form_id == old_form.id)
items_attrs = get_simple_column_attrs(RegistrationFormSection)
for old_section in old_sections:
new_section = RegistrationFormSection(**{attr: getattr(old_section, attr) for attr in items_attrs})
for old_item in old_section.children:
new_item = RegistrationFormItem(parent=new_section, registration_form=new_form,
**{attr: getattr(old_item, attr) for attr in items_attrs})
if new_item.is_field:
if clone_all_revisions:
self._clone_all_field_versions(old_item, new_item)
else:
field_data = RegistrationFormFieldData(field=new_item,
versioned_data=old_item.versioned_data)
new_item.current_data = field_data
self._field_data_map[old_item.current_data] = field_data
new_section.children.append(new_item)
new_form.form_items.append(new_section)
db.session.flush()
def _process(self):
new_position = request.json['endPos'] + 1
old_position = self.section.position
if new_position == old_position:
return jsonify(success=True)
elif new_position < old_position:
def fn(section):
return section.position >= new_position and section.id != self.section.id
start_enum = new_position + 1
else:
def fn(section):
return (section.position > old_position and section.position <= new_position
and section.id != self.section.id)
start_enum = self.section.position
to_update = filter(fn, RegistrationFormSection.find(registration_form=self.regform, is_deleted=False)
.order_by(RegistrationFormSection.position).all())
self.section.position = new_position
for pos, section in enumerate(to_update, start_enum):
section.position = pos
db.session.flush()
return jsonify(success=True)
def _checkParams(self, params):
RHManageRegFormBase._checkParams(self, params)
self.section = RegistrationFormSection.get_one(request.view_args['section_id'])
def _process_args(self):
RHManageRegFormBase._process_args(self)
self.section = RegistrationFormSection.get_one(request.view_args['section_id'])
def _process_args(self):
RHManageRegFormBase._process_args(self)
self.section = RegistrationFormSection.get_or_404(
request.view_args['section_id'])
def _checkParams(self, params):
RHManageRegFormBase._checkParams(self, params)
self.section = RegistrationFormSection.get_one(
request.view_args['section_id'])
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 == {}
def test_create_registration(monkeypatch, dummy_event, dummy_user,
dummy_regform):
monkeypatch.setattr('indico.modules.users.util.get_user_by_email',
lambda *args, **kwargs: dummy_user)
# Extend the dummy_regform with more sections and fields
section = RegistrationFormSection(registration_form=dummy_regform,
title='dummy_section',
is_manager_only=False)
db.session.add(section)
db.session.flush()
boolean_field = RegistrationFormField(parent_id=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=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
},
]
})
db.session.add(multi_choice_field)
db.session.flush()
data = {
boolean_field.html_field_name: True,
multi_choice_field.html_field_name: {
'test1': 2
},
'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=False,
notify_user=False)
assert reg.data_by_field[boolean_field.id].data
assert reg.data_by_field[multi_choice_field.id].data == {'test1': 2}
db.session.delete(reg)
db.session.flush()
# Make sure that missing data gets default values:
data = {
'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=False,
notify_user=False)
assert not reg.data_by_field[boolean_field.id].data
assert reg.data_by_field[multi_choice_field.id].data == {}
db.session.delete(reg)
db.session.flush()
# Add a manager only section
section = RegistrationFormSection(registration_form=dummy_regform,
title='manager_section',
is_manager_only=True)
db.session.add(section)
db.session.flush()
checkbox_field = RegistrationFormField(parent_id=section.id,
registration_form=dummy_regform)
_fill_form_field_with_data(checkbox_field, {
'input_type': 'checkbox',
'title': 'Checkbox'
})
db.session.add(checkbox_field)
db.session.flush()
data = {
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=False,
notify_user=False)
assert not reg.data_by_field[boolean_field.id].data
assert reg.data_by_field[multi_choice_field.id].data == {}
# Assert that the manager field gets the default value, not the value sent
assert not reg.data_by_field[checkbox_field.id].data
db.session.delete(reg)
db.session.flush()
# Try again with management=True
data = {
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 not reg.data_by_field[boolean_field.id].data
assert reg.data_by_field[multi_choice_field.id].data == {}
# Assert that the manager field gets properly set with management=True
assert reg.data_by_field[checkbox_field.id].data
