def validate(self, extension):
existing = self.dao.find_by(exten=extension.exten,
context=extension.context)
if existing and existing.id != extension.id:
raise errors.resource_exists('Extension',
exten=extension.exten,
context=extension.context)
def validate(self, external_app):
tenant_uuid = external_app.tenant_uuid
name = external_app.name
found = self.dao.find_by(tenant_uuid=tenant_uuid, name=name)
if found is not None:
metadata = {'tenant_uuid': tenant_uuid, 'name': name}
raise errors.resource_exists('ExternalApp', **metadata)
def validate(self, external_app):
user_uuid = external_app.user_uuid
name = external_app.name
found = self.dao.find_by(user_uuid=user_uuid, name=name)
if found is not None:
metadata = {'user_uuid': user_uuid, 'name': name}
raise errors.resource_exists('UserExternalApp', **metadata)
def validate(self, model):
value = getattr(model, self.field)
query = {self.field: value}
found = self.dao.find_by(**query)
if found is not None and found.id != model.id:
metadata = {self.field: value}
raise errors.resource_exists(self.resource, **metadata)
def validate(self, model):
voicemail = self.dao.find_by(number=model.number,
context=model.context)
if voicemail and voicemail.id != model.id:
raise errors.resource_exists('Voicemail',
number=voicemail.number,
context=voicemail.context)
def _check_mac_already_exists(self, device):
if not device.mac:
return
existing_device = self.device_dao.find_by('mac', device.mac.lower())
if existing_device:
raise errors.resource_exists('Device', mac=device.mac)
def validate(self, extension):
existing = self.dao.find_by(exten=extension.exten, context=extension.context)
if existing:
raise errors.resource_exists(
'Extension', exten=extension.exten, context=extension.context
)
self._validate_parking_lots(extension)
def validate(self, template):
counter = Counter(funckey.hash_destination()
for funckey in template.keys.values())
if len(counter) > 0:
destination, counts = counter.most_common(1)[0]
if counts > 1:
args = dict(destination)
raise errors.resource_exists('destination', **args)
def validate(self, template):
counter = Counter(funckey.hash_destination()
for funckey in template.keys.values())
if len(counter) > 0:
destination, counts = counter.most_common(1)[0]
if counts > 1:
args = dict(destination)
raise errors.resource_exists('destination', **args)
def validate(self, ingress_http):
existing = self.dao.find_by(tenant_uuid=ingress_http.tenant_uuid)
if existing:
raise errors.resource_exists(
'IngressHTTP',
tenant_uuid=str(ingress_http.tenant_uuid),
)
def _validate(self, model, tenant_uuids=None):
value = getattr(model, self.field)
if tenant_uuids is None:
found = self.dao_find(value)
else:
found = self.dao_find(value, tenant_uuids=tenant_uuids)
if found is not None:
metadata = {self.field: value}
raise errors.resource_exists(self.resource, **metadata)
def _validate(self, model, tenant_uuids=None):
value = getattr(model, self.field)
query = {self.field: value}
if tenant_uuids is None:
found = self.dao.find_by(**query)
else:
found = self.dao.find_by(tenant_uuids=tenant_uuids, **query)
if found is not None and found.id != model.id:
metadata = {self.field: value}
raise errors.resource_exists(self.resource, **metadata)
def create_directory(self, sound):
path = self._build_path('tenants', sound.tenant_uuid, sound.name)
with umask_disabled():
try:
os.makedirs(path, 0o775)
except OSError as e:
if e.errno == errno.EEXIST:
raise errors.resource_exists(sound, name=sound.name)
else:
logger.error('Could not create sound directory %s: %s',
path, e)
def validate_slots_do_not_conflict_with_extension_context(
self, parking_lot, extension):
extensions = extension_dao.find_all_by(context=extension.context)
for extension in extensions:
if extension.is_pattern():
continue
if parking_lot.in_slots_range(extension.exten):
raise errors.resource_exists(
'Extension',
id=extension.id,
exten=extension.exten,
context=extension.context,
)
def _validate(self, model, tenant_uuids=None):
value = getattr(model, self.field)
query = {self.field: value}
if tenant_uuids is not None:
query['tenant_uuids'] = tenant_uuids
found = self.dao_find(**query)
if not found:
return
if getattr(found, self.id_field) != getattr(model, self.id_field):
metadata = {self.field: value}
raise errors.resource_exists(self.resource, **metadata)
def validate(self, parking_lot):
if not parking_lot.extensions:
return
extensions = extension_dao.find_all_by(
context=parking_lot.extensions[0].context)
for extension in extensions:
if extension.is_pattern():
continue
if parking_lot.in_slots_range(extension.exten):
raise errors.resource_exists(
'Extension',
id=extension.id,
exten=extension.exten,
context=extension.context,
)
def _validate_parking_lots(self, extension):
if extension.is_pattern():
return
parking_lots = self.parking_lot_dao.find_all_by()
for parking_lot in parking_lots:
if (
parking_lot.extensions
and parking_lot.extensions[0].context == extension.context
):
if parking_lot.in_slots_range(extension.exten):
raise errors.resource_exists(
'ParkingLot',
id=parking_lot.id,
slots_start=parking_lot.slots_start,
slots_end=parking_lot.slots_end,
)
def validate_unique_name_through_group(self, queue):
group = group_dao.find_by(name=queue.name)
if group is not None:
raise errors.resource_exists('Group', name=group.name)
def validate(self, line):
existing = self.dao.find_by(provisioningid=line.provisioningid)
if existing:
raise errors.resource_exists(
'Line', provisioning_code=line.provisioning_code)
def validate(self, model):
existing = self.find(model)
if existing:
raise errors.resource_exists('Voicemail',
number=existing.number,
context=existing.context)
def validate(self, model):
value = getattr(model, self.field)
found = self.dao_find(value)
if found is not None:
metadata = {self.field: value}
raise errors.resource_exists(self.resource, **metadata)
def validate_unique_name_through_queue(self, group):
queue = queue_dao.find_by(name=group.name)
if queue is not None:
raise errors.resource_exists('Queue', name=group.name)
def validate(self, model):
existing = self.find(model)
if existing:
raise errors.resource_exists('Voicemail',
number=existing.number,
context=existing.context)
def validate_extension_available(extension):
existing_extension = extension_dao.find_by_exten_context(extension.exten, extension.context)
if existing_extension:
raise errors.resource_exists('Extension',
exten=extension.exten, context=extension.context)
