def post(self):
form = self.schema().load(request.get_json())
form = self.add_tenant_to_form(form)
templates = []
for template in form['templates']:
try:
model = self.dao.get(
template['uuid'],
template=True,
tenant_uuids=[form['tenant_uuid']],
)
templates.append(model)
except NotFoundError:
metadata = {'templates': template}
raise errors.param_not_found('templates', 'endpoint_sip',
**metadata)
form['templates'] = templates
if form.get('transport'):
transport_uuid = form['transport']['uuid']
try:
form['transport'] = self.transport_dao.get(transport_uuid)
except NotFoundError as e:
raise errors.param_not_found('transport', 'SIPTransport',
**e.metadata)
model = self.model(**form)
model = self.service.create(model)
return self.schema().dump(model), 201, self.build_headers(model)
def put(self, uuid):
kwargs = self._add_tenant_uuid()
sip = self.service.get(uuid, **kwargs)
form = self.schema().load(request.get_json(), partial=True)
if form.get('templates'):
templates = []
for template in form['templates']:
try:
model = self.dao.get(template['uuid'],
template=True,
**kwargs)
templates.append(model)
except NotFoundError:
metadata = {'templates': template}
raise errors.param_not_found('templates', 'endpoint_sip',
**metadata)
form['templates'] = templates
if form.get('transport'):
transport_uuid = form['transport']['uuid']
try:
form['transport'] = self.transport_dao.get(transport_uuid)
except NotFoundError as e:
raise errors.param_not_found('transport', 'SIPTransport',
**e.metadata)
for name, value in form.items():
setattr(sip, name, value)
self.service.edit(sip)
return '', 204
def validate_destination(self, destination):
dest_type = destination.get('type')
if not dest_type:
raise errors.param_not_found('destination', 'type')
if dest_type not in self.builders:
raise errors.param_not_found('destination', 'type')
builder = self.builders[dest_type]
builder.validate(destination)
def validate(self, destination):
extensions = self.dao.find_all_service_extensions()
all_services = [e.service for e in extensions]
service = destination.service
if service not in all_services:
raise errors.param_not_found('service', service)
def validate(self, destination):
extensions = self.dao.find_all_forward_extensions()
all_forwards = [e.forward for e in extensions]
forward = destination.forward
if forward not in all_forwards:
raise errors.param_not_found('forward', forward)
def validate(self, destination):
extensions = self.dao.find_all_agent_action_extensions()
all_actions = [e.action for e in extensions]
action = destination.action
if action not in all_actions:
raise errors.param_not_found('action', action)
def get_voicemail_or_fail(self, tenant_uuids=None):
form = self.schema().load(request.get_json())
try:
return self.voicemail_dao.get(form['voicemail_id'],
tenant_uuids=tenant_uuids)
except NotFoundError:
raise errors.param_not_found('voicemail_id', 'Voicemail')
def validate(self, destination):
extensions = self.dao.find_all_transfer_extensions()
all_transfers = [e.transfer for e in extensions]
transfer = destination.transfer
if transfer not in all_transfers:
raise errors.param_not_found('transfer', transfer)
def validate(self, model):
value = getattr(model, self.field)
try:
self.dao_get(value)
except NotFoundError:
metadata = {self.field: value}
raise errors.param_not_found(self.field, self.resource, **metadata)
def validate(self, model):
value = getattr(model, self.field)
try:
self.dao_get(value)
except NotFoundError:
metadata = {self.field: value}
raise errors.param_not_found(self.field, self.resource, **metadata)
def find_or_create_destination(self, destination):
persistor = self.build_persistor(destination.type)
destination_row = persistor.find_or_create(destination)
if not destination_row:
raise errors.param_not_found('destination',
'func key representing destination',
type=destination.type)
return destination_row
def _check_template_id_exists(self, device):
if not device.template_id:
return
templates = self.device_dao.device_templates()
if device.template_id not in templates:
raise errors.param_not_found('template_id', 'DeviceTemplate')
def _check_plugin_exists(self, device):
if not device.plugin:
return
plugins = self.device_dao.plugins()
if device.plugin not in plugins:
raise errors.param_not_found('plugin', 'Plugin')
def _find_moh_uuid(self, form, field, tenant_uuids):
name = form.pop(field, None)
if name:
try:
moh = self._moh_dao.get_by(name=name,
tenant_uuids=tenant_uuids)
except NotFoundError:
raise errors.param_not_found(field, 'moh')
return moh.uuid
def find_or_create_destination(self, destination):
persistor = self.build_persistor(destination.type)
destination_row = persistor.find_or_create(destination)
if not destination_row:
raise errors.param_not_found('destination',
'func key representing destination',
type=destination.type)
return destination_row
def _validate(self, model, tenant_uuids=None):
value = getattr(model, self.field)
try:
if tenant_uuids is None:
self.dao_get(value)
else:
self.dao_get(value, tenant_uuids=tenant_uuids)
except NotFoundError:
metadata = {self.field: value}
raise errors.param_not_found(self.field, self.resource, **metadata)
def put(self, user_id):
user = self.get_user(user_id)
form = self.schema().load(request.get_json())
try:
lines = [self.line_dao.get(line['id']) for line in form['lines']]
except NotFoundError as e:
raise errors.param_not_found('lines', 'Line', **e.metadata)
self.service.associate_all_lines(user, lines)
return '', 204
def validate(self, model):
destination = QueueDestinationSchema().dump(model)
skill_rule_id = destination.get('skill_rule_id', None)
if not skill_rule_id:
return
try:
self.dao_get(skill_rule_id)
except NotFoundError:
metadata = {'skill_rule_id': skill_rule_id}
raise errors.param_not_found('skill_rule_id', 'SkillRule',
**metadata)
def validate_associate_agent_queue(queue_id, agent_id):
if not _queue_exists(queue_id):
raise errors.not_found('Queue', queue_id=queue_id)
if not _agent_exists(agent_id):
raise errors.param_not_found('agent_id', 'Agent')
try:
queue_members_dao.get_by_queue_id_and_agent_id(queue_id, agent_id)
raise errors.resource_associated('Agent', 'Queue',
agent_id, queue_id)
except NotFoundError:
pass
def validate(self, model):
destination = UserDestinationSchema().dump(model)
moh_uuid = destination.get('moh_uuid', None)
if not moh_uuid:
return
try:
self._dao_get(moh_uuid)
except NotFoundError:
metadata = {'moh_uuid': moh_uuid}
raise errors.param_not_found('moh_uuid', 'MOH', **metadata)
def validate_moh_exists_in_tenant(self, model):
moh_name = getattr(model, self.field)
if moh_name:
if moh_name == 'default':
return
try:
self.dao_get_by(name=moh_name,
tenant_uuids=[model.tenant_uuid])
except NotFoundError:
metadata = {self.field: moh_name}
raise errors.param_not_found(self.field, self.resource,
**metadata)
def put(self, context_id):
context = self.context_dao.get(context_id)
form = self.schema().load(request.get_json())
try:
contexts = [
self.context_dao.get(c['id']) for c in form['contexts']
]
except NotFoundError as e:
raise errors.param_not_found('contexts', 'Context', **e.metadata)
self.service.associate_contexts(context, contexts)
return '', 204
def put(self, user_id):
user = self.user_dao.get_by_id_uuid(user_id)
form = self.schema().load(request.get_json())
try:
groups = [
self.group_dao.get_by(id=group['id'])
for group in form['groups']
]
except NotFoundError as e:
raise errors.param_not_found('groups', 'Group', **e.metadata)
self.service.associate_all_groups(user, groups)
return '', 204
def put(self, paging_id):
tenant_uuids = self._build_tenant_list({'recurse': True})
paging = self.paging_dao.get(paging_id, tenant_uuids=tenant_uuids)
form = self.schema().load(request.get_json())
try:
users = [
self.user_dao.get_by(uuid=user['uuid'], tenant_uuids=tenant_uuids)
for user in form['users']
]
except NotFoundError as e:
raise errors.param_not_found('users', 'User', **e.metadata)
self.service.associate_all_member_users(paging, users)
return '', 204
def put(self, outcall_id):
tenant_uuids = self._build_tenant_list({'recurse': True})
outcall = self.outcall_dao.get(outcall_id, tenant_uuids=tenant_uuids)
form = self.schema().load(request.get_json())
try:
trunks = [
self.trunk_dao.get(trunk['id'], tenant_uuids=tenant_uuids)
for trunk in form['trunks']
]
except NotFoundError as e:
raise errors.param_not_found('trunks', 'Trunk', **e.metadata)
self.service.associate_all_trunks(outcall, trunks)
return '', 204
def validate_moh_exists_in_tenant(self, application):
if not application.dest_node:
return
if not application.dest_node.type_ == 'holding':
return
moh_name = application.dest_node.music_on_hold
if moh_name:
if moh_name == 'default':
return
try:
self.dao_get_by(name=moh_name,
tenant_uuids=[application.tenant_uuid])
except NotFoundError:
metadata = {'music_on_hold': moh_name}
raise errors.param_not_found('music_on_hold', 'MOH',
**metadata)
def put(self, call_pickup_id):
tenant_uuids = self._build_tenant_list({'recurse': True})
call_pickup = self.call_pickup_dao.get(call_pickup_id,
tenant_uuids=tenant_uuids)
form = self.schema().load(request.get_json())
try:
targets = [
self.group_dao.get_by(id=group['id'],
tenant_uuids=tenant_uuids)
for group in form['groups']
]
except NotFoundError as e:
raise errors.param_not_found('groups', 'Group', **e.metadata)
self.service.associate_target_groups(call_pickup, targets)
return '', 204
def put(self, call_pickup_id):
tenant_uuids = self._build_tenant_list({'recurse': True})
call_pickup = self.call_pickup_dao.get(call_pickup_id,
tenant_uuids=tenant_uuids)
form = self.schema().load(request.get_json())
try:
interceptors = [
self.user_dao.get_by(uuid=user['uuid'],
tenant_uuids=tenant_uuids)
for user in form['users']
]
except NotFoundError as e:
raise errors.param_not_found('users', 'User', **e.metadata)
self.service.associate_interceptor_users(call_pickup, interceptors)
return '', 204
def put(self, group_uuid):
tenant_uuids = self._build_tenant_list({'recurse': True})
group = self.group_dao.get(group_uuid, tenant_uuids=tenant_uuids)
form = self.schema().load(request.get_json())
members = []
try:
for member_form in form['users']:
user = self.user_dao.get_by(uuid=member_form['user']['uuid'],
tenant_uuids=tenant_uuids)
member = self._find_or_create_member(group, user)
member.priority = member_form['priority']
members.append(member)
except NotFoundError as e:
raise errors.param_not_found('users', 'User', **e.metadata)
self.service.associate_all_users(group, members)
return '', 204
def put(self, call_filter_id):
tenant_uuids = self._build_tenant_list({'recurse': True})
call_filter = self.call_filter_dao.get(call_filter_id,
tenant_uuids=tenant_uuids)
form = self.schema().load(request.get_json())
try:
surrogates = []
for user_form in form['users']:
user = self.user_dao.get_by(uuid=user_form['user']['uuid'],
tenant_uuids=tenant_uuids)
surrogate = self.service.find_surrogate_by_user(
call_filter, user)
if not surrogate:
surrogate = CallFilterMember()
surrogate.user = user
surrogates.append(surrogate)
except NotFoundError as e:
raise errors.param_not_found('users', 'User', **e.metadata)
self.service.associate_surrogates(call_filter, surrogates)
return '', 204
def put(self, call_filter_id):
tenant_uuids = self._build_tenant_list({'recurse': True})
call_filter = self.call_filter_dao.get(call_filter_id,
tenant_uuids=tenant_uuids)
form = self.schema().load(request.get_json())
try:
recipients = []
for user_form in form['users']:
user = self.user_dao.get_by(uuid=user_form['user']['uuid'],
tenant_uuids=tenant_uuids)
recipient = self.service.find_recipient_by_user(
call_filter, user)
if not recipient:
recipient = CallFilterMember()
recipient.user = user
recipient.timeout = user_form['timeout']
recipients.append(recipient)
except NotFoundError as e:
raise errors.param_not_found('users', 'User', **e.metadata)
self.service.associate_recipients(call_filter, recipients)
return '', 204
def _validate_user_id(user_line):
try:
return user_dao.get(user_line.user_id)
except NotFoundError:
raise errors.param_not_found('user_id', 'User')
def get_agent(self, agent_id, tenant_uuids=None):
agent = self.agent_dao.find(agent_id, tenant_uuids=tenant_uuids)
if not agent:
raise errors.param_not_found('agent_id', 'Agent')
return agent
def validate(self, model):
value = getattr(model, self.field)
items = self.dao_list()
if value not in items:
metadata = {self.field: value}
raise errors.param_not_found(self.field, self.resource, **metadata)
def _check_invalid_context(line):
try:
context_dao.get(line.context)
except NotFoundError:
raise errors.param_not_found('context', 'Context', name=line.context)
def validate_context_exists(extension):
existing_context = context_dao.find(extension.context)
if not existing_context:
raise errors.param_not_found('context', 'Context')
def validate(self, model):
value = getattr(model, self.field)
exists = self.dao_exist(value)
if not exists:
metadata = {self.field: value}
raise errors.param_not_found(self.field, self.resource, **metadata)
def _validate_user_exists(user_cti_profile):
try:
user_dao.get(user_cti_profile.user_id)
except NotFoundError:
raise errors.param_not_found('user_id', 'User')
def get_voicemail_or_fail(self):
form = parser.parse_args()
try:
return self.voicemail_dao.get(form['voicemail_id'])
except NotFoundError:
raise errors.param_not_found('voicemail_id', 'Voicemail')
def validate(self, model):
value = getattr(model, self.field)
found = self.dao_find(value)
if found is None:
metadata = {self.field: value}
raise errors.param_not_found(self.field, self.resource, **metadata)
def validate_extension(line_extension):
try:
extension_dao.get(line_extension.extension_id)
except NotFoundError:
raise errors.param_not_found('extension_id', 'Extension')
def _validate_line_id(user_line):
try:
return line_dao.get(user_line.line_id)
except NotFoundError:
raise errors.param_not_found('line_id', 'Line')
def validate(self, model):
value = getattr(model, self.field)
items = self.dao_list()
if value not in items:
metadata = {self.field: value}
raise errors.param_not_found(self.field, self.resource, **metadata)
def validate(self, model):
value = getattr(model, self.field)
found = self.dao_find(value)
if found is None:
metadata = {self.field: value}
raise errors.param_not_found(self.field, self.resource, **metadata)
def _validate_cti_profile_exists(user_cti_profile):
try:
cti_profile_dao.get(user_cti_profile.cti_profile_id)
except NotFoundError:
raise errors.param_not_found('cti_profile_id', 'CtiProfile')
def validate(self, model):
value = getattr(model, self.field)
exists = self.dao_exist(value)
if not exists:
metadata = {self.field: value}
raise errors.param_not_found(self.field, self.resource, **metadata)
def get_extension_or_fail(self):
form = self.schema().load(request.get_json())
try:
return self.extension_dao.get(form['extension_id'])
except NotFoundError:
raise errors.param_not_found('extension_id', 'Extension')
def _find_user_uuid(self):
user_uuid = request.user_uuid
if not user_uuid:
raise errors.param_not_found('user_uuid', 'meetings')
return user_uuid
def get_line_or_fail(self):
form = parser.parse_args()
try:
return self.line_dao.get(form['line_id'])
except NotFoundError:
raise errors.param_not_found('line_id', 'Line')
def validate_line(line_extension):
try:
line_dao.get(line_extension.line_id)
except NotFoundError:
raise errors.param_not_found('line_id', 'Line')
