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, 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_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)