def test_identificador_cliente_interaccion_externa_tipo1_envia_datos_correctos_creacion_astdb(
self):
campana_entrante_1 = CampanaFactory(type=Campana.TYPE_ENTRANTE)
campana_entrante_2 = CampanaFactory(type=Campana.TYPE_ENTRANTE)
ident_cliente = IdentificadorClienteFactory(
tipo_interaccion=IdentificadorCliente.INTERACCION_EXTERNA_1)
dest_entrante_1 = DestinoEntrante.crear_nodo_ruta_entrante(campana_entrante_1)
dest_entrante_2 = DestinoEntrante.crear_nodo_ruta_entrante(campana_entrante_2)
dest_entrante_ident_client = DestinoEntrante.crear_nodo_ruta_entrante(ident_cliente)
OpcionDestino.crear_opcion_destino(
dest_entrante_ident_client, dest_entrante_1, IdentificadorCliente.DESTINO_MATCH)
OpcionDestino.crear_opcion_destino(
dest_entrante_ident_client, dest_entrante_2, IdentificadorCliente.DESTINO_NO_MATCH)
sync_ident_cliente = SincronizadorDeConfiguracionIdentificadorClienteAsterisk()
gen_family = sync_ident_cliente._obtener_generador_family()
dict_astdb = gen_family._create_dict(ident_cliente)
self.assertEqual(dict_astdb['NAME'], ident_cliente.nombre)
self.assertEqual(dict_astdb['TYPE'], ident_cliente.tipo_interaccion)
self.assertEqual(dict_astdb['EXTERNALURL'], ident_cliente.url)
audio_path = convert_audio_asterisk_path_astdb(ident_cliente.audio.audio_asterisk)
self.assertEqual(dict_astdb['AUDIO'], audio_path)
self.assertEqual(dict_astdb['LENGTH'], ident_cliente.longitud_id_esperado)
self.assertEqual(dict_astdb['TIMEOUT'], ident_cliente.timeout)
self.assertEqual(dict_astdb['RETRIES'], ident_cliente.intentos)
self.assertEqual(dict_astdb['TRUEDST'], "{0},{1}".format(
dest_entrante_1.tipo, dest_entrante_1.object_id))
self.assertEqual(dict_astdb['FALSEDST'], "{0},{1}".format(
dest_entrante_2.tipo, dest_entrante_2.object_id))
def setUp(self, *args, **kwargs):
super(TestsRutasEntrantes, self).setUp(*args, **kwargs)
self.admin = self.crear_administrador()
self.admin.set_password(self.PWD)
# Creo un Supervisor Normal
self.usr_sup = self.crear_user_supervisor()
self.crear_supervisor_profile(self.usr_sup)
# Creo un Supervisor Customer
self.usr_customer = self.crear_user_supervisor()
self.crear_supervisor_profile(self.usr_customer, is_customer=True)
self.campana_entrante = CampanaFactory(type=Campana.TYPE_ENTRANTE)
self.destino_campana_entrante = DestinoEntrante.crear_nodo_ruta_entrante(
self.campana_entrante)
self.ivr = IVRFactory()
self.destino_ivr = DestinoEntrante.crear_nodo_ruta_entrante(self.ivr)
self.opc_dest_ivr_time_out = OpcionDestinoFactory(
valor=IVR.VALOR_TIME_OUT,
destino_anterior=self.destino_ivr,
destino_siguiente=self.destino_campana_entrante)
self.opc_dest_ivr_invalid = OpcionDestinoFactory(
valor=IVR.VALOR_DESTINO_INVALIDO,
destino_anterior=self.destino_ivr,
destino_siguiente=self.destino_ivr)
self.opc_dest_ivr_camp_entrante_1 = OpcionDestinoFactory(
valor='1',
destino_anterior=self.destino_ivr,
destino_siguiente=self.destino_campana_entrante)
self.opc_dest_ivr_ivr_2 = OpcionDestinoFactory(
valor='2',
destino_anterior=self.destino_ivr,
destino_siguiente=self.destino_ivr)
self.validacion_tiempo = ValidacionTiempoFactory()
self.grupo_horario = self.validacion_tiempo.grupo_horario
self.validacion_fecha_hora = ValidacionFechaHoraFactory(
grupo_horario=self.grupo_horario)
self.destino_val_fecha_hora = DestinoEntrante.crear_nodo_ruta_entrante(
self.validacion_fecha_hora)
self.opc_dest_val_fecha_hora_true = OpcionDestinoFactory(
valor=ValidacionFechaHora.DESTINO_MATCH,
destino_anterior=self.destino_val_fecha_hora,
destino_siguiente=self.destino_campana_entrante)
self.opc_dest_val_fecha_hora_false = OpcionDestinoFactory(
valor=ValidacionFechaHora.DESTINO_NO_MATCH,
destino_anterior=self.destino_val_fecha_hora,
destino_siguiente=self.destino_ivr)
self.archivo_audio = ArchivoDeAudioFactory()
self.ruta_entrante = RutaEntranteFactory(
destino=self.destino_campana_entrante)
def test_elimina_ivr_ok(self, mock_sincronizacion):
# Creo un IVR que no es destino
destinos_iniciales = DestinoEntrante.objects.count()
ivr = IVRFactory()
DestinoEntrante.crear_nodo_ruta_entrante(ivr)
self.client.login(username=self.admin.username, password=self.PWD)
url = reverse('eliminar_ivr', args=[ivr.id])
response = self.client.post(url, follow=True)
self.assertEqual(response.status_code, 200)
self.assertContains(response, IVRDeleteView.nodo_eliminado)
self.assertEqual(IVR.objects.count(), 0)
self.assertEqual(DestinoEntrante.objects.count(), destinos_iniciales)
def done(self, form_list, **kwargs):
queue = self._save_forms(form_list, Campana.ESTADO_ACTIVA)
self._insert_queue_asterisk(queue)
# salvamos los supervisores y agentes asignados a la campaña
self.save_supervisores(form_list, -2)
self.save_agentes(form_list, -1)
# creamos un nodo destino de ruta entrante para ser que a la campaña se le pueda
# configurar un acceso en alguna ruta entrante
DestinoEntrante.crear_nodo_ruta_entrante(queue.campana)
# se insertan los datos de la campaña en asterisk
campana = queue.campana
self.alertas_por_sistema_externo(campana)
return HttpResponseRedirect(reverse('campana_list'))
def test_creacion_sincronizador_destino_personalizado_envia_datos_correctos_asterisk(self):
campana_entrante_1 = CampanaFactory(type=Campana.TYPE_ENTRANTE)
dest_entrante_1 = DestinoEntrante.crear_nodo_ruta_entrante(campana_entrante_1)
dest_personalizado = DestinoPersonalizadoFactory()
nodo_dest_personalizado = DestinoEntrante.crear_nodo_ruta_entrante(dest_personalizado)
OpcionDestino.crear_opcion_destino(
nodo_dest_personalizado, dest_entrante_1, 'failover')
sync_dest_personalizado = SincronizadorDeConfiguracionDestinoPersonalizadoAsterisk()
gen_family = sync_dest_personalizado._obtener_generador_family()
dict_astdb = gen_family._create_dict(dest_personalizado)
self.assertEqual(dict_astdb['NAME'], dest_personalizado.nombre)
self.assertEqual(dict_astdb['DST'], dest_personalizado.custom_destination)
self.assertEqual(dict_astdb['FAILOVER'], "{0},{1}".format(
dest_entrante_1.tipo, dest_entrante_1.object_id))
def crear_destino_entrante(info_nodo_entrante):
# crea nodo de modelo DestinoEntrante a partir de modelo recibido
dest = DestinoEntrante.crear_nodo_ruta_entrante(info_nodo_entrante,
commit=False)
dest.nombre += timezone.now().strftime("%H:%M:%S")
dest.save()
return dest
def test_generar_dialplan_entrante_ivr_breakout(self):
ivr = IVRFactory()
destino_ivr = DestinoEntrante.crear_nodo_ruta_entrante(ivr)
self.queue_entrante.ivr_breakdown = destino_ivr
creator = QueuesCreator()
dialplan = creator._generar_dialplan_entrantes(self.campana_entrante)
self.assertIn('context=sub-oml-module-ivrbreakout', dialplan)
def _create_dict(self, family_member):
nodo = DestinoEntrante.get_nodo_ruta_entrante(family_member)
externalurl = family_member.url if family_member.url is not None else ''
longitud_id_esperado = ''
if family_member.longitud_id_esperado is not None:
longitud_id_esperado = family_member.longitud_id_esperado
dict_identificador_cliente = {
'NAME':
family_member.nombre,
'TYPE':
family_member.tipo_interaccion,
'EXTERNALURL':
externalurl,
'AUDIO':
convert_audio_asterisk_path_astdb(
family_member.audio.audio_asterisk),
'LENGTH':
longitud_id_esperado,
'TIMEOUT':
family_member.timeout,
'RETRIES':
family_member.intentos,
}
for opcion in nodo.destinos_siguientes.all():
dst = "{0},{1}".format(opcion.destino_siguiente.tipo,
opcion.destino_siguiente.object_id)
if opcion.valor == IdentificadorCliente.DESTINO_MATCH:
dict_identificador_cliente.update({'TRUEDST': dst})
elif opcion.valor == IdentificadorCliente.DESTINO_NO_MATCH:
dict_identificador_cliente.update({'FALSEDST': dst})
return dict_identificador_cliente
def _crear_ruta_entrante(self, campana_entrante):
destino_campana_entrante = DestinoEntrante.crear_nodo_ruta_entrante(
campana_entrante)
ruta_entrante = RutaEntranteFactory(telefono='01177660011',
destino=destino_campana_entrante,
prefijo_caller_id='')
escribir_ruta_entrante_config(self, ruta_entrante)
def test_identificador_cliente_interaccion_externa_tipo2_envia_datos_correctos_creacion_astdb(
self):
ident_cliente = IdentificadorClienteFactory(
tipo_interaccion=IdentificadorCliente.INTERACCION_EXTERNA_2)
DestinoEntrante.crear_nodo_ruta_entrante(ident_cliente)
sync_ident_cliente = SincronizadorDeConfiguracionIdentificadorClienteAsterisk()
gen_family = sync_ident_cliente._obtener_generador_family()
dict_astdb = gen_family._create_dict(ident_cliente)
self.assertEqual(dict_astdb['NAME'], ident_cliente.nombre)
self.assertEqual(dict_astdb['TYPE'], ident_cliente.tipo_interaccion)
self.assertEqual(dict_astdb['EXTERNALURL'], ident_cliente.url)
audio_path = convert_audio_asterisk_path_astdb(ident_cliente.audio.audio_asterisk)
self.assertEqual(dict_astdb['AUDIO'], audio_path)
self.assertEqual(dict_astdb['LENGTH'], ident_cliente.longitud_id_esperado)
self.assertEqual(dict_astdb['TIMEOUT'], ident_cliente.timeout)
self.assertFalse(dict_astdb.get('TRUEDST', False))
self.assertFalse(dict_astdb.get('FALSEDST', False))
def __init__(self, *args, **kwargs):
super(OpcionDestinoValidacionFechaHoraForm, self).__init__(*args, **kwargs)
instance = getattr(self, 'instance', None)
if instance.pk is not None:
tipo_destino = instance.destino_siguiente.tipo
self.initial['tipo_destino'] = tipo_destino
destinos_qs = DestinoEntrante.get_destinos_por_tipo(tipo_destino)
destino_entrante_choices = [EMPTY_CHOICE] + [(dest_entr.id, dest_entr.__unicode__())
for dest_entr in destinos_qs]
self.fields['destino_siguiente'].choices = destino_entrante_choices
def test_no_elimina_validacion_fecha_hora_destino_de_otro_nodo(self, mock_sincronizacion):
# Creo un Validacion Fecha Hora y lo pongo como destino de un IVR
ivr = IVRFactory()
nodo_ivr = DestinoEntrante.crear_nodo_ruta_entrante(ivr)
validacion_fh = ValidacionFechaHoraFactory()
nodo_validacion = DestinoEntrante.crear_nodo_ruta_entrante(validacion_fh)
OpcionDestinoFactory(valor='False',
destino_anterior=nodo_ivr,
destino_siguiente=nodo_validacion)
destinos_iniciales = DestinoEntrante.objects.count()
self.client.login(username=self.admin.username, password=self.PWD)
url = reverse('eliminar_validacion_fecha_hora', args=[validacion_fh.id])
response = self.client.post(url, follow=True)
self.assertEqual(response.status_code, 200)
self.assertFalse(mock_sincronizacion.called)
list_url = reverse('lista_validaciones_fecha_hora', args=(1,))
self.assertRedirects(response, list_url)
self.assertContains(response, ValidacionFechaHoraDeleteView.imposible_eliminar)
self.assertEqual(ValidacionFechaHora.objects.count(), 1)
self.assertEqual(DestinoEntrante.objects.count(), destinos_iniciales)
def _create_dict(self, family_member):
nodo = DestinoEntrante.get_nodo_ruta_entrante(family_member)
dict_destino_personalizado = {
'NAME': family_member.nombre,
'DST': family_member.custom_destination,
}
# sólo tendría un destino siguiente (FAILOVER)
opcion_destino_failover = nodo.destinos_siguientes.first()
dst = "{0},{1}".format(
opcion_destino_failover.destino_siguiente.tipo,
opcion_destino_failover.destino_siguiente.object_id)
dict_destino_personalizado.update({'FAILOVER': dst})
return dict_destino_personalizado
def setUp(self):
super(RedisDatabaseTest, self).setUp()
audio_1 = ArchivoDeAudioFactory(audio_asterisk='oml/audio_1')
audio_2 = ArchivoDeAudioFactory(audio_asterisk='oml/audio_2')
audio_3 = ArchivoDeAudioFactory(audio_asterisk='oml/audio_3')
self.ivr = IVRFactory(nombre='IVR 1',
time_out=10,
time_out_retries=5,
invalid_retries=1,
audio_principal=audio_1,
time_out_audio=audio_2,
invalid_audio=audio_3)
self.nodo_ivr = DestinoEntrante.crear_nodo_ruta_entrante(self.ivr)
self.grupo_horario = GrupoHorarioFactory()
self.validacion_tiempo = ValidacionTiempoFactory(
grupo_horario=self.grupo_horario)
self.tc = ValidacionFechaHoraFactory()
self.nodo_tc = DestinoEntrante.crear_nodo_ruta_entrante(self.tc)
self.id_cliente = IdentificadorClienteFactory(audio=audio_1)
self.nodo_id_cliente = DestinoEntrante.crear_nodo_ruta_entrante(
self.id_cliente)
self.pausa = PausaFactory()
self.inr = RutaEntranteFactory(destino=self.nodo_ivr)
self.trunk = TroncalSIPFactory()
self.destino_personalizado = DestinoPersonalizadoFactory()
self.nodo_destino_personalizado = DestinoEntrante.crear_nodo_ruta_entrante(
self.destino_personalizado)
self.campana_entrante = CampanaFactory(type=Campana.TYPE_ENTRANTE)
QueueFactory(campana=self.campana_entrante)
self.campana_dialer = CampanaFactory(type=Campana.TYPE_DIALER)
QueueFactory(campana=self.campana_dialer)
self.campana_preview = CampanaFactory(type=Campana.TYPE_PREVIEW)
QueueFactory(campana=self.campana_preview)
self.campana_manual = CampanaFactory(type=Campana.TYPE_MANUAL)
QueueFactory(campana=self.campana_manual)
def test_no_elimina_ivr_utilizado_en_ruta_entrante(self, mock_sincronizacion):
# Creo un IVR y lo pongo como destino de una Ruta Entrante
destinos_iniciales = DestinoEntrante.objects.count()
ivr = IVRFactory()
nodo_ivr = DestinoEntrante.crear_nodo_ruta_entrante(ivr)
RutaEntranteFactory(destino=nodo_ivr)
self.client.login(username=self.admin.username, password=self.PWD)
url = reverse('eliminar_ivr', args=[ivr.id])
response = self.client.post(url, follow=True)
self.assertEqual(response.status_code, 200)
list_url = reverse('lista_ivrs', args=(1,))
self.assertRedirects(response, list_url)
self.assertContains(response, IVRDeleteView.imposible_eliminar)
self.assertEqual(IVR.objects.count(), 1)
self.assertEqual(DestinoEntrante.objects.count(), destinos_iniciales + 1)
def __init__(self, *args, **kwargs):
super(RutaEntranteForm, self).__init__(*args, **kwargs)
tipo_destino_choices = [EMPTY_CHOICE]
tipo_destino_choices.extend(DestinoEntrante.TIPOS_DESTINOS)
self.fields['tipo_destino'].choices = tipo_destino_choices
instance = getattr(self, 'instance', None)
if instance.pk is not None:
tipo = instance.destino.tipo
self.initial['tipo_destino'] = tipo
destinos_qs = DestinoEntrante.get_destinos_por_tipo(tipo)
destino_entrante_choices = [EMPTY_CHOICE] + [(dest_entr.id, dest_entr.__unicode__())
for dest_entr in destinos_qs]
self.fields['destino'].choices = destino_entrante_choices
else:
self.fields['destino'].choices = ()
def _create_dict(self, family_member):
nodo = DestinoEntrante.get_nodo_ruta_entrante(family_member)
dict_tc = {
'NAME': family_member.nombre,
'TGID': family_member.grupo_horario.id,
}
for opcion in nodo.destinos_siguientes.all():
dst = "{0},{1}".format(opcion.destino_siguiente.tipo,
opcion.destino_siguiente.object_id)
if opcion.valor == ValidacionFechaHora.DESTINO_MATCH:
dict_tc.update({'TRUEDST': dst})
elif opcion.valor == ValidacionFechaHora.DESTINO_NO_MATCH:
dict_tc.update({'FALSEDST': dst})
return dict_tc
def test_no_elimina_campana_destino_de_otro_nodo(self, mock_sincronizacion):
# Pongo la campaña entrante 1 como destino de un IVR
ivr = IVRFactory()
nodo_ivr = DestinoEntrante.crear_nodo_ruta_entrante(ivr)
OpcionDestinoFactory(valor='False',
destino_anterior=nodo_ivr,
destino_siguiente=self.nodo_camp_1)
destinos_iniciales = DestinoEntrante.objects.count()
campanas_iniciales = Campana.objects.filter(estado=Campana.ESTADO_ACTIVA).count()
self.client.login(username=self.admin.username, password=self.PWD)
url = reverse('campana_elimina', args=[self.camp_1.id])
response = self.client.post(url, follow=True)
self.assertEqual(response.status_code, 200)
list_url = reverse('campana_list')
self.assertRedirects(response, list_url)
self.assertContains(response, CampanaDeleteView.imposible_eliminar)
self.assertEqual(Campana.objects.filter(estado=Campana.ESTADO_ACTIVA).count(),
campanas_iniciales)
self.assertEqual(DestinoEntrante.objects.count(), destinos_iniciales)
def test_elimina_validacion_fecha_hora_ok(self, mock_sincronizacion):
# Creo una Validacion Fecha Hora que no es destino
destinos_iniciales = DestinoEntrante.objects.count()
validacion_fh = ValidacionFechaHoraFactory()
nodo_validacion = DestinoEntrante.crear_nodo_ruta_entrante(validacion_fh)
OpcionDestinoFactory(valor='True',
destino_anterior=nodo_validacion,
destino_siguiente=self.nodo_camp_1)
OpcionDestinoFactory(valor='False',
destino_anterior=nodo_validacion,
destino_siguiente=self.nodo_camp_2)
self.client.login(username=self.admin.username, password=self.PWD)
url = reverse('eliminar_validacion_fecha_hora', args=[validacion_fh.id])
response = self.client.post(url, follow=True)
mock_sincronizacion.assert_called_with(validacion_fh)
self.assertEqual(response.status_code, 200)
self.assertContains(response, ValidacionFechaHoraDeleteView.nodo_eliminado)
self.assertEqual(ValidacionFechaHora.objects.count(), 0)
self.assertEqual(DestinoEntrante.objects.count(), destinos_iniciales)
self.assertEqual(OpcionDestino.objects.count(), 0)
def _inicializar_ivr_a_modificar(self, *args, **kwargs):
valores_fijos_ivr = (IVR.VALOR_TIME_OUT, IVR.VALOR_DESTINO_INVALIDO)
valor_opcion_field = {
IVR.VALOR_TIME_OUT: 'time_out_destination',
IVR.VALOR_DESTINO_INVALIDO: 'invalid_destination'
}
ivr = self.instance
nodo_ivr = DestinoEntrante.objects.get(
object_id=ivr.pk, content_type=ContentType.objects.get_for_model(ivr))
opciones_destino_fijas_ivr = nodo_ivr.destinos_siguientes.filter(
valor__in=valores_fijos_ivr)
for opcion_destino in opciones_destino_fijas_ivr:
destino = opcion_destino.destino_siguiente
destino_valor = opcion_destino.valor
destino_field = valor_opcion_field[destino_valor]
destino_field_tipo = valor_opcion_field[destino_valor] + '_type'
self.initial[destino_field] = destino.pk
self.initial[destino_field_tipo] = destino.tipo
destinos_qs = DestinoEntrante.get_destinos_por_tipo(destino.tipo)
destinos_choices = [EMPTY_CHOICE] + [(dest_entr.id, dest_entr.__unicode__())
for dest_entr in destinos_qs]
self.fields[destino_field].choices = destinos_choices
def test_no_elimina_validacion_fecha_hora_utilizado_en_ruta_entrante(self, mock_sincronizacion):
# Creo una validacion fecha hora y la pongo como destino de una Ruta Entrante
destinos_iniciales = DestinoEntrante.objects.count()
validacion_fh = ValidacionFechaHoraFactory()
nodo_validacion = DestinoEntrante.crear_nodo_ruta_entrante(validacion_fh)
OpcionDestinoFactory(valor='True',
destino_anterior=nodo_validacion,
destino_siguiente=self.nodo_camp_1)
OpcionDestinoFactory(valor='False',
destino_anterior=nodo_validacion,
destino_siguiente=self.nodo_camp_2)
RutaEntranteFactory(destino=nodo_validacion)
self.client.login(username=self.admin.username, password=self.PWD)
url = reverse('eliminar_validacion_fecha_hora', args=[validacion_fh.id])
response = self.client.post(url, follow=True)
self.assertEqual(response.status_code, 200)
list_url = reverse('lista_validaciones_fecha_hora', args=(1,))
self.assertFalse(mock_sincronizacion.called)
mock_sincronizacion.assert_not_called()
self.assertRedirects(response, list_url)
self.assertContains(response, ValidacionFechaHoraDeleteView.imposible_eliminar)
self.assertEqual(ValidacionFechaHora.objects.count(), 1)
self.assertEqual(DestinoEntrante.objects.count(), destinos_iniciales + 1)
def crear_destinos_desde_campanas_entrantes():
for campana in Campana.objects.obtener_campanas_entrantes():
DestinoEntrante.crear_nodo_ruta_entrante(campana)
def _obtener_destinos_siguientes(self, ivr):
return DestinoEntrante.get_nodo_ruta_entrante(
ivr).destinos_siguientes.all()
def _crear_campanas_entrantes(self):
self.camp_1 = CampanaFactory(type=Campana.TYPE_ENTRANTE, estado=Campana.ESTADO_ACTIVA)
self.camp_2 = CampanaFactory(type=Campana.TYPE_ENTRANTE, estado=Campana.ESTADO_ACTIVA)
self.nodo_camp_1 = DestinoEntrante.crear_nodo_ruta_entrante(self.camp_1)
self.nodo_camp_2 = DestinoEntrante.crear_nodo_ruta_entrante(self.camp_2)
