def db_update_fieldattr(session, field_id, attr_name, attr_dict, language):
"""
Transaction for updating a fieldattr
:param session: An ORM session
:param field_id: The field on which the attribute is configured
:param attr_name: The attribute name
:param attr_dict: The attribute configuration
:param language: The language of the request
:return: The ID of the attribute
"""
attr_dict['name'] = attr_name
attr_dict['field_id'] = field_id
if attr_dict['type'] == 'localized' and language is not None:
fill_localized_keys(attr_dict, ['value'], language)
o = session.query(models.FieldAttr).filter(models.FieldAttr.field_id == field_id, models.FieldAttr.name == attr_name).one_or_none()
if o is None:
attr_dict['id'] = ''
o = db_add(session, models.FieldAttr, attr_dict)
else:
o.update(attr_dict)
return o.id
def db_update_fieldoption(session, field_id, fieldoption_id, option_dict, language, idx):
"""
Transaction to update a field option
:param session: An ORM session
:param field_id: The field ID of the field on which the option is set
:param fieldoption_id: The option ID
:param option_dict: The option configuration
:param language: The language of the request
:param idx: The order index with reference to the other options set
:return: The serialized descriptor of the option
"""
option_dict['field_id'] = field_id
fill_localized_keys(option_dict, models.FieldOption.localized_keys, language)
o = None
if fieldoption_id is not None:
o = session.query(models.FieldOption).filter(models.FieldOption.id == fieldoption_id).one_or_none()
if o is None:
o = db_add(session, models.FieldOption, option_dict)
else:
o.update(option_dict)
o.order = idx
return o.id
def db_schedule_email(session, tid, address, subject, body):
return db_add(session, models.Mail, {
'address': address,
'subject': subject,
'body': body,
'tid': tid,
})
def create(session, tid, request):
"""
Transaction for registering the creation of a redirect for a tenant
:param session: An ORM session
:param tid: A tenant ID
:param request: The request data
:return: The descriptor of the registered redirect
"""
request['tid'] = tid
redirect = db_add(session, models.Redirect, request)
return serialize_redirect(redirect)
def db_create_questionnaire(session, tid, questionnaire_dict, language):
fill_localized_keys(questionnaire_dict,
models.Questionnaire.localized_keys, language)
questionnaire_dict['tid'] = tid
q = db_add(session, models.Questionnaire, questionnaire_dict)
for step in questionnaire_dict.get('steps', []):
step['questionnaire_id'] = q.id
db_create_step(session, tid, step, language)
return q
def db_create_context(session, tid, request, language):
"""
Transaction for creating a context
:param session: An ORM session
:param tid: The tenant ID
:param request: The request data
:param language: The request language
:return: The created context
"""
request = fill_context_request(tid, request, language)
context = db_add(session, models.Context, request)
db_associate_context_receivers(session, context, request['receivers'])
return context
def db_create_step(session, tid, request, language):
"""
Transaction for creating a step
:param session: An ORM session
:param tid: A tenant ID
:param request: The request data
:param session: the session on which perform queries.
:param language: the language of the specified steps.
"""
fill_localized_keys(request, models.Step.localized_keys, language)
step = db_add(session, models.Step, request)
for trigger in request.get('triggered_by_options', []):
db_create_option_trigger(session, trigger['option'], 'step', step.id, trigger.get('sufficient', True))
for c in request['children']:
c['tid'] = tid
c['step_id'] = step.id
db_create_field(session, tid, c, language)
return serialize_step(session, tid, step, language)
def db_create_field(session, tid, request, language):
"""
Transaction for creating a field
:param session: An ORM session
:param tid: The tenant ID
:param request: The request data
:param language: The language of the request
:return: The created field
"""
request['tid'] = tid
fill_localized_keys(request, models.Field.localized_keys, language)
check_field_association(session, tid, request)
if request.get('template_id', '') != '':
if request['template_id'] == 'whistleblower_identity':
if request.get('step_id', '') == '':
raise errors.InputValidationError("Cannot associate whistleblower identity field to a fieldgroup")
q_id = session.query(models.Questionnaire.id) \
.filter(models.Questionnaire.id == models.Step.questionnaire_id,
models.Step.id == request['step_id'])
field = session.query(models.Field) \
.filter(models.Field.template_id == 'whistleblower_identity',
models.Field.step_id == models.Step.id,
models.Step.questionnaire_id.in_(q_id.subquery())).one_or_none()
if field is not None:
raise errors.InputValidationError("Whistleblower identity field already present")
field = db_add(session, models.Field, request)
template = session.query(models.Field).filter(models.Field.id == request['template_id']).one()
field.label = template.label
field.description = template.description
field.hint = template.hint
field.placeholder = template.placeholder
attrs = request.get('attrs')
if not attrs:
field_attrs = read_json_file(Settings.field_attrs_file)
attrs = field_attrs.get(field.template_id, {})
db_update_fieldattrs(session, field.id, attrs, None)
else:
field = db_add(session, models.Field, request)
attrs = request.get('attrs')
options = request.get('options')
db_update_fieldattrs(session, field.id, attrs, language)
db_update_fieldoptions(session, field.id, options, language)
for trigger in request.get('triggered_by_options', []):
db_create_option_trigger(session, trigger['option'], 'field', field.id, trigger.get('sufficient', True))
if field.instance != 'reference':
for c in request.get('children', []):
c['tid'] = field.tid
c['fieldgroup_id'] = field.id
db_create_field(session, tid, c, language)
return field