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