def edit(session, line):
derived_line = _fetch_derived_line(session, line)
if derived_line is None:
session.rollback()
raise ElementNotExistsError('Protocol Line',
protocol_id=line.protocolid)
line.update_data_source(derived_line)
line_row = _fetch_line(session, line.id)
if line_row is None:
session.rollback()
raise ElementNotExistsError('Line', line_id=line.id)
line.update_data_source(line_row)
_commit_or_abort(session, ElementEditionError, derived_line, line_row)
def get(session, line_id):
line = session.query(LineSchema).filter(LineSchema.id == line_id).first()
if not line:
raise ElementNotExistsError('Line', line_id=line_id)
return _convert_to_model(line)
def get_by_extension_id(extension_id):
context = find_by_extension_id(extension_id)
if not context:
raise ElementNotExistsError('Context', extension_id=extension_id)
return context
def test_get_not_found(self, profile_service_get):
expected_status_code = 404
profile_service_get.side_effect = ElementNotExistsError('cti_profile')
result = self.app.get('%s/%s' % (BASE_URL, 1))
assert_that(result.status_code, equal_to(expected_status_code))
def _get_config_from_provd(config_id):
config_manager = provd_connector.config_manager()
try:
return config_manager.get(config_id)
except HTTPError as e:
if e.code == 404:
raise ElementNotExistsError('device config', id=config_id)
raise
def test_validate_dissociation_user_not_exists(self, patch_dao):
user_voicemail = Mock(UserVoicemail, user_id=3)
patch_dao.side_effect = ElementNotExistsError(
'User', id=user_voicemail.user_id)
self.assertRaises(NonexistentParametersError,
validator.validate_dissociation, user_voicemail)
def test_validate_association_when_user_does_not_exist(self, user_get):
user_voicemail = UserVoicemail(user_id=1, voicemail_id=2)
user_get.side_effect = ElementNotExistsError('user',
id=user_voicemail.user_id)
self.assertRaises(NonexistentParametersError,
validator.validate_association, user_voicemail)
user_get.assert_called_once_with(user_voicemail.user_id)
def get(session, func_key_id):
query = QueryHelper(session).select_func_key(func_key_id)
row = query.first()
if not row:
raise ElementNotExistsError('FuncKey')
return db_converter.to_model(row)
def test_when_element_not_exists_is_raised(self):
expected_status_code = 404
expected_message = ["element with id=1 does not exist"]
exception = ElementNotExistsError('element', id=1)
response = make_error_response(exception)
self.assertResponse(response, expected_status_code, expected_message)
def test_validate_extension_when_no_extension(self, extension_get):
line_extension = Mock(LineExtension, line_id=1, extension_id=2)
extension_get.side_effect = ElementNotExistsError('Extension', id=2)
self.assertRaises(NonexistentParametersError,
validator.validate_extension, line_extension)
extension_get.assert_called_once_with(line_extension.extension_id)
def test_validate_line_when_no_line(self, line_get):
line_extension = Mock(LineExtension, line_id=1)
line_get.side_effect = ElementNotExistsError('Line', id=1)
self.assertRaises(NonexistentParametersError, validator.validate_line,
line_extension)
line_get.assert_called_once_with(line_extension.line_id)
def _get_voicemail_row(session, voicemail_id):
row = (session.query(VoicemailSchema).filter(
VoicemailSchema.uniqueid == voicemail_id).first())
if not row:
raise ElementNotExistsError('Voicemail', uniqueid=voicemail_id)
return row
def get(session, context_name):
context_row = (session.query(ContextSchema).filter(
ContextSchema.name == context_name).first())
if not context_row:
raise ElementNotExistsError('Context', name=context_name)
return context_converter.to_model(context_row)
def find_profile_by_userid(session, userid):
user = session.query(UserSchema).filter(UserSchema.id == userid).first()
if user is None:
raise ElementNotExistsError('user', id=userid)
if user.cti_profile_id is None:
return None
row = session.query(CtiProfileSchema).filter(CtiProfileSchema.id == user.cti_profile_id).first()
return cti_profile_db_converter.to_model(row)
def get_by_exten_context(session, exten, context):
res = (session.query(ExtensionSchema).filter(
ExtensionSchema.exten == exten).filter(
ExtensionSchema.context == context)).first()
if not res:
raise ElementNotExistsError('Extension', exten=exten, context=context)
return db_converter.to_model(res)
def _delete_provd_device(device):
provd_device_manager = provd_connector.device_manager()
try:
provd_device_manager.remove(device.id)
except HTTPError as e:
if e.code == 404:
raise ElementNotExistsError('Device', id=device.id)
raise e
except Exception as e:
raise ElementDeletionError('Device', e)
def test_validate_edition_unexisting_user(self, patch_get_user,
patch_get_profile):
user_cti_profile = UserCtiProfile(user_id=1,
cti_profile_id=2,
enabled=True)
patch_get_user.side_effect = ElementNotExistsError('user')
self.assertRaises(ElementNotExistsError, validator.validate_edit,
user_cti_profile)
patch_get_user.assert_called_with(user_cti_profile.user_id)
def test_when_user_destination_does_not_exist_then_raises_error(
self, user_dao_get):
user_dao_get.side_effect = ElementNotExistsError('User')
func_key = Mock(FuncKey, destination='user', destination_id=1)
self.assertRaisesRegexp(
NonexistentParametersError,
"Nonexistent parameters: user 1 does not exist",
validator.validate_destination_exists, func_key)
user_dao_get.assert_called_once_with(func_key.destination_id)
def get_by_user_id(session, user_id):
row = _fetch_by_user_id(session, user_id)
if not row:
raise ElementNotExistsError('User', id=user_id)
if row.voicemail_id is None or row.voicemail_id == 0:
raise UserVoicemailNotExistsError.from_user_id(user_id)
return db_converter.to_model(row)
def get_by_extension_id(extension_id):
context = context_dao.find_by_extension_id(extension_id)
if not context:
raise ElementNotExistsError('Extension', id=extension_id)
line_extension = _find_line_extension_by_type(context, extension_id)
if not line_extension:
raise LineExtensionNotExistsError.from_extension_id(extension_id)
return line_extension
def test_validate_dissociation_no_voicemail(self, user_dao_get,
voicemail_dao_get):
user_voicemail = Mock(UserVoicemail, user_id=3, voicemail_id=4)
user_dao_get.return_value = Mock()
voicemail_dao_get.side_effect = ElementNotExistsError(
'Voicemail', id=user_voicemail.voicemail_id)
self.assertRaises(NonexistentParametersError,
validator.validate_dissociation, user_voicemail)
def get_by_number_context(session, number, context):
row = (session.query(VoicemailSchema).filter(
VoicemailSchema.mailbox == number).filter(
VoicemailSchema.context == context).first())
if not row:
raise ElementNotExistsError('Voicemail',
number=number,
context=context)
return db_converter.to_model(row)
def test_when_number_context_do_not_exist(self, get_by_number_context):
voicemail = Voicemail(name='voicemail',
number='1001',
context='default')
get_by_number_context.side_effect = ElementNotExistsError('voicemail')
validator.validate_number_context(voicemail)
get_by_number_context.assert_called_once_with(voicemail.number,
voicemail.context)
def test_associate_voicemail_when_voicemail_inexistant(
self, get_user, get_voicemail):
user_id = 21
voicemail_id = 32
get_user.return_value = Mock()
get_voicemail.side_effect = ElementNotExistsError('voicemail')
self.assertRaises(ElementNotExistsError,
user_association.associate_voicemail, user_id,
voicemail_id)
def get_main_user_by_line_id(session, line_id):
row = (session.query(UserSchema, UserLineSchema)
.filter(UserLineSchema.user_id == UserSchema.id)
.filter(UserLineSchema.line_id == line_id)
.filter(UserLineSchema.main_user == True)
.first())
if not row:
raise ElementNotExistsError('MainUser', line_id=line_id)
user_row, _ = row
return db_converter.to_model(user_row)
def get_by_user_id(session, user_id):
line = (session.query(LineSchema).join(
UserLineSchema,
and_(UserLineSchema.user_id == user_id,
UserLineSchema.line_id == LineSchema.id,
UserLineSchema.main_line == True,
UserLineSchema.main_user == True)).first())
if not line:
raise ElementNotExistsError('Line', user_id=user_id)
return _convert_to_model(line)
def test_get_cti_profile_association_unexisting_user(self, user_cti_profile_get):
user_id = 1
expected_status_code = 404
expected_result = ['user with id=%d does not exist' % user_id]
user_cti_profile_get.side_effect = ElementNotExistsError('user', id=user_id)
result = self.app.get(BASE_URL % user_id)
assert_that(result.status_code, equal_to(expected_status_code))
assert_that(self._serialize_decode(result.data), equal_to(expected_result))
def test_get_line_associated_to_a_user_when_user_does_not_exist(
self, user_services_get):
expected_status_code = 404
expected_result = ["User with id=1 does not exist"]
user_services_get.side_effect = ElementNotExistsError(
'User', id=self.user_line.user_id)
result = self.app.get(BASE_URL % self.user_line.user_id)
assert_that(result.status_code, equal_to(expected_status_code))
assert_that(self._serialize_decode(result.data),
equal_to(expected_result))
def test_validate_dissociation_user_not_exists(self,
user_dao_get,
line_dao_get,
user_line_dao_find_all_by_user_id,
line_has_secondary_user):
user_line = Mock(UserLine, user_id=3)
user_dao_get.side_effect = ElementNotExistsError('User', id=user_line.user_id)
self.assertRaises(NonexistentParametersError, validator.validate_dissociation, user_line)
user_dao_get.assert_called_once_with(user_line.user_id)
self.assertEquals(line_dao_get.call_count, 0)
self.assertEquals(user_line_dao_find_all_by_user_id.call_count, 0)
self.assertEquals(line_has_secondary_user.call_count, 0)
def get_by_number_context(session, number, context):
line = (session.query(LineSchema).join(
Extension, and_(Extension.exten == number,
Extension.context == context)).join(
UserLineSchema,
and_(UserLineSchema.extension_id == Extension.id,
LineSchema.id == UserLineSchema.line_id,
UserLineSchema.main_line == True,
UserLineSchema.main_user == True))).first()
if not line:
raise ElementNotExistsError('Line', number=number, context=context)
return _convert_to_model(line)
