def update_substatus_model_from_request(model_obj, request, language):
"""Populates the model off each value from requests['substatus']"""
fill_localized_keys(request, models.SubmissionSubStatus.localized_keys, language)
model_obj.label = request['label']
model_obj.presentation_order = request['presentation_order']
return model_obj
def db_update_step(session, tid, step_id, step_dict, language):
"""
Update the specified step with the details.
:param session: the session on which perform queries.
:param step_id: the step_id of the step to update
:param step_dict: the step definition dict
:param language: the language of the step definition dict
:return: a serialization of the object
"""
step = models.db_get(
session, models.Step, models.Step.id == step_id,
models.Questionnaire.id == models.Step.questionnaire_id,
models.Questionnaire.tid == tid)
fill_localized_keys(step_dict, models.Step.localized_keys, language)
step.update(step_dict)
for child in step_dict['children']:
db_update_field(session, tid, child['id'], child, language)
db_reset_option_triggers(session, 'step', step.id)
for trigger in step_dict.get('triggered_by_options', []):
db_create_trigger(session, tid, trigger['option'], 'step', step.id,
trigger.get('sufficient', True))
return step
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 = models.db_forge_obj(session, models.FieldAttr, attr_dict)
else:
o.update(attr_dict)
return o.id
def db_update_field(session, tid, field_id, field_dict, language):
field = models.db_get(session, models.Field, models.Field.tid == tid,
models.Field.id == field_id)
check_field_association(session, tid, field_dict)
fill_localized_keys(field_dict, models.Field.localized_keys, language)
db_update_fieldattrs(session, tid, field.id, field_dict['attrs'], language)
if field_dict['instance'] != 'reference':
db_update_fieldoptions(session, tid, field.id, field_dict['options'],
language)
# full update
field.update(field_dict)
else:
# partial update
field.update({
'label': field_dict['label'],
'hint': field_dict['hint'],
'description': field_dict['description'],
'template_override_id': field_dict['template_override_id'],
'x': field_dict['x'],
'y': field_dict['y'],
'width': field_dict['width'],
'required': field_dict['required']
})
return field
def db_create_field(session, tid, field_dict, language):
"""
Create and add a new field to the session, then return the new serialized object.
"""
field_dict['tid'] = tid
fill_localized_keys(field_dict, models.Field.localized_keys, language)
check_field_association(session, tid, field_dict)
if field_dict.get('template_id', '') != '':
if field_dict['template_id'] == 'whistleblower_identity':
if field_dict.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 == field_dict['step_id'])
field = session.query(models.Field) \
.filter(models.Field.template_id == u'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 = models.db_forge_obj(session, models.Field, field_dict)
template = session.query(models.Field).filter(models.Field.id == field_dict['template_id']).one()
field.label = template.label
field.hint = template.hint
field.description = template.description
attrs = field_dict.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 = models.db_forge_obj(session, models.Field, field_dict)
attrs = field_dict.get('attrs')
options = field_dict.get('options')
db_update_fieldattrs(session, field.id, attrs, language)
db_update_fieldoptions(session, field.id, options, language)
for trigger in field_dict.get('triggered_by_options', []):
db_create_trigger(session, tid, trigger['option'], 'field', field.id, trigger.get('sufficient', True))
if field.instance != 'reference':
for c in field_dict.get('children', []):
c['tid'] = field.tid
c['fieldgroup_id'] = field.id
db_create_field(session, tid, c, language)
return field
def db_update_field(session, tid, field_id, field_dict, language):
field = models.db_get(session, models.Field, models.Field.tid == tid, models.Field.id == field_id)
check_field_association(session, tid, field_dict)
fill_localized_keys(field_dict, models.Field.localized_keys, language)
db_update_fieldattrs(session, field.id, field_dict['attrs'], language)
db_reset_option_triggers(session, 'field', field.id)
for trigger in field_dict.get('triggered_by_options', []):
db_create_trigger(session, tid, trigger['option'], 'field', field.id, trigger.get('sufficient', True))
if field_dict['instance'] != 'reference':
db_update_fieldoptions(session, field.id, field_dict['options'], language)
# full update
field.update(field_dict)
else:
# partial update
field.update({
'label': field_dict['label'],
'hint': field_dict['hint'],
'description': field_dict['description'],
'placeholder': field_dict['placeholder'],
'template_override_id': field_dict['template_override_id'],
'x': field_dict['x'],
'y': field_dict['y'],
'width': field_dict['width'],
'required': field_dict['required']
})
return field
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 = models.db_forge_obj(session, models.FieldOption, option_dict)
else:
o.update(option_dict)
o.order = idx
return o.id
def db_admin_update_user(session, tid, user_id, request, language):
"""
Updates the specified user.
"""
fill_localized_keys(request, models.User.localized_keys, language)
user = db_get_user(session, tid, user_id)
if user.username != request['username']:
check = session.query(models.User).filter(
models.User.username == text_type(request['username']),
models.User.tid == tid).one_or_none()
if check is not None:
raise errors.InputValidationError('Username already in use')
user.update(request)
password = request['password']
if password:
user.hash_alg = GCE.HASH
user.salt = GCE.generate_salt()
user.password = GCE.hash_password(password, user.salt)
user.password_change_date = datetime_now()
user.crypto_prv_key = b''
user.crypto_pub_key = b''
# The various options related in manage PGP keys are used here.
parse_pgp_options(user, request)
if user.role == 'admin':
db_refresh_memory_variables(session, [tid])
return user
def update_status_model_from_request(model_obj, request, language):
"""Populates the model from the request, as well as setting default values"""
fill_localized_keys(request, models.SubmissionStatus.localized_keys, language)
model_obj.label = request['label']
model_obj.presentation_order = request['presentation_order']
return model_obj
def db_admin_update_user(session, tid, user_id, request, language):
"""
Updates the specified user.
"""
fill_localized_keys(request, models.User.localized_keys, language)
user = db_get_user(session, tid, user_id)
if user.username != request['username']:
check = session.query(models.User).filter(models.User.username == text_type(request['username']),
models.UserTenant.user_id == models.User.id,
models.UserTenant.tenant_id == tid).one_or_none()
if check is not None:
raise errors.InputValidationError('Username already in use')
user.update(request)
password = request['password']
if password:
user.hash_alg = GCE.HASH
user.salt = GCE.generate_salt()
user.password = GCE.hash_password(password, user.salt)
user.password_change_date = datetime_now()
user.crypto_prv_key = b''
user.crypto_pub_key = b''
# The various options related in manage PGP keys are used here.
parse_pgp_options(user, request)
if user.role == 'admin':
db_refresh_memory_variables(session, [tid])
return user
def db_update_field(session, tid, field_id, field_dict, language):
field = models.db_get(session, models.Field, models.Field.tid == tid, models.Field.id == field_id)
check_field_association(session, tid, field_dict)
fill_localized_keys(field_dict, models.Field.localized_keys, language)
db_update_fieldattrs(session, field.id, field_dict['attrs'], language)
db_reset_option_triggers(session, 'field', field.id)
for trigger in field_dict.get('triggered_by_options', []):
db_create_trigger(session, tid, trigger['option'], 'field', field.id, trigger.get('sufficient', True))
if field_dict['instance'] != 'reference':
db_update_fieldoptions(session, field.id, field_dict['options'], language)
# full update
field.update(field_dict)
else:
# partial update
field.update({
'label': field_dict['label'],
'hint': field_dict['hint'],
'description': field_dict['description'],
'placeholder': field_dict['placeholder'],
'template_override_id': field_dict['template_override_id'],
'x': field_dict['x'],
'y': field_dict['y'],
'width': field_dict['width'],
'required': field_dict['required']
})
return field
def db_update_step(session, tid, step_id, step_dict, language):
"""
Update the specified step with the details.
:param session: the session on which perform queries.
:param step_id: the step_id of the step to update
:param step_dict: the step definition dict
:param language: the language of the step definition dict
:return: a serialization of the object
"""
step = models.db_get(session, models.Step, models.Step.id == step_id,
models.Questionnaire.id == models.Step.questionnaire_id,
models.Questionnaire.tid == tid)
fill_localized_keys(step_dict, models.Step.localized_keys, language)
step.update(step_dict)
for child in step_dict['children']:
db_update_field(session, tid, child['id'], child, language)
db_reset_option_triggers(session, 'step', step.id)
for trigger in step_dict.get('triggered_by_options', []):
db_create_trigger(session, tid, trigger['option'], 'step', step.id, trigger.get('sufficient', True))
return step
def db_create_user(session, tid, request, language):
"""
Transaction for creating a new user
:param session: An ORM session
:param tid: A tenant ID
:param request: The request data
:param language: The language of the request
:return: The serialized descriptor of the created object
"""
request['tid'] = tid
fill_localized_keys(request, models.User.localized_keys, language)
if not request['public_name']:
request['public_name'] = request['name']
user = models.User(request)
if not request['username']:
user.username = user.id
user.salt = GCE.generate_salt()
# The various options related in manage PGP keys are used here.
parse_pgp_options(user, request)
session.add(user)
session.flush()
if request.get('send_account_activation_link', False):
db_generate_password_reset_token(session, user)
return user
def db_update_step(session, tid, step_id, request, language):
"""
Transaction for updating a step
:param session: An ORM session
:param tid: The tenant ID
:param step_id: the step_id of the step to update
:param request: the step definition dict
:param language: the language of the step definition dict
:return: a serialization of the object
"""
step = models.db_get(
session, models.Step, models.Step.id == step_id,
models.Questionnaire.id == models.Step.questionnaire_id,
models.Questionnaire.tid == tid)
fill_localized_keys(request, models.Step.localized_keys, language)
step.update(request)
for child in request['children']:
db_update_field(session, tid, child['id'], child, language)
db_reset_option_triggers(session, 'step', step.id)
for trigger in request.get('triggered_by_options', []):
db_create_option_trigger(session, trigger['option'], 'step', step.id,
trigger.get('sufficient', True))
return serialize_step(session, tid, step, language)
def update_status_model_from_request(model_obj, request, language):
"""Populates the model from the request, as well as setting default values"""
fill_localized_keys(request, models.SubmissionStatus.localized_keys,
language)
model_obj.label = request['label']
model_obj.presentation_order = request['presentation_order']
return model_obj
def update_substatus_model_from_request(model_obj, request, language):
"""Populates the model off each value from requests['substatus']"""
fill_localized_keys(request, models.SubmissionSubStatus.localized_keys,
language)
model_obj.label = request['label']
model_obj.presentation_order = request['presentation_order']
return model_obj
def db_create_user(session, tid, request, language):
request['tid'] = tid
fill_localized_keys(request, models.User.localized_keys, language)
if request['username']:
user = session.query(models.User).filter(
models.User.username == text_type(request['username']),
models.UserTenant.user_id == models.User.id,
models.UserTenant.tenant_id == tid).one_or_none()
if user is not None:
raise errors.InputValidationError('Username already in use')
user = models.User({
'tid':
tid,
'username':
request['username'],
'role':
request['role'],
'state':
u'enabled',
'name':
request['name'],
'description':
request['description'],
'language':
language,
'password_change_needed':
request['password_change_needed'],
'mail_address':
request['mail_address'],
'can_edit_general_settings':
request['can_edit_general_settings']
})
if not request['username']:
user.username = user.id = uuid4()
password = u'password'
if request['password']:
password = request['password']
user.hash_alg = GCE.HASH
user.salt = GCE.generate_salt()
user.password = GCE.hash_password(password, user.salt)
# The various options related in manage PGP keys are used here.
parse_pgp_options(user, request)
session.add(user)
session.flush()
db_create_usertenant_association(session, user.id, tid)
return user
def db_admin_update_user(session, tid, user_session, user_id, request,
language):
"""
Transaction for updating an existing user
:param session: An ORM session
:param tid: A tenant ID
:param user_session: The current user session
:param user_id: The ID of the user to update
:param request: The request data
:param language: The language of the request
:return: The serialized descriptor of the updated object
"""
fill_localized_keys(request, models.User.localized_keys, language)
user = db_get_user(session, tid, user_id)
if user.username != request['username']:
check = session.query(models.User).filter(
models.User.username == request['username'],
models.User.tid == tid).one_or_none()
if check is not None:
raise errors.InputValidationError('Username already in use')
user.update(request)
password = request['password']
if password and (not user.crypto_pub_key or user_session.ek):
if user.crypto_pub_key and user_session.ek:
enc_key = GCE.derive_key(password.encode(), user.salt)
crypto_escrow_prv_key = GCE.asymmetric_decrypt(
user_session.cc, Base64Encoder.decode(user_session.ek))
if tid == 1:
user_cc = GCE.asymmetric_decrypt(
crypto_escrow_prv_key,
Base64Encoder.decode(user.crypto_escrow_bkp1_key))
else:
user_cc = GCE.asymmetric_decrypt(
crypto_escrow_prv_key,
Base64Encoder.decode(user.crypto_escrow_bkp2_key))
user.crypto_prv_key = Base64Encoder.encode(
GCE.symmetric_encrypt(enc_key, user_cc))
if user.hash_alg != 'ARGON2':
user.hash_alg = 'ARGON2'
user.salt = GCE.generate_salt()
user.password = GCE.hash_password(password, user.salt)
user.password_change_date = datetime_now()
user.password_change_needed = True
# The various options related in manage PGP keys are used here.
parse_pgp_options(user, request)
return user_serialize_user(session, user, language)
def db_update_substatus_model_from_request(model_obj, request, language):
"""
Populates the model from the request, as well as setting default values
:param model_obj: The object model
:param request: The request data
:param language: The language of the request
"""
fill_localized_keys(request, models.SubmissionSubStatus.localized_keys, language)
model_obj.update(request)
def db_create_questionnaire(session, state, tid, questionnaire_dict, language):
fill_localized_keys(questionnaire_dict, models.Questionnaire.localized_keys, language)
questionnaire_dict['tid'] = tid
q = models.db_forge_obj(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 update_receiver(session, tid, receiver_id, request, language):
"""
Updates the specified receiver with the details.
"""
fill_localized_keys(request, models.Receiver.localized_keys, language)
receiver, user = db_get_receiver(session, tid, receiver_id)
receiver.update(request)
return admin_serialize_receiver(session, receiver, user, language)
def db_create_questionnaire(session, tid, questionnaire_dict, language):
fill_localized_keys(questionnaire_dict, models.Questionnaire.localized_keys, language)
questionnaire_dict['tid'] = tid
q = models.db_forge_obj(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 fill_context_request(tid, request, language):
request['tid'] = tid
fill_localized_keys(request, models.Context.localized_keys, language)
if not request['allow_recipients_selection']:
request['select_all_receivers'] = True
request['tip_timetolive'] = 0 if request['tip_timetolive'] < 0 else request['tip_timetolive']
if request['select_all_receivers']:
request['maximum_selectable_receivers'] = 0
return request
def fill_context_request(tid, request, language):
request['tid'] = tid
fill_localized_keys(request, models.Context.localized_keys, language)
if not request['allow_recipients_selection']:
request['select_all_receivers'] = True
request['tip_timetolive'] = 0 if request['tip_timetolive'] < 0 else request['tip_timetolive']
if request['select_all_receivers']:
request['maximum_selectable_receivers'] = 0
return request
def db_update_fieldattr(session, field_id, attr_name, attr_dict, language):
attr_dict['name'] = attr_name
attr_dict['field_id'] = field_id
if attr_dict['type'] == u'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:
o = models.db_forge_obj(session, models.FieldAttr, attr_dict)
else:
o.update(attr_dict)
return o.id
def db_update_field(session, tid, field_id, request, language):
"""
Transaction for updating a field
:param session: An ORM session
:param tid: The tenant ID
:param field_id: The ID of the object to be updated
:param request: The request data
:param language: The language of the request
:return: The updated field
"""
field = db_get(session,
models.Field,
(models.Field.tid == tid,
models.Field.id == field_id))
check_field_association(session, tid, request)
fill_localized_keys(request, models.Field.localized_keys, language)
if field.instance != 'reference' or field.template_id == 'whistleblower_identity':
db_update_fieldattrs(session, field.id, request['attrs'], language)
db_reset_option_triggers(session, 'field', field.id)
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':
db_update_fieldoptions(session, field.id, request['options'], language)
# full update
field.update(request)
else:
# partial update
field.update({
'label': request['label'],
'hint': request['hint'],
'description': request['description'],
'placeholder': request['placeholder'],
'template_override_id': request['template_override_id'],
'x': request['x'],
'y': request['y'],
'width': request['width'],
'required': request['required']
})
return field
def db_create_receiver_user(session, state, tid, request, language):
"""
Creates a new receiver
Returns:
(dict) the receiver descriptor
"""
fill_localized_keys(request, models.Receiver.localized_keys, language)
user = db_create_user(session, state, tid, request, language)
request['id'] = user.id
receiver = models.db_forge_obj(session, models.Receiver, request)
return receiver, user
def db_update_fieldoption(session, field_id, fieldoption_id, option_dict, language, idx):
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 = models.db_forge_obj(session, models.FieldOption, option_dict)
else:
o.update(option_dict)
o.presentation_order = idx
return o.id
def db_create_step(session, tid, step_dict, language):
"""
Create the specified step
:param session: the session on which perform queries.
:param language: the language of the specified steps.
"""
fill_localized_keys(step_dict, models.Step.localized_keys, language)
step = models.db_forge_obj(session, models.Step, step_dict)
for c in step_dict['children']:
c['tid'] = tid
c['step_id'] = step.id
db_create_field(session, tid, c, language)
return step
def db_update_fieldoption(session, field_id, fieldoption_id, option_dict, language, idx):
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 = models.db_forge_obj(session, models.FieldOption, option_dict)
else:
o.update(option_dict)
o.presentation_order = idx
return o.id
def db_create_user(session, tid, request, language):
request['tid'] = tid
fill_localized_keys(request, models.User.localized_keys, language)
if request['username']:
user = session.query(models.User).filter(models.User.username == text_type(request['username']),
models.UserTenant.user_id == models.User.id,
models.UserTenant.tenant_id == tid).one_or_none()
if user is not None:
raise errors.InputValidationError('Username already in use')
user = models.User({
'tid': tid,
'username': request['username'],
'role': request['role'],
'state': u'enabled',
'name': request['name'],
'description': request['description'],
'language': language,
'password_change_needed': request['password_change_needed'],
'mail_address': request['mail_address'],
'can_edit_general_settings': request['can_edit_general_settings']
})
if not request['username']:
user.username = user.id = uuid4()
password = u'password'
if request['password']:
password = request['password']
user.hash_alg = GCE.HASH
user.salt = GCE.generate_salt()
user.password = GCE.hash_password(password, user.salt)
# The various options related in manage PGP keys are used here.
parse_pgp_options(user, request)
session.add(user)
session.flush()
db_create_usertenant_association(session, user.id, tid)
return user
def db_admin_update_user(session, tid, user_session, user_id, request, language):
"""
Transaction for updating an existing user
:param session: An ORM session
:param tid: A tenant ID
:param user_session: The current user session
:param user_id: The ID of the user to update
:param request: The request data
:param language: The language of the request
:return: The serialized descriptor of the updated object
"""
fill_localized_keys(request, models.User.localized_keys, language)
user = db_get_user(session, tid, user_id)
user.update(request)
password = request['password']
if password and (not user.crypto_pub_key or user_session.ek):
if user.crypto_pub_key and user_session.ek:
enc_key = GCE.derive_key(password.encode(), user.salt)
crypto_escrow_prv_key = GCE.asymmetric_decrypt(user_session.cc, Base64Encoder.decode(user_session.ek))
if user_session.user_tid == 1:
user_cc = GCE.asymmetric_decrypt(crypto_escrow_prv_key, Base64Encoder.decode(user.crypto_escrow_bkp1_key))
else:
user_cc = GCE.asymmetric_decrypt(crypto_escrow_prv_key, Base64Encoder.decode(user.crypto_escrow_bkp2_key))
user.crypto_prv_key = Base64Encoder.encode(GCE.symmetric_encrypt(enc_key, user_cc))
if user.hash_alg != 'ARGON2':
user.hash_alg = 'ARGON2'
user.salt = GCE.generate_salt()
user.password = GCE.hash_password(password, user.salt)
user.password_change_date = datetime_now()
State.log(tid=tid, type='change_password', user_id=user_session.user_id, object_id=user_id)
# The various options related in manage PGP keys are used here.
parse_pgp_options(user, request)
return user_serialize_user(session, user, language)
def db_update_questionnaire(session, tid, questionnaire_id, request, language):
"""
Updates the specified questionnaire. If the key receivers is specified we remove
the current receivers of the Questionnaire and reset set it to the new specified
ones.
:param session: An ORM session
:param tid: A tenant ID
:param questionnaire_id: The ID of the model to be updated
:param request: The request data
:param language: The language of the request
:return: A serialized descriptor of the questionnaire
"""
questionnaire = models.db_get(session, models.Questionnaire, models.Questionnaire.tid == tid, models.Questionnaire.id == questionnaire_id)
fill_localized_keys(request, models.Questionnaire.localized_keys, language)
questionnaire.update(request)
return serialize_questionnaire(session, tid, questionnaire, language)
def db_update_fieldattr(session, tid, field_id, attr_name, attr_dict,
language):
attr_dict['name'] = attr_name
attr_dict['field_id'] = field_id
attr_dict['tid'] = tid
if attr_dict['type'] == u'localized':
fill_localized_keys(attr_dict, ['value'], language)
a = session.query(models.FieldAttr).filter(
models.FieldAttr.field_id == field_id,
models.FieldAttr.name == attr_name,
models.FieldAttr.field_id == models.Field.id,
models.Field.tid == tid).one_or_none()
if a is None:
a = models.db_forge_obj(session, models.FieldAttr, attr_dict)
else:
a.update(attr_dict)
return a.id
def db_create_step(session, tid, step_dict, language):
"""
Create the specified step
:param session: the session on which perform queries.
:param language: the language of the specified steps.
"""
fill_localized_keys(step_dict, models.Step.localized_keys, language)
step = models.db_forge_obj(session, models.Step, step_dict)
for trigger in step_dict.get('triggered_by_options', []):
db_create_trigger(session, tid, trigger['option'], 'step', step.id, trigger.get('sufficient', True))
for c in step_dict['children']:
c['tid'] = tid
c['step_id'] = step.id
db_create_field(session, tid, c, language)
return step
def db_create_step(session, tid, step_dict, language):
"""
Create the specified step
:param session: the session on which perform queries.
:param language: the language of the specified steps.
"""
fill_localized_keys(step_dict, models.Step.localized_keys, language)
step = models.db_forge_obj(session, models.Step, step_dict)
for trigger in step_dict.get('triggered_by_options', []):
db_create_trigger(session, tid, trigger['option'], 'step', step.id,
trigger.get('sufficient', True))
for c in step_dict['children']:
c['tid'] = tid
c['step_id'] = step.id
db_create_field(session, tid, c, language)
return step
def fill_context_request(tid, request, language):
"""
An utility function for correcting requests for context configuration
:param tid: The tenant ID
:param request: The request data
:param language: The language of the request
:return: The request data corrected in some values
"""
request['tid'] = tid
fill_localized_keys(request, models.Context.localized_keys, language)
if not request['allow_recipients_selection']:
request['select_all_receivers'] = True
request['tip_timetolive'] = 0 if request['tip_timetolive'] < 0 else request['tip_timetolive']
if request['select_all_receivers']:
request['maximum_selectable_receivers'] = 0
return request
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_update_step(session, tid, step_id, request, language):
"""
Update the specified step with the details.
:param session: the session on which perform queries.
:param step_id: the step_id of the step to update
:param request: the step definition dict
:param language: the language of the step definition dict
:return: a serialization of the object
"""
step = models.db_get(
session, models.Step, models.Step.id == step_id,
models.Questionnaire.id == models.Step.questionnaire_id,
models.Questionnaire.tid == tid)
fill_localized_keys(request, models.Step.localized_keys, language)
step.update(request)
for child in request['children']:
db_update_field(session, tid, child['id'], child, language)
return step
def db_update_questionnaire(session, questionnaire, request, language):
fill_localized_keys(request, models.Questionnaire.localized_keys, language)
questionnaire.update(request)
return questionnaire
def update_substatus_model_from_request(model_obj, request, language):
"""Populates the model off each value from requests['substatus']"""
fill_localized_keys(request, models.SubmissionSubStatus.localized_keys,
language)
model_obj.update(request)
return model_obj
def update_status_model_from_request(model_obj, request, language):
"""Populates the model from the request, as well as setting default values"""
fill_localized_keys(request, models.SubmissionStatus.localized_keys,
language)
model_obj.update(request)
return model_obj
