def setUp(self):
super(CalificacionTests, self).setUp()
self.agente_profile = self.crear_agente_profile()
self.usuario_agente = self.agente_profile.user
self.campana = CampanaFactory.create()
self.nombre_opcion_gestion = NombreCalificacionFactory.create()
self.nombre_calificacion_agenda = NombreCalificacion.objects.get(
nombre=settings.CALIFICACION_REAGENDA)
self.formulario = FormularioFactory()
self.campo_formulario = FieldFormularioFactory(formulario=self.formulario)
self.opcion_calificacion_gestion = OpcionCalificacionFactory.create(
campana=self.campana, nombre=self.nombre_opcion_gestion.nombre,
tipo=OpcionCalificacion.GESTION, formulario=self.formulario)
self.opcion_calificacion_agenda = OpcionCalificacionFactory.create(
campana=self.campana, nombre=self.nombre_calificacion_agenda.nombre,
tipo=OpcionCalificacion.AGENDA)
self.opcion_calificacion_camp_manual = OpcionCalificacionFactory.create(
campana=self.campana, nombre=self.nombre_opcion_gestion.nombre)
self.opcion_calificacion_no_accion = OpcionCalificacionFactory.create(
campana=self.campana, tipo=OpcionCalificacion.NO_ACCION)
self.contacto = ContactoFactory.create()
self.campana.bd_contacto.contactos.add(self.contacto)
self.queue = QueueFactory.create(campana=self.campana)
self.calificacion_cliente = CalificacionClienteFactory(
opcion_calificacion=self.opcion_calificacion_camp_manual, agente=self.agente_profile,
contacto=self.contacto)
QueueMemberFactory.create(member=self.agente_profile, queue_name=self.queue)
self.client.login(username=self.usuario_agente.username, password=PASSWORD)
def setUp(self):
super(AuditoriaDeGestionTests, self).setUp()
self.supervisor = self.crear_supervisor_profile()
self.client.login(username=self.supervisor.user.username,
password=PASSWORD)
self.campana = CampanaFactory.create(estado=Campana.ESTADO_ACTIVA)
self.campana.supervisors.add(self.supervisor.user)
self.opcion_calificacion_gestion = OpcionCalificacionFactory.create(
campana=self.campana, tipo=OpcionCalificacion.GESTION)
self.opcion_calificacion_no_gestion = OpcionCalificacionFactory.create(
campana=self.campana, tipo=OpcionCalificacion.NO_ACCION)
self.contacto_gestion = ContactoFactory.create()
self.campana.bd_contacto.contactos.add(self.contacto_gestion)
self.contacto_no_gestion = ContactoFactory.create()
self.campana.bd_contacto.contactos.add(self.contacto_no_gestion)
self.agente = self.crear_agente_profile()
self.calificacion_gestion = CalificacionClienteFactory(
opcion_calificacion=self.opcion_calificacion_gestion,
agente=self.agente,
contacto=self.contacto_gestion)
self.calificacion_no_gestion = CalificacionClienteFactory(
opcion_calificacion=self.opcion_calificacion_no_gestion,
agente=self.agente,
contacto=self.contacto_no_gestion)
def setUp(self):
super(ReglaIncidenciaPorCalificacionTests, self).setUp()
self.admin = self.crear_administrador()
self.client.login(username=self.admin.username, password=PASSWORD)
self.formulario = FormularioFactory()
self.campo_formulario = FieldFormularioFactory(
formulario=self.formulario)
self.campana = CampanaFactory.create(type=Campana.TYPE_DIALER)
self.nombre_opcion_1 = NombreCalificacionFactory.create()
self.opcion_calificacion_1 = OpcionCalificacionFactory.create(
campana=self.campana,
nombre=self.nombre_opcion_1.nombre,
tipo=OpcionCalificacion.GESTION,
formulario=self.formulario)
self.campana.opciones_calificacion.add(self.opcion_calificacion_1)
self.nombre_opcion_2 = NombreCalificacionFactory.create()
self.opcion_calificacion_2 = OpcionCalificacionFactory.create(
campana=self.campana,
nombre=self.nombre_opcion_2.nombre,
tipo=OpcionCalificacion.NO_ACCION)
self.campana.opciones_calificacion.add(self.opcion_calificacion_2)
self.contacto = ContactoFactory.create()
self.campana.bd_contacto.contactos.add(self.contacto)
self.campana_extra = CampanaFactory.create(type=Campana.TYPE_DIALER)
self.nombre_opcion_extra = NombreCalificacionFactory.create()
self.opcion_calificacion_extra = OpcionCalificacionFactory.create(
campana=self.campana_extra,
nombre=self.nombre_opcion_extra.nombre,
tipo=OpcionCalificacion.NO_ACCION)
self.campana_extra.opciones_calificacion.add(
self.opcion_calificacion_extra)
def setUp(self):
self.usuario_admin_supervisor = UserFactory(is_staff=True, is_supervisor=True)
self.usuario_admin_supervisor.set_password(self.PWD)
self.usuario_admin_supervisor.save()
self.agente_profile = AgenteProfileFactory.create(user=self.usuario_admin_supervisor)
self.nombre_calificacion = NombreCalificacionFactory.create(nombre=self.CALIFICACION_NOMBRE)
self.nombre_calificacion_gestion = NombreCalificacionFactory.create(nombre=self.GESTION)
self.campana_activa = CampanaFactory.create(
estado=Campana.ESTADO_ACTIVA, type=Campana.TYPE_PREVIEW)
self.contacto_calificado_gestion = ContactoFactory(
bd_contacto=self.campana_activa.bd_contacto)
self.contacto_calificado_no_accion = ContactoFactory(
bd_contacto=self.campana_activa.bd_contacto)
self.contacto_no_atendido = ContactoFactory(bd_contacto=self.campana_activa.bd_contacto)
self.contacto_no_calificado = ContactoFactory(bd_contacto=self.campana_activa.bd_contacto)
self.opcion_calificacion_gestion = OpcionCalificacionFactory.create(
campana=self.campana_activa, nombre=self.nombre_calificacion_gestion.nombre,
tipo=OpcionCalificacion.GESTION)
self.opcion_calificacion_noaccion = OpcionCalificacionFactory.create(
campana=self.campana_activa, nombre=self.nombre_calificacion.nombre,
tipo=OpcionCalificacion.NO_ACCION)
self.telefono1 = self.contacto_calificado_gestion.telefono
self.telefono2 = self.contacto_calificado_no_accion.telefono
self.telefono3 = self.contacto_no_atendido.telefono
self.telefono4 = self.contacto_no_calificado.telefono
self.generador_log_llamadas = GeneradorDeLlamadaLogs()
self.generador_log_llamadas.generar_log(
self.campana_activa, False, 'COMPLETEAGENT', self.telefono1, agente=self.agente_profile,
contacto=self.contacto_calificado_gestion, duracion_llamada=self.DURACION_LLAMADA,
callid=1)
self.generador_log_llamadas.generar_log(
self.campana_activa, False, 'COMPLETEAGENT', self.telefono2, agente=self.agente_profile,
contacto=self.contacto_calificado_no_accion, duracion_llamada=self.DURACION_LLAMADA,
callid=2)
self.generador_log_llamadas.generar_log(
self.campana_activa, True, 'NOANSWER', self.telefono3, agente=self.agente_profile,
contacto=self.contacto_no_atendido, callid=3)
self.generador_log_llamadas.generar_log(
self.campana_activa, True, 'COMPLETEOUTNUM', self.telefono4, agente=self.agente_profile,
contacto=self.contacto_no_calificado, duracion_llamada=0, callid=4)
callid_gestion = LlamadaLog.objects.get(
contacto_id=self.contacto_calificado_gestion.pk, event='COMPLETEAGENT').callid
callid_no_accion = LlamadaLog.objects.get(
contacto_id=self.contacto_calificado_no_accion.pk, event='COMPLETEAGENT').callid
self.calif_gestion = CalificacionClienteFactory.create(
opcion_calificacion=self.opcion_calificacion_gestion, agente=self.agente_profile,
contacto=self.contacto_calificado_gestion, callid=callid_gestion)
self.calif_no_accion = CalificacionClienteFactory.create(
opcion_calificacion=self.opcion_calificacion_noaccion, agente=self.agente_profile,
contacto=self.contacto_calificado_no_accion, callid=callid_no_accion)
CalificacionCliente.history.all().update(history_change_reason='calificacion')
self.client.login(username=self.usuario_admin_supervisor.username, password=self.PWD)
def _crear_opciones_calificacion(self, campana):
# opciones de calificacion
OpcionCalificacionFactory(nombre=self.success.nombre,
campana=campana,
tipo=OpcionCalificacion.GESTION)
OpcionCalificacionFactory(nombre=self.angry.nombre,
campana=campana,
tipo=OpcionCalificacion.NO_ACCION)
def setUp(self):
super(AuditoriasCalificacionesTests, self).setUp()
self.campana1 = CampanaFactory(estado=Campana.ESTADO_ACTIVA)
self.campana2 = CampanaFactory(estado=Campana.ESTADO_ACTIVA)
self.campana3 = CampanaFactory(estado=Campana.ESTADO_ACTIVA)
self.supervisor1 = self.crear_supervisor_profile(rol=User.GERENTE)
self.supervisor2 = self.crear_supervisor_profile(rol=User.GERENTE)
self.supervisor3 = self.crear_supervisor_profile(rol=User.SUPERVISOR)
self.supervisor4 = self.crear_supervisor_profile(rol=User.REFERENTE)
# calificaciones y auditorias de gestion para campana1
opcion_calificacion11 = OpcionCalificacionFactory(
campana=self.campana1, tipo=OpcionCalificacion.GESTION)
self.calificacion11 = CalificacionClienteFactory(
opcion_calificacion=opcion_calificacion11)
# calificacion de gestion para campana2
opcion_calificacion21_gestion = OpcionCalificacionFactory(
campana=self.campana2, tipo=OpcionCalificacion.GESTION)
opcion_calificacion21_no_accion = OpcionCalificacionFactory(
campana=self.campana2, tipo=OpcionCalificacion.NO_ACCION)
self.calificacion21 = CalificacionClienteFactory(
opcion_calificacion=opcion_calificacion21_no_accion)
self.calificacion22 = CalificacionClienteFactory(
opcion_calificacion=opcion_calificacion21_gestion)
self.calificacion23 = CalificacionClienteFactory(
opcion_calificacion=opcion_calificacion21_gestion)
self.calificacion24 = CalificacionClienteFactory(
opcion_calificacion=opcion_calificacion21_gestion)
self.calificacion25 = CalificacionClienteFactory(
opcion_calificacion=opcion_calificacion21_gestion)
self.queue_campana_2 = QueueFactory(campana=self.campana2)
QueueMemberFactory(member=self.calificacion25.agente,
queue_name=self.queue_campana_2)
self.auditoria_aprobada = AuditoriaCalificacionFactory(
calificacion=self.calificacion23,
resultado=AuditoriaCalificacion.APROBADA)
self.auditoria_rechazada = AuditoriaCalificacionFactory(
calificacion=self.calificacion24,
resultado=AuditoriaCalificacion.RECHAZADA)
self.auditoria_rechazada = AuditoriaCalificacionFactory(
calificacion=self.calificacion25,
resultado=AuditoriaCalificacion.OBSERVADA)
self.campana2.supervisors.add(self.supervisor2.user)
self.campana3.supervisors.add(self.supervisor2.user)
# calificacion de gestion para campana2
opcion_calificacion31_gestion = OpcionCalificacionFactory(
campana=self.campana3, tipo=OpcionCalificacion.GESTION)
self.calificacion31 = CalificacionClienteFactory(
opcion_calificacion=opcion_calificacion31_gestion)
self.client.login(username=self.supervisor2.user,
password=self.DEFAULT_PASSWORD)
def setUp(self):
self.usuario_admin_supervisor = UserFactory(is_staff=True,
is_supervisor=True)
self.usuario_admin_supervisor.set_password(self.PWD)
self.usuario_admin_supervisor.save()
self.user_agente = self.crear_user_agente()
self.campana = CampanaFactory()
self.agente_profile = self.crear_agente_profile(self.user_agente)
self.opcion_calificacion = OpcionCalificacionFactory(
campana=self.campana, tipo=OpcionCalificacion.GESTION)
self.calificacion = CalificacionClienteFactory(
opcion_calificacion=self.opcion_calificacion)
self.grabacion1 = GrabacionFactory.create(
duracion=0,
agente=self.agente_profile,
callid=self.calificacion.callid,
campana=self.campana)
self.grabacion2 = GrabacionFactory(duracion=0,
agente=self.agente_profile,
campana=self.campana)
self.grabacion3 = GrabacionFactory(duracion=0,
agente=self.agente_profile,
campana=self.campana)
self.marca_campana1 = GrabacionMarcaFactory(
callid=self.grabacion1.callid)
self.marca_campana2 = GrabacionMarcaFactory(
callid=self.grabacion2.callid)
self.client.login(username=self.usuario_admin_supervisor.username,
password=self.PWD)
def test_calificacion_cliente_creacion_redirecciona_a_otro_formulario_gestion(
self, post):
nuevo_formulario = FormularioFactory()
campo_formulario = FieldFormularioFactory(formulario=nuevo_formulario,
nombre_campo='otro_campo')
nombre_opcion = NombreCalificacionFactory.create(nombre='otra opcion')
opcion_calificacion = OpcionCalificacionFactory.create(
campana=self.campana,
nombre=nombre_opcion,
tipo=OpcionCalificacion.GESTION,
formulario=nuevo_formulario)
url = reverse('calificacion_formulario_update_or_create',
kwargs={
'pk_campana': self.campana.pk,
'pk_contacto': self.contacto.pk
})
post_data = self._obtener_post_data_calificacion_cliente()
post_data['opcion_calificacion'] = opcion_calificacion.pk
response = self.client.post(url, post_data, follow=True)
self.assertTemplateUsed(
response, 'formulario/respuesta_formulario_gestion_agente.html')
self.assertTrue(campo_formulario.nombre_campo in
response.context_data['form'].fields)
self.assertFalse(self.campo_formulario.nombre_campo in
response.context_data['form'].fields)
def test_api_opciones_calificacion_ocultando_opcion_calificacion(self):
opcion_calificacion_2 = OpcionCalificacionFactory(
campana=self.campana_activa)
self.opcion_calificacion.oculta = True
self.opcion_calificacion.save()
token_agente = Token.objects.get(user=self.agente_profile.user).key
client = APIClient()
client.credentials(HTTP_AUTHORIZATION='Bearer ' + token_agente)
url = reverse('api_campana_opciones_calificacion_intern-list',
args=(self.campana_activa.pk, ))
response = client.get(url)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.json()), 2)
opcion_data_1 = response.json()[0]
opcion_data_2 = response.json()[1]
if response.json()[1]['id'] == self.opcion_calificacion.id:
opcion_data_1 = response.json()[1]
opcion_data_2 = response.json()[0]
self.assertEqual(opcion_data_1['id'], self.opcion_calificacion.id)
self.assertEqual(opcion_data_2['id'], opcion_calificacion_2.id)
self.assertEqual(opcion_data_1['name'],
self.opcion_calificacion.nombre)
self.assertEqual(opcion_data_2['name'], opcion_calificacion_2.nombre)
self.assertTrue(opcion_data_1['hidden'])
self.assertFalse(opcion_data_2['hidden'])
def setUp(self):
super(APITest, self).setUp()
self.factory = RequestFactory()
self.supervisor_admin = self.crear_supervisor_profile(
rol=User.ADMINISTRADOR)
self.supervisor = self.crear_supervisor_profile(rol=User.SUPERVISOR)
self.agente_profile = self.crear_agente_profile()
self.campana_activa = CampanaFactory.create(
estado=Campana.ESTADO_ACTIVA)
self.campana_activa_supervisor = CampanaFactory.create(
estado=Campana.ESTADO_ACTIVA)
self.campana_activa_supervisor.supervisors.add(self.supervisor.user)
self.campana_finalizada = CampanaFactory(
estado=Campana.ESTADO_FINALIZADA)
self.queue = QueueFactory.create(campana=self.campana_activa)
self.queue2 = QueueFactory.create(
campana=self.campana_activa_supervisor)
self.queue3 = QueueFactory.create(campana=self.campana_finalizada)
QueueMemberFactory.create(member=self.agente_profile,
queue_name=self.queue)
self.sistema_externo = SistemaExternoFactory()
self.opcion_calificacion = OpcionCalificacionFactory(
campana=self.campana_activa)
self.calificacion_cliente = CalificacionClienteFactory(
opcion_calificacion=self.opcion_calificacion,
agente=self.agente_profile)
for user in User.objects.all():
Token.objects.create(user=user)
def setUp(self):
super(APITest, self).setUp()
self.factory = RequestFactory()
self.supervisor_admin = self.crear_supervisor_profile(
rol=User.ADMINISTRADOR)
self.supervisor = self.crear_supervisor_profile(rol=User.SUPERVISOR)
self.agente_profile = self.crear_agente_profile()
self.campana_activa = CampanaFactory.create(
estado=Campana.ESTADO_ACTIVA,
type=Campana.TYPE_MANUAL,
nombre='activa uno')
self.campana_activa_2 = CampanaFactory.create(
estado=Campana.ESTADO_ACTIVA,
type=Campana.TYPE_PREVIEW,
nombre='activa dos')
self.campana_activa_supervisor = CampanaFactory.create(
estado=Campana.ESTADO_ACTIVA,
type=Campana.TYPE_ENTRANTE,
nombre='activa supervisor uno')
self.campana_activa_supervisor.supervisors.add(self.supervisor.user)
self.campana_finalizada = CampanaFactory(
estado=Campana.ESTADO_FINALIZADA)
self.queue = QueueFactory.create(campana=self.campana_activa)
self.queue1 = QueueFactory.create(campana=self.campana_activa_2)
self.queue2 = QueueFactory.create(
campana=self.campana_activa_supervisor)
self.queue3 = QueueFactory.create(campana=self.campana_finalizada)
QueueMemberFactory.create(member=self.agente_profile,
queue_name=self.queue)
self.sistema_externo = SistemaExternoFactory()
self.opcion_calificacion = OpcionCalificacionFactory(
campana=self.campana_activa)
self.contacto = ContactoFactory(
bd_contacto=self.campana_activa.bd_contacto)
self.calificacion_cliente = CalificacionClienteFactory(
opcion_calificacion=self.opcion_calificacion,
agente=self.agente_profile,
contacto=self.contacto)
for user in User.objects.all():
Token.objects.create(user=user)
def setUp(self):
self.supervisor1 = self.crear_supervisor_profile(rol=User.SUPERVISOR)
self.supervisor2 = self.crear_supervisor_profile(rol=User.SUPERVISOR)
self.agente1 = self.crear_agente_profile()
self.agente2 = self.crear_agente_profile()
self.campana1 = CampanaFactory(estado=Campana.ESTADO_ACTIVA)
self.queue_campana_1 = QueueFactory(campana=self.campana1)
QueueMemberFactory(member=self.agente1,
queue_name=self.queue_campana_1)
self.campana1.supervisors.add(self.supervisor1.user)
self.campana2 = CampanaFactory(estado=Campana.ESTADO_ACTIVA)
self.queue_campana_2 = QueueFactory(campana=self.campana2)
QueueMemberFactory(member=self.agente2,
queue_name=self.queue_campana_2)
self.campana2.supervisors.add(self.supervisor2.user)
self.contacto = ContactoFactory(id_externo='id_ext')
self.campana3 = CampanaFactory(estado=Campana.ESTADO_ACTIVA)
self.campana3.bd_contacto.genera_contactos([self.contacto])
self.campana3.supervisors.add(self.supervisor1.user)
self.opcion_calificacion = OpcionCalificacionFactory(
campana=self.campana1, tipo=OpcionCalificacion.GESTION)
self.calificacion = CalificacionClienteFactory(
opcion_calificacion=self.opcion_calificacion)
update_change_reason(self.calificacion, 'calificacion')
self.grabacion1 = GrabacionFactory.create(
duracion=1,
agente=self.agente1,
callid=self.calificacion.callid,
campana=self.campana1,
id_cliente='-1')
self.grabacion2 = GrabacionFactory(duracion=1,
agente=self.agente1,
campana=self.campana1)
self.grabacion3 = GrabacionFactory(duracion=1,
agente=self.agente1,
campana=self.campana1)
self.marca_campana1 = GrabacionMarcaFactory(
callid=self.grabacion1.callid)
self.marca_campana2 = GrabacionMarcaFactory(
callid=self.grabacion2.callid)
self.grabacion2_1 = GrabacionFactory.create(duracion=1,
agente=self.agente2,
campana=self.campana2)
self.marca_campana2_1 = GrabacionMarcaFactory(
callid=self.grabacion2_1.callid)
self.grabacion3_1 = GrabacionFactory.create(
tel_cliente=self.contacto.telefono,
agente=self.agente2,
campana=self.campana3)
def test_calificaciones_agenda_se_adicionan_a_llamadas_pendientes(self):
campana_manual = CampanaFactory(type=Campana.TYPE_MANUAL, estado=Campana.ESTADO_ACTIVA)
opcion_calificacion_agenda = OpcionCalificacionFactory(
nombre=settings.CALIFICACION_REAGENDA, campana=campana_manual,
tipo=OpcionCalificacion.AGENDA)
CalificacionClienteFactory(
opcion_calificacion=opcion_calificacion_agenda, agente=self.agente_profile)
estadisticas_service = EstadisticasService()
llamadas_pendientes, _, _, _, _ = estadisticas_service.obtener_total_llamadas(
campana_manual)
self.assertEqual(llamadas_pendientes, 1)
def setUp(self):
super(ReporteDeLLamadasSalientesDeSupervisionTest, self).setUp()
self.generador = GeneradorDeLlamadaLogs()
self.supervisor = SupervisorProfileFactory()
self.agente1 = AgenteProfileFactory()
self.manual = CampanaFactory.create(type=Campana.TYPE_MANUAL,
nombre='camp-manual-1',
estado=Campana.ESTADO_ACTIVA,
supervisors=[self.supervisor.user])
self.opcion_calificacion_m1 = OpcionCalificacionFactory(
campana=self.manual, tipo=OpcionCalificacion.GESTION)
self.preview = CampanaFactory.create(
type=Campana.TYPE_PREVIEW,
nombre='camp-preview-1',
estado=Campana.ESTADO_ACTIVA,
supervisors=[self.supervisor.user])
self.opcion_calificacion_p1 = OpcionCalificacionFactory(
campana=self.preview, tipo=OpcionCalificacion.GESTION)
# Campañas que no deben estar en los reportes por no ser del supervisor
self.manual2 = CampanaFactory.create(type=Campana.TYPE_MANUAL,
nombre='camp-manual-2',
estado=Campana.ESTADO_ACTIVA)
self.preview2 = CampanaFactory.create(type=Campana.TYPE_PREVIEW,
nombre='camp-preview-2',
estado=Campana.ESTADO_ACTIVA)
# Campañas que no deben estar en los reportes por no ser MANUAL o PREVIEW
self.dialer = CampanaFactory.create(type=Campana.TYPE_DIALER,
nombre='camp-dialer-1',
estado=Campana.ESTADO_ACTIVA,
supervisors=[self.supervisor.user])
self.opcion_calificacion_d1 = OpcionCalificacionFactory(
campana=self.dialer, tipo=OpcionCalificacion.GESTION)
self.dialer2 = CampanaFactory.create(type=Campana.TYPE_DIALER,
nombre='camp-dialer-2',
estado=Campana.ESTADO_ACTIVA)
def setUp(self):
super(LimitarAgendasPersonalesTests, self).setUp()
self.grupo1 = GrupoFactory(nombre='grupo1', limitar_agendas_personales=True,
cantidad_agendas_personales=1)
self.grupo2 = GrupoFactory(nombre='grupo2', limitar_agendas_personales=True,
cantidad_agendas_personales=0)
self.grupo3 = GrupoFactory(nombre='grupo3', limitar_agendas_personales=False,
cantidad_agendas_personales=0)
self.agente_1 = self.crear_agente_profile()
self.agente_1.grupo = self.grupo1
self.agente_1.save()
self.agente_2 = self.crear_agente_profile()
self.agente_2.grupo = self.grupo2
self.agente_2.save()
self.agente_3 = self.crear_agente_profile()
self.agente_3.grupo = self.grupo3
self.agente_3.save()
self.contacto = ContactoFactory.create()
self.campana_preview = CampanaFactory.create(estado=Campana.ESTADO_ACTIVA,
type=Campana.TYPE_PREVIEW)
self.campana_dialer = CampanaFactory.create(estado=Campana.ESTADO_ACTIVA,
type=Campana.TYPE_DIALER)
self.nombre_calificacion_agenda = NombreCalificacion.objects.get(
nombre=settings.CALIFICACION_REAGENDA)
self.opcion_calificacion_agenda_campana_preview = OpcionCalificacionFactory.create(
campana=self.campana_preview, nombre=self.nombre_calificacion_agenda.nombre,
tipo=OpcionCalificacion.AGENDA)
self.opcion_calificacion_agenda_campana_dialer = OpcionCalificacionFactory.create(
campana=self.campana_dialer, nombre=self.nombre_calificacion_agenda.nombre,
tipo=OpcionCalificacion.AGENDA)
def setUp(self):
super(CalificacionTests, self).setUp()
self.agente_1 = self.crear_agente_profile()
self.agente_2 = self.crear_agente_profile()
self.agente_3 = self.crear_agente_profile()
self.supervisor = self.crear_supervisor_profile()
self.campana = CampanaFactory.create(estado=Campana.ESTADO_ACTIVA,
type=Campana.TYPE_MANUAL)
self.campana.supervisors.add(self.supervisor.user)
self.nombre_calificacion_agenda = NombreCalificacion.objects.get(
nombre=settings.CALIFICACION_REAGENDA)
self.opcion_calificacion_agenda = OpcionCalificacionFactory.create(
campana=self.campana,
nombre=self.nombre_calificacion_agenda.nombre,
tipo=OpcionCalificacion.AGENDA)
self.contacto_1 = ContactoFactory.create()
self.campana.bd_contacto.contactos.add(self.contacto_1)
self.contacto_2 = ContactoFactory.create()
self.campana.bd_contacto.contactos.add(self.contacto_2)
self.calificacion_1 = CalificacionClienteFactory(
opcion_calificacion=self.opcion_calificacion_agenda,
agente=self.agente_1,
contacto=self.contacto_1)
self.agenda_1 = AgendaContactoFactory(
agente=self.agente_1,
contacto=self.contacto_1,
campana=self.campana,
tipo_agenda=AgendaContacto.TYPE_PERSONAL)
self.calificacion_2 = CalificacionClienteFactory(
opcion_calificacion=self.opcion_calificacion_agenda,
agente=self.agente_2,
contacto=self.contacto_2)
self.agenda_2 = AgendaContactoFactory(
agente=self.agente_2,
contacto=self.contacto_2,
campana=self.campana,
tipo_agenda=AgendaContacto.TYPE_PERSONAL)
self.queue = QueueFactory.create(campana=self.campana)
QueueMemberFactory.create(member=self.agente_1, queue_name=self.queue)
QueueMemberFactory.create(member=self.agente_2, queue_name=self.queue)
self.client.login(username=self.supervisor.user.username,
password=PASSWORD)
def setUp(self):
super(ReporteDeLLamadasEntrantesDeSupervisionTest, self).setUp()
self.generador = GeneradorDeLlamadaLogs()
self.agente1 = self.crear_agente_profile()
self.agente2 = self.crear_agente_profile()
self.entrante1 = CampanaFactory.create(type=Campana.TYPE_ENTRANTE, nombre='camp-entrante-1',
estado=Campana.ESTADO_ACTIVA)
self.opcion_calificacion = OpcionCalificacionFactory(campana=self.entrante1,
tipo=OpcionCalificacion.GESTION)
# Campaña que no debe estar en los reportes por no ser del supervisor
self.entrante2 = CampanaFactory.create(type=Campana.TYPE_ENTRANTE, nombre='camp-entrante-2',
estado=Campana.ESTADO_ACTIVA)
self.queue = QueueFactory.create(campana=self.entrante1)
def test_calificaciones_agenda_se_adicionan_a_llamadas_pendientes(self):
campana_manual = CampanaFactory(type=Campana.TYPE_MANUAL, estado=Campana.ESTADO_ACTIVA)
opcion_calificacion_agenda = OpcionCalificacionFactory(
nombre=settings.CALIFICACION_REAGENDA, campana=campana_manual,
tipo=OpcionCalificacion.AGENDA)
log = LlamadaLogFactory(campana_id=campana_manual.pk)
CalificacionClienteFactory(
callid=log.callid,
opcion_calificacion=opcion_calificacion_agenda, agente=self.agente_profile)
hoy_ahora = fecha_hora_local(timezone.now())
fecha_desde = datetime_hora_minima_dia_utc(hoy_ahora)
fecha_hasta = datetime_hora_maxima_dia_utc(hoy_ahora)
estadisticas_service = EstadisticasService(campana_manual, fecha_desde, fecha_hasta)
estadisticas_service.calcular_estadisticas_totales()
self.assertEqual(estadisticas_service.reporte_totales_llamadas.llamadas_pendientes, 1)
def test_api_modificar_calificacion_NO_permite_modificarla_a_opcion_calificacion_oculta(
self):
token_agente = Token.objects.get(user=self.agente_profile.user).key
client = APIClient()
client.credentials(HTTP_AUTHORIZATION='Bearer ' + token_agente)
opcion_oculta = OpcionCalificacionFactory(campana=self.campana_activa,
oculta=True)
post_data = {
'idContact': self.calificacion_cliente.contacto.pk,
'idDispositionOption': opcion_oculta.pk,
'comments': self.calificacion_cliente.observaciones
}
url = reverse('api_disposition-detail',
args=(self.calificacion_cliente.pk, ))
response = client.put(url, post_data)
self.assertEqual(response.status_code, 400)
expected_result = {
'status': 'ERROR',
'idDispositionOption': 'Disposition option id not found'
}
self.assertEqual(response.json(), expected_result)
def setUp(self):
super(ReporteDeLLamadasEntrantesDeSupervisionTest, self).setUp()
self.generador = GeneradorDeLlamadaLogs()
self.supervisor = SupervisorProfileFactory()
self.supervisor.user.set_password(self.PWD)
self.supervisor.user.save()
self.agente1 = AgenteProfileFactory()
self.entrante1 = CampanaFactory.create(
type=Campana.TYPE_ENTRANTE,
nombre='camp-entrante-1',
estado=Campana.ESTADO_ACTIVA,
supervisors=[self.supervisor.user])
self.opcion_calificacion = OpcionCalificacionFactory(
campana=self.entrante1, tipo=OpcionCalificacion.GESTION)
# Campaña que no debe estar en los reportes por no ser del supervisor
self.entrante2 = CampanaFactory.create(type=Campana.TYPE_ENTRANTE,
nombre='camp-entrante-2',
estado=Campana.ESTADO_ACTIVA)
def test_no_permite_auditar_en_campanas_no_asignadas(self):
campana_no_asignada = CampanaFactory.create(
estado=Campana.ESTADO_ACTIVA)
nombre_opcion_no_asignada = NombreCalificacionFactory.create()
opcion_calificacion_no_asignada = OpcionCalificacionFactory.create(
campana=campana_no_asignada,
nombre=nombre_opcion_no_asignada.nombre)
contacto_no_asignada = ContactoFactory.create()
campana_no_asignada.bd_contacto.contactos.add(contacto_no_asignada)
calificacion_no_asignada = CalificacionClienteFactory(
opcion_calificacion=opcion_calificacion_no_asignada,
agente=self.agente,
contacto=contacto_no_asignada)
url = reverse('auditar_calificacion_cliente',
args=(calificacion_no_asignada.id, ))
response = self.client.get(url, follow=True)
self.assertEqual(response.status_code, 200)
self.assertRedirects(response,
reverse('buscar_auditorias_gestion', args=(1, )))
self.assertContains(
response,
_("No tiene permiso para auditar calificaciones de esta campaña."))
def setUp(self):
self.factory = RequestFactory()
self.supervisor_admin = SupervisorProfileFactory(is_administrador=True)
self.supervisor_admin.user.set_password(self.PWD)
self.supervisor_admin.user.save()
self.supervisor = SupervisorProfileFactory(is_administrador=False)
self.supervisor.user.set_password(self.PWD)
self.supervisor.user.save()
self.agente_profile = AgenteProfileFactory()
self.agente_profile.user.set_password(self.PWD)
self.agente_profile.user.is_agente = True
self.agente_profile.user.save()
self.campana_activa = CampanaFactory.create(
estado=Campana.ESTADO_ACTIVA)
self.campana_activa_supervisor = CampanaFactory.create(
estado=Campana.ESTADO_ACTIVA)
self.campana_activa_supervisor.supervisors.add(self.supervisor.user)
self.campana_finalizada = CampanaFactory(
estado=Campana.ESTADO_FINALIZADA)
self.queue = QueueFactory.create(campana=self.campana_activa)
QueueMemberFactory.create(member=self.agente_profile,
queue_name=self.queue)
self.sistema_externo = SistemaExternoFactory()
self.opcion_calificacion = OpcionCalificacionFactory(
campana=self.campana_activa)
self.calificacion_cliente = CalificacionClienteFactory(
opcion_calificacion=self.opcion_calificacion,
agente=self.agente_profile)
for user in User.objects.all():
Token.objects.create(user=user)
def setUp(self):
self.supervisor1 = self.crear_supervisor_profile(rol=User.SUPERVISOR)
self.supervisor2 = self.crear_supervisor_profile(rol=User.SUPERVISOR)
self.agente1 = self.crear_agente_profile()
self.agente2 = self.crear_agente_profile()
self.campana1 = CampanaFactory(estado=Campana.ESTADO_ACTIVA)
self.queue_campana_1 = QueueFactory(campana=self.campana1)
QueueMemberFactory(member=self.agente1,
queue_name=self.queue_campana_1)
self.campana1.supervisors.add(self.supervisor1.user)
self.campana2 = CampanaFactory(estado=Campana.ESTADO_ACTIVA)
self.queue_campana_2 = QueueFactory(campana=self.campana2)
QueueMemberFactory(member=self.agente2,
queue_name=self.queue_campana_2)
self.campana2.supervisors.add(self.supervisor2.user)
self.contacto = ContactoFactory(id_externo='id_ext')
self.campana3 = CampanaFactory(estado=Campana.ESTADO_ACTIVA)
self.campana3.bd_contacto.genera_contactos([self.contacto])
self.campana3.supervisors.add(self.supervisor1.user)
self.opcion_calificacion = OpcionCalificacionFactory(
campana=self.campana1, tipo=OpcionCalificacion.GESTION)
self.calificacion = CalificacionClienteFactory(
opcion_calificacion=self.opcion_calificacion)
update_change_reason(self.calificacion, 'calificacion')
self.llamada_log1 = LlamadaLogFactory.create(
duracion_llamada=1,
agente_id=self.agente1.id,
callid=self.calificacion.callid,
campana_id=self.campana1.id,
contacto_id='-1',
event='COMPLETEAGENT')
self.llamada_log2 = LlamadaLogFactory.create(
duracion_llamada=1,
agente_id=self.agente1.id,
campana_id=self.campana1.id,
event='COMPLETEAGENT')
self.llamada_log3 = LlamadaLogFactory.create(
duracion_llamada=1,
agente_id=self.agente1.id,
campana_id=self.campana1.id,
event='COMPLETEAGENT')
self.marca_campana1 = GrabacionMarcaFactory(
callid=self.llamada_log1.callid)
self.marca_campana2 = GrabacionMarcaFactory(
callid=self.llamada_log2.callid)
self.llamada_log2_1 = LlamadaLogFactory.create(
duracion_llamada=1,
agente_id=self.agente2.id,
campana_id=self.campana2.id,
event='COMPLETEAGENT')
self.marca_campana2_1 = GrabacionMarcaFactory(
callid=self.llamada_log2_1.callid)
self.llamada_log3_1 = LlamadaLogFactory.create(
numero_marcado=self.contacto.telefono,
agente_id=self.agente2.id,
campana_id=self.campana3.id,
event='COMPLETEAGENT')
(_, hace_mucho, ahora) = self._obtener_fechas()
self.rango_hace_mucho = hace_mucho.date().strftime('%d/%m/%Y') + ' - ' + \
ahora.date().strftime('%d/%m/%Y')
def _crear_datos_entorno(self):
admin = User.objects.filter(is_staff=True).first()
# crear grupo
grupo = GrupoFactory()
# crear modulo
modulo = ModuloFactory()
# crear agente
agente = AgenteProfileFactory(grupo=grupo, reported_by=admin)
agente.modulos.add(modulo)
agente.user.username = self.agent_username
agente.user.set_password(self.agent_password)
agente.sip_extension = 1000 + agente.id
agente.user.is_agente = True
agente.user.save()
agente.save()
asterisk_sip_service = ActivacionAgenteService()
asterisk_sip_service.activar()
# crear audio
ArchivoDeAudioFactory()
# crear pausa
PausaFactory()
# crear formulario (2 campos)
form = FormularioFactory()
FieldFormularioFactory.create_batch(2, formulario=form)
# crear califs.(1 gestion y 1 normal)
success = NombreCalificacionFactory(nombre='Success')
angry = NombreCalificacionFactory(nombre='Hangs up angry')
# crear BD (3 contactos)
bd_contacto = BaseDatosContactoFactory()
ContactoFactory.create_batch(3, bd_contacto=bd_contacto)
# crear campaña manual
campana_manual = CampanaFactory(
nombre='test_manual_campaign', bd_contacto=bd_contacto, type=Campana.TYPE_MANUAL,
reported_by=admin, es_manual=True, estado=Campana.ESTADO_ACTIVA
)
# crear Queue para la campaña
Queue.objects.create(
campana=campana_manual,
name=campana_manual.nombre,
maxlen=5,
wrapuptime=5,
servicelevel=30,
strategy='rrmemory',
eventmemberstatus=True,
eventwhencalled=True,
ringinuse=True,
setinterfacevar=True,
weight=0,
wait=120
)
# opciones de calificacion
OpcionCalificacionFactory(
nombre=success.nombre, campana=campana_manual, tipo=OpcionCalificacion.GESTION)
OpcionCalificacionFactory(
nombre=angry.nombre, campana=campana_manual, tipo=OpcionCalificacion.NO_ACCION)
activacion_queue_service = ActivacionQueueService()
activacion_queue_service.activar()
# crea un troncal y con este una ruta entrante hacia el pbx-emulator
text_config = ("type=friend\n"
"host=pbx-emulator\n"
"defaultuser=01177660010\n"
"secret=OMLtraining72\n"
"qualify=yes\n"
"insecure=invite\n"
"context=from-pstn\n"
"disallow=all\n"
"allow=alaw\n")
register_string = "01177660010:OMLtraining72@pbx-emulator"
troncal_pbx_emulator = TroncalSIPFactory(
text_config=text_config, register_string=register_string, canales_maximos=1000,
caller_id='')
sincronizador_troncal = SincronizadorDeConfiguracionTroncalSipEnAsterisk()
sincronizador_troncal.regenerar_troncales(troncal_pbx_emulator)
ruta_saliente = RutaSalienteFactory(ring_time=25, dial_options="Tt")
PatronDeDiscadoFactory(ruta_saliente=ruta_saliente, match_pattern="X.")
OrdenTroncalFactory(ruta_saliente=ruta_saliente, orden=0, troncal=troncal_pbx_emulator)
sincronizador_ruta_saliente = SincronizadorDeConfiguracionDeRutaSalienteEnAsterisk()
sincronizador_ruta_saliente.regenerar_rutas_salientes(ruta_saliente)
class APITest(OMLBaseTest):
"""Agrupa todos los test relacionados con los servicios creados para la API del sistema"""
def setUp(self):
super(APITest, self).setUp()
self.factory = RequestFactory()
self.supervisor_admin = self.crear_supervisor_profile(
rol=User.ADMINISTRADOR)
self.supervisor = self.crear_supervisor_profile(rol=User.SUPERVISOR)
self.agente_profile = self.crear_agente_profile()
self.campana_activa = CampanaFactory.create(
estado=Campana.ESTADO_ACTIVA,
type=Campana.TYPE_MANUAL,
nombre='activa uno')
self.campana_activa_2 = CampanaFactory.create(
estado=Campana.ESTADO_ACTIVA,
type=Campana.TYPE_PREVIEW,
nombre='activa dos')
self.campana_activa_supervisor = CampanaFactory.create(
estado=Campana.ESTADO_ACTIVA,
type=Campana.TYPE_ENTRANTE,
nombre='activa supervisor uno')
self.campana_activa_supervisor.supervisors.add(self.supervisor.user)
self.campana_finalizada = CampanaFactory(
estado=Campana.ESTADO_FINALIZADA)
self.queue = QueueFactory.create(campana=self.campana_activa)
self.queue1 = QueueFactory.create(campana=self.campana_activa_2)
self.queue2 = QueueFactory.create(
campana=self.campana_activa_supervisor)
self.queue3 = QueueFactory.create(campana=self.campana_finalizada)
QueueMemberFactory.create(member=self.agente_profile,
queue_name=self.queue)
self.sistema_externo = SistemaExternoFactory()
self.opcion_calificacion = OpcionCalificacionFactory(
campana=self.campana_activa)
self.contacto = ContactoFactory(
bd_contacto=self.campana_activa.bd_contacto)
self.calificacion_cliente = CalificacionClienteFactory(
opcion_calificacion=self.opcion_calificacion,
agente=self.agente_profile,
contacto=self.contacto)
for user in User.objects.all():
Token.objects.create(user=user)
def test_api_campanas_supervisor_usuario_supervisor_admin_obtiene_todas_campanas_activas(
self):
self.client.login(username=self.supervisor_admin.user.username,
password=PASSWORD)
url = reverse('api_campanas_de_supervisor')
response = self.client.get(url)
ids_campanas_esperadas = set(
Campana.objects.obtener_activas().values_list('id', flat=True))
ids_campanas_devueltas = set(
[campana['id'] for campana in response.data])
self.assertEqual(ids_campanas_esperadas, ids_campanas_devueltas)
def test_api_campanas_supervisor_admin_filtro_nombre(self):
self.client.login(username=self.supervisor_admin.user.username,
password=PASSWORD)
url = reverse('api_campanas_de_supervisor')
response = self.client.get(url, {'name': 'uno'})
ids_campanas_esperadas = set(
(self.campana_activa.id, self.campana_activa_supervisor.id))
ids_campanas_devueltas = set(
[campana['id'] for campana in response.data])
self.assertEqual(ids_campanas_esperadas, ids_campanas_devueltas)
def test_api_campanas_supervisor_admin_filtro_tipo(self):
self.client.login(username=self.supervisor_admin.user.username,
password=PASSWORD)
url = reverse('api_campanas_de_supervisor')
response = self.client.get(url, {'type': Campana.TYPE_MANUAL})
ids_campanas_esperadas = set([self.campana_activa.id])
ids_campanas_devueltas = set(
[campana['id'] for campana in response.data])
self.assertEqual(ids_campanas_esperadas, ids_campanas_devueltas)
def test_api_campanas_supervisor_admin_filtro_tipos(self):
self.client.login(username=self.supervisor_admin.user.username,
password=PASSWORD)
url = reverse('api_campanas_de_supervisor')
response = self.client.get(
url, {'type': str([Campana.TYPE_MANUAL, Campana.TYPE_PREVIEW])})
ids_campanas_esperadas = set(
[self.campana_activa.id, self.campana_activa_2.id])
ids_campanas_devueltas = set(
[campana['id'] for campana in response.data])
self.assertEqual(ids_campanas_esperadas, ids_campanas_devueltas)
def test_api_campanas_supervisor_admin_filtro_agente(self):
self.client.login(username=self.supervisor_admin.user.username,
password=PASSWORD)
url = reverse('api_campanas_de_supervisor')
QueueMemberFactory.create(
member=self.agente_profile,
queue_name=self.campana_activa_supervisor.queue_campana)
response = self.client.get(url, {'agent': self.agente_profile.id})
ids_campanas_esperadas = set(
(self.campana_activa.id, self.campana_activa_supervisor.id))
ids_campanas_devueltas = set(
[campana['id'] for campana in response.data])
self.assertEqual(ids_campanas_esperadas, ids_campanas_devueltas)
def test_api_campanas_supervisor_usr_supervisor_no_admin_obtiene_campanas_activas_asignadas(
self):
self.client.login(username=self.supervisor.user.username,
password=PASSWORD)
url = reverse('api_campanas_de_supervisor')
response = self.client.get(url)
self.assertEqual(len(response.data), 1)
self.assertEqual(response.data[0]['id'],
self.campana_activa_supervisor.id)
def test_servicio_campanas_supervisor_usuario_agente_no_accede_a_servicio(
self):
self.client.login(username=self.agente_profile.user.username,
password=PASSWORD)
url = reverse('api_campanas_de_supervisor')
response = self.client.get(url)
self.assertEqual(response.status_code, 403)
def test_servicio_campanas_supervisor_usuario_no_logueado_no_accede_a_servicio(
self):
url = reverse('api_campanas_de_supervisor')
response = self.client.get(url)
self.assertEqual(response.status_code, 403)
def test_servicio_agentes_activos_usuario_no_logueado_no_accede_a_servicio(
self):
url = reverse('api_agentes_activos')
response = self.client.get(url, follow=True)
self.assertTemplateUsed(response, 'registration/login.html')
def test_servicio_opciones_calificaciones_usuario_no_logueado_no_accede_a_servicio(
self):
url = reverse('api_campana_opciones_calificacion-list',
args=[self.campana_activa.pk, 1])
response = self.client.get(url, follow=True)
self.assertEqual(response.status_code, 403)
def test_servicio_opciones_calificaciones_usuario_no_agente_no_accede_a_servicio(
self):
url = reverse('api_campana_opciones_calificacion-list',
args=[self.campana_activa.pk, 1])
self.client.login(username=self.supervisor_admin.user.username,
password=PASSWORD)
response = self.client.get(url, follow=True)
self.assertEqual(response.status_code, 403)
def test_servicio_opciones_calificaciones_usuario_agente_accede_a_servicio(
self):
id_externo = "id_externo_campana_activa"
self.sistema_externo.campanas.add(self.campana_activa)
self.campana_activa.id_externo = id_externo
self.campana_activa.save()
self.client.login(username=self.agente_profile.user.username,
password=PASSWORD)
url = reverse('api_campana_opciones_calificacion-list',
args=[id_externo, self.sistema_externo.pk])
response = self.client.get(url, follow=True)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json()[0]['name'],
self.opcion_calificacion.nombre)
def test_servicio_opciones_calificaciones_usuario_agente_accede_a_servicio_via_token(
self):
token_agente = Token.objects.get(user=self.agente_profile.user).key
client = APIClient()
client.credentials(HTTP_AUTHORIZATION='Bearer ' + token_agente)
id_externo = "id_externo_campana_activa"
self.sistema_externo.campanas.add(self.campana_activa)
self.campana_activa.id_externo = id_externo
self.campana_activa.save()
url = reverse('api_campana_opciones_calificacion-list',
args=[id_externo, self.sistema_externo.pk])
response = client.get(url, follow=True)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json()[0]['name'],
self.opcion_calificacion.nombre)
def test_api_vista_opciones_calificaciones_no_es_accessible_usando_token_no_agente(
self):
token_supervisor = Token.objects.get(
user=self.supervisor_admin.user).key
client = APIClient()
client.credentials(HTTP_AUTHORIZATION='Bearer ' + token_supervisor)
url = reverse('api_campana_opciones_calificacion-list',
args=[1, self.sistema_externo.pk])
response = client.get(url)
self.assertEqual(response.status_code, 403)
def test_api_opciones_calificacion_devuelve_404_si_sistema_externo_no_es_entero(
self):
token_agente = Token.objects.get(user=self.agente_profile.user).key
client = APIClient()
client.credentials(HTTP_AUTHORIZATION='Bearer ' + token_agente)
url = reverse('api_campana_opciones_calificacion-list', args=(1, 1))
response = client.get(url)
self.assertEqual(response.status_code, 404)
def test_api_opciones_calificacion_sin_sistema_externo_devuelve_404_id_campana_no_entero(
self):
token_agente = Token.objects.get(user=self.agente_profile.user).key
client = APIClient()
client.credentials(HTTP_AUTHORIZATION='Bearer ' + token_agente)
url = reverse('api_campana_opciones_calificacion_intern-list',
args=("campana_id_str", ))
response = client.get(url)
self.assertEqual(response.status_code, 404)
def test_api_opciones_calificacion_sin_sistema_externo_usa_id_campana_oml(
self):
token_agente = Token.objects.get(user=self.agente_profile.user).key
client = APIClient()
client.credentials(HTTP_AUTHORIZATION='Bearer ' + token_agente)
url = reverse('api_campana_opciones_calificacion_intern-list',
args=(self.campana_activa.pk, ))
response = client.get(url)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json()[0]['name'],
self.opcion_calificacion.nombre)
def test_api_opciones_calificacion_ocultando_opcion_calificacion(self):
opcion_calificacion_2 = OpcionCalificacionFactory(
campana=self.campana_activa)
self.opcion_calificacion.oculta = True
self.opcion_calificacion.save()
token_agente = Token.objects.get(user=self.agente_profile.user).key
client = APIClient()
client.credentials(HTTP_AUTHORIZATION='Bearer ' + token_agente)
url = reverse('api_campana_opciones_calificacion_intern-list',
args=(self.campana_activa.pk, ))
response = client.get(url)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.json()), 2)
opcion_data_1 = response.json()[0]
opcion_data_2 = response.json()[1]
if response.json()[1]['id'] == self.opcion_calificacion.id:
opcion_data_1 = response.json()[1]
opcion_data_2 = response.json()[0]
self.assertEqual(opcion_data_1['id'], self.opcion_calificacion.id)
self.assertEqual(opcion_data_2['id'], opcion_calificacion_2.id)
self.assertEqual(opcion_data_1['name'],
self.opcion_calificacion.nombre)
self.assertEqual(opcion_data_2['name'], opcion_calificacion_2.nombre)
self.assertTrue(opcion_data_1['hidden'])
self.assertFalse(opcion_data_2['hidden'])
def set_redis_mock_return_values(self, redis_mock_class, keys, values):
redis_fake_dict = dict(zip(keys, values))
redis_mock_class.return_value.keys.return_value = keys
def hgetall_fake(key):
return redis_fake_dict[key]
redis_mock_class.return_value.hgetall = hgetall_fake
return redis_mock_class
@patch(
'ominicontacto_app.services.asterisk.supervisor_activity.redis.Redis')
def test_servicio_agentes_activos_funciona_correctamente(self, Redis):
ag1_pk = self.agente_profile.pk
self.campana_activa.supervisors.add(self.supervisor_admin.user)
ag2 = self.crear_agente_profile()
QueueMemberFactory.create(member=ag2, queue_name=self.queue)
key1 = 'OML:AGENT:{0}'.format(ag1_pk)
key2 = 'OML:AGENT:{0}'.format(ag2.pk)
key3 = 'OML:SUPERVISOR:{0}'.format(self.supervisor_admin.pk)
now = datetime.now()
timestamp = datetime.timestamp(now)
key1_value = {
'TIMESTAMP': timestamp,
'STATUS': 'READY',
'NAME': self.agente_profile.user.get_full_name(),
'SIP': self.agente_profile.sip_extension
}
key2_value = {
'TIMESTAMP': timestamp,
'NAME': ag2.user.get_full_name(),
'SIP': ag2.sip_extension,
'STATUS': 'PAUSE',
}
key3_value = {
str(ag1_pk):
json.dumps({
'grupo': self.agente_profile.grupo.nombre,
'campana': [
self.campana_activa.nombre,
]
}),
str(ag2.pk):
json.dumps({
'grupo': ag2.grupo.nombre,
'campana': [
self.campana_activa.nombre,
]
}),
}
Redis = self.set_redis_mock_return_values(
Redis, [key1, key2, key3], [key1_value, key2_value, key3_value])
self.client.login(username=self.supervisor_admin.user.username,
password=PASSWORD)
url = reverse('api_agentes_activos')
response = self.client.get(url)
response_json = response.json()
ag1_value = response_json[0]
ag2_value = response_json[1]
self.assertEqual(len(response_json), 2)
self.assertEqual(ag1_value['id'], ag1_pk)
self.assertEqual(ag2_value['id'], ag2.pk)
@patch(
'ominicontacto_app.services.asterisk.supervisor_activity.redis.Redis')
def test_servicio_agentes_activos_no_muestra_entradas_status_vacio(
self, Redis):
ag1_pk = self.agente_profile.pk
self.campana_activa.supervisors.add(self.supervisor_admin.user)
ag2 = self.crear_agente_profile()
QueueMemberFactory.create(member=ag2, queue_name=self.queue)
key1 = 'OML:AGENT:{0}'.format(ag1_pk)
key2 = 'OML:AGENT:{0}'.format(ag2.pk)
key3 = 'OML:SUPERVISOR:{0}'.format(self.supervisor_admin.pk)
now = datetime.now()
timestamp = datetime.timestamp(now)
key1_value = {
'TIMESTAMP': timestamp,
'STATUS': 'READY',
'NAME': self.agente_profile.user.get_full_name(),
'SIP': self.agente_profile.sip_extension
}
key2_value = {
'TIMESTAMP': timestamp,
'NAME': ag2.user.get_full_name(),
'SIP': ag2.sip_extension
}
key3_value = {
str(ag1_pk):
json.dumps({
'grupo': self.agente_profile.grupo.nombre,
'campana': [
self.campana_activa.nombre,
]
})
}
Redis = self.set_redis_mock_return_values(
Redis, [key1, key2, key3], [key1_value, key2_value, key3_value])
self.client.login(username=self.supervisor_admin.user.username,
password=PASSWORD)
url = reverse('api_agentes_activos')
response = self.client.get(url)
response_json = response.json()
ag_value = response_json[0]
self.assertEqual(len(response_json), 1)
self.assertEqual(ag_value['id'], ag1_pk)
@patch(
'ominicontacto_app.services.asterisk.supervisor_activity.redis.Redis')
def test_servicio_agentes_activos_no_muestra_entradas_con_menos_campos(
self, Redis):
ag1_pk = self.agente_profile.pk
self.campana_activa.supervisors.add(self.supervisor_admin.user)
ag2 = self.crear_agente_profile()
QueueMemberFactory.create(member=ag2, queue_name=self.queue)
key1 = 'OML:AGENT:{0}'.format(ag1_pk)
key2 = 'OML:AGENT:{0}'.format(ag2.pk)
key3 = 'OML:SUPERVISOR:{0}'.format(self.supervisor_admin.pk)
now = datetime.now()
timestamp = datetime.timestamp(now)
key1_value = {
'STATUS': 'READY',
'NAME': self.agente_profile.user.get_full_name(),
'SIP': self.agente_profile.sip_extension
}
key2_value = {
'TIMESTAMP': timestamp,
'NAME': ag2.user.get_full_name(),
'SIP': ag2.sip_extension
}
key3_value = {
str(ag1_pk):
json.dumps({
'grupo': self.agente_profile.grupo.nombre,
'campana': [
self.campana_activa.nombre,
]
})
}
Redis = self.set_redis_mock_return_values(
Redis, [key1, key2, key3], [key1_value, key2_value, key3_value])
self.client.login(username=self.supervisor_admin.user.username,
password=PASSWORD)
url = reverse('api_agentes_activos')
response = self.client.get(url)
response_json = response.json()
self.assertEqual(len(response_json), 0)
def test_api_login_devuelve_token_asociado_al_usuario_password(self):
url = 'https://{0}{1}'.format(settings.OML_OMNILEADS_HOSTNAME,
reverse('api_login'))
user = self.supervisor_admin.user
password = PASSWORD
post_data = {
'username': user.username,
'password': password,
}
request = self.factory.post(url, data=post_data)
response = login(request)
token_obj = Token.objects.get(user=user)
self.assertEqual(response.data['token'], token_obj.key)
def test_api_vista_contactos_campanas_es_accessible_usando_token_agente(
self):
ContactoFactory(bd_contacto=self.campana_activa.bd_contacto)
cantidad = self.campana_activa.bd_contacto.contactos.count()
token_agente = Token.objects.get(user=self.agente_profile.user).key
client = APIClient()
client.credentials(HTTP_AUTHORIZATION='Bearer ' + token_agente)
url = reverse('api_contactos_campana', args=(self.campana_activa.pk, ))
response = client.get(url, {
'search[value]': 1,
'start': 1,
'length': 10,
'draw': 10
},
format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data['recordsTotal'], cantidad)
def test_api_vista_contactos_campanas_no_es_accessible_usando_token_no_agente(
self):
token_agente = Token.objects.get(user=self.supervisor_admin.user).key
client = APIClient()
client.credentials(HTTP_AUTHORIZATION='Bearer ' + token_agente)
url = reverse('api_contactos_campana', args=(self.campana_activa.pk, ))
response = client.get(url, {
'search[value]': 1,
'start': 1,
'length': 10,
'draw': 10
},
format='json')
self.assertEqual(response.status_code, 403)
def test_api_adiciona_calificacion_ids_internos(self):
token_agente = Token.objects.get(user=self.agente_profile.user).key
client = APIClient()
client.credentials(HTTP_AUTHORIZATION='Bearer ' + token_agente)
observaciones = 'calificacion externa'
contacto = ContactoFactory(bd_contacto=self.campana_activa.bd_contacto)
url = reverse('api_disposition-list')
post_data = {
'idContact': contacto.pk,
'idDispositionOption': self.opcion_calificacion.pk,
'comments': observaciones
}
calificaciones_count = CalificacionCliente.objects.count()
client.post(url, post_data)
self.assertEqual(CalificacionCliente.objects.count(),
calificaciones_count + 1)
def test_api_adiciona_calificacion_ids_externos(self):
self.client.login(username=self.agente_profile.user.username,
password=PASSWORD)
observaciones = 'calificacion externa'
id_contacto_externo = 'contacto_externo_1'
AgenteEnSistemaExternoFactory(agente=self.agente_profile,
sistema_externo=self.sistema_externo)
ContactoFactory(bd_contacto=self.campana_activa.bd_contacto,
id_externo=id_contacto_externo)
url = reverse('api_disposition-list')
post_data = {
'idExternalSystem': self.sistema_externo.pk,
'idContact': id_contacto_externo,
'idDispositionOption': self.opcion_calificacion.pk,
'comments': observaciones
}
calificaciones_count = CalificacionCliente.objects.count()
self.client.post(url, post_data)
self.assertEqual(CalificacionCliente.objects.count(),
calificaciones_count + 1)
def test_api_adiciona_calificacion_ids_internos_no_se_accede_credenciales_no_agente(
self):
observaciones = 'calificacion externa'
contacto = ContactoFactory(bd_contacto=self.campana_activa.bd_contacto)
url = reverse('api_disposition-list')
post_data = {
'idContact': contacto.pk,
'idAgent': self.agente_profile.pk,
'idDispositionOption': self.opcion_calificacion.pk,
'comments': observaciones
}
token_supervisor = Token.objects.get(
user=self.supervisor_admin.user).key
client = APIClient()
client.credentials(HTTP_AUTHORIZATION='Bearer ' + token_supervisor)
url = reverse('api_disposition-list')
response = client.post(url, post_data)
self.assertEqual(response.status_code, 403)
def test_api_crea_nueva_calificacion_con_nuevo_contacto_metadata_vacia(
self):
self.client.login(username=self.agente_profile.user.username,
password=PASSWORD)
observaciones = 'calificacion externa'
phone = '1232343523'
id_contacto_externo = 'contacto_externo_1'
url = reverse('api_disposition_new_contact-list')
post_data = {
'phone': phone,
'idExternalContact': id_contacto_externo,
'idDispositionOption': self.opcion_calificacion.pk,
'comments': observaciones
}
calificaciones_count = CalificacionCliente.objects.count()
contactos_count = Contacto.objects.count()
self.client.post(url, post_data)
self.assertEqual(CalificacionCliente.objects.count(),
calificaciones_count + 1)
self.assertEqual(Contacto.objects.count(), contactos_count + 1)
def test_api_crea_nueva_calificacion_con_nuevo_contacto_con_valores_metadata(
self):
token_agente = Token.objects.get(user=self.agente_profile.user).key
client = APIClient()
client.credentials(HTTP_AUTHORIZATION='Bearer ' + token_agente)
observaciones = 'calificacion externa'
phone = '1232343523'
id_contacto_externo = 'contacto_externo_1'
url = reverse('api_disposition_new_contact-list')
post_data = {
'phone': phone,
'idExternalContact': id_contacto_externo,
'idDispositionOption': self.opcion_calificacion.pk,
'comments': observaciones,
}
contacto_a_crear = ContactoFactory.build(
bd_contacto=self.campana_activa.bd_contacto)
post_data.update(contacto_a_crear.obtener_datos())
post_data.pop('telefono')
calificaciones_count = CalificacionCliente.objects.count()
contactos_count = Contacto.objects.count()
client.post(url, post_data)
self.assertEqual(CalificacionCliente.objects.count(),
calificaciones_count + 1)
self.assertEqual(Contacto.objects.count(), contactos_count + 1)
self.assertTrue(
Contacto.objects.filter(datos=contacto_a_crear.datos).exists())
def test_api_crear_nueva_calificacion_con_nuevo_contacto_con_opcion_oculta_falla(
self):
self.opcion_calificacion.oculta = True
self.opcion_calificacion.save()
self.client.login(username=self.agente_profile.user.username,
password=PASSWORD)
observaciones = 'calificacion externa'
phone = '1232343523'
id_contacto_externo = 'contacto_externo_1'
url = reverse('api_disposition_new_contact-list')
post_data = {
'phone': phone,
'idExternalContact': id_contacto_externo,
'idDispositionOption': self.opcion_calificacion.pk,
'comments': observaciones
}
calificaciones_count = CalificacionCliente.objects.count()
contactos_count = Contacto.objects.count()
response = self.client.post(url, post_data)
response_data = response.json()
self.assertEqual(response.status_code, 400)
self.assertIn('idDispositionOption', response_data)
self.assertEqual(response_data['idDispositionOption'],
'Disposition option id not found')
self.assertEqual(CalificacionCliente.objects.count(),
calificaciones_count)
self.assertEqual(Contacto.objects.count(), contactos_count)
def test_api_crear_calificacion_impide_calificar_mas_de_una_vez_contacto_campana(
self):
token_agente = Token.objects.get(user=self.agente_profile.user).key
client = APIClient()
client.credentials(HTTP_AUTHORIZATION='Bearer ' + token_agente)
observaciones = 'calificacion externa'
post_data = {
'idContact': self.calificacion_cliente.contacto.pk,
'idAgent': self.agente_profile.pk,
'idDispositionOption': self.opcion_calificacion.pk,
'comments': observaciones
}
url = reverse('api_disposition-list')
response = client.post(url, post_data)
self.assertEqual(response.status_code, 400)
def test_api_modificar_calificacion_impide_calificar_mas_de_una_vez_contacto_campana(
self):
contacto_nuevo = ContactoFactory(
bd_contacto=self.campana_activa.bd_contacto)
CalificacionClienteFactory(
opcion_calificacion=self.opcion_calificacion,
contacto=contacto_nuevo)
token_agente = Token.objects.get(user=self.agente_profile.user).key
client = APIClient()
client.credentials(HTTP_AUTHORIZATION='Bearer ' + token_agente)
observaciones = 'calificacion externa'
post_data = {
'id': self.calificacion_cliente.pk,
'idContact': contacto_nuevo.pk,
'idAgent': self.agente_profile.pk,
'idDispositionOption': self.opcion_calificacion.pk,
'comments': observaciones
}
url = reverse('api_disposition-detail',
args=(self.calificacion_cliente.pk, ))
response = client.put(url, post_data)
self.assertEqual(response.status_code, 400)
self.assertEqual(str(response.data['status']), 'ERROR')
def test_api_modificar_calificacion_permite_modificarla_con_opcion_calificacion_oculta(
self):
token_agente = Token.objects.get(user=self.agente_profile.user).key
client = APIClient()
client.credentials(HTTP_AUTHORIZATION='Bearer ' + token_agente)
self.opcion_calificacion.oculta = True
self.opcion_calificacion.save()
observaciones = 'Nuevas observaciones'
post_data = {
'idContact': self.calificacion_cliente.contacto.pk,
'idDispositionOption': self.opcion_calificacion.pk,
'comments': observaciones
}
url = reverse('api_disposition-detail',
args=(self.calificacion_cliente.pk, ))
response = client.put(url, post_data)
self.assertEqual(response.status_code, 200)
expected_result = {
"id": self.calificacion_cliente.id,
"idContact": self.calificacion_cliente.contacto.id,
"callid": None,
"idDispositionOption":
self.calificacion_cliente.opcion_calificacion.id,
"comments": observaciones
}
self.assertEqual(response.json(), expected_result)
def test_api_modificar_calificacion_NO_permite_modificarla_a_opcion_calificacion_oculta(
self):
token_agente = Token.objects.get(user=self.agente_profile.user).key
client = APIClient()
client.credentials(HTTP_AUTHORIZATION='Bearer ' + token_agente)
opcion_oculta = OpcionCalificacionFactory(campana=self.campana_activa,
oculta=True)
post_data = {
'idContact': self.calificacion_cliente.contacto.pk,
'idDispositionOption': opcion_oculta.pk,
'comments': self.calificacion_cliente.observaciones
}
url = reverse('api_disposition-detail',
args=(self.calificacion_cliente.pk, ))
response = client.put(url, post_data)
self.assertEqual(response.status_code, 400)
expected_result = {
'status': 'ERROR',
'idDispositionOption': 'Disposition option id not found'
}
self.assertEqual(response.json(), expected_result)
def test_api_crear_calificacion_con_opcion_oculta_para_contacto_existente_falla(
self):
id_contacto = self.calificacion_cliente.contacto.pk
CalificacionCliente.objects.all().delete()
self.opcion_calificacion.oculta = True
self.opcion_calificacion.save()
token_agente = Token.objects.get(user=self.agente_profile.user).key
client = APIClient()
client.credentials(HTTP_AUTHORIZATION='Bearer ' + token_agente)
observaciones = 'calificacion externa'
post_data = {
'idContact': id_contacto,
'idAgent': self.agente_profile.pk,
'idDispositionOption': self.opcion_calificacion.pk,
'comments': observaciones
}
url = reverse('api_disposition-list')
response = client.post(url, post_data)
self.assertEqual(response.status_code, 400)
response_data = response.json()
self.assertEqual(response_data['status'], 'ERROR')
self.assertIn('idDispositionOption', response_data)
self.assertEqual(response_data['idDispositionOption'],
'Disposition option id not found')
def test_api_muestra_solo_las_calificaciones_que_ha_hecho_el_agente_que_accede(
self):
contacto_nuevo = ContactoFactory(
bd_contacto=self.campana_activa.bd_contacto)
CalificacionClienteFactory(
opcion_calificacion=self.opcion_calificacion,
contacto=contacto_nuevo)
token_agente = Token.objects.get(user=self.agente_profile.user).key
client = APIClient()
client.credentials(HTTP_AUTHORIZATION='Bearer ' + token_agente)
url = reverse('api_disposition-list')
response = client.get(url)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 1)
@patch(
'ominicontacto_app.services.asterisk.asterisk_ami.AMIManagerConnector')
@patch.object(AgentActivityAmiManager, "login_agent")
def test_api_vista_login_de_agente_retorno_de_valores_correctos(
self, login_agent, manager):
self.client.login(username=self.agente_profile.user.username,
password=PASSWORD)
login_agent.return_value = False
url = reverse('api_agent_asterisk_login')
response = self.client.post(url)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json()['status'], 'OK')
@patch(
'ominicontacto_app.services.asterisk.asterisk_ami.AMIManagerConnector')
@patch.object(AgentActivityAmiManager, "login_agent")
def test_api_vista_login_de_agente_retorno_de_valores_erroneos(
self, login_agent, manager):
self.client.login(username=self.agente_profile.user.username,
password=PASSWORD)
login_agent.return_value = True
url = reverse('api_agent_asterisk_login')
response = self.client.post(url)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json()['status'], 'ERROR')
@patch(
'ominicontacto_app.services.asterisk.asterisk_ami.AMIManagerConnector')
@patch.object(AgentActivityAmiManager, "pause_agent")
def test_api_vista_pausa_de_agente_retorno_de_valores_correctos(
self, pause_agent, manager):
self.client.login(username=self.agente_profile.user.username,
password=PASSWORD)
pause_agent.return_value = False, False
url = reverse('api_make_pause')
post_data = {'pause_id': 1}
response = self.client.post(url, post_data)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json()['status'], 'OK')
@patch(
'ominicontacto_app.services.asterisk.asterisk_ami.AMIManagerConnector')
@patch.object(AgentActivityAmiManager, "pause_agent")
def test_api_vista_pausa_de_agente_retorno_de_valores_erroneos(
self, pause_agent, manager):
self.client.login(username=self.agente_profile.user.username,
password=PASSWORD)
pause_agent.return_value = True, False
url = reverse('api_make_pause')
post_data = {'pause_id': 1}
response = self.client.post(url, post_data)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json()['status'], 'ERROR')
@patch(
'ominicontacto_app.services.asterisk.asterisk_ami.AMIManagerConnector')
@patch.object(AgentActivityAmiManager, "unpause_agent")
def test_api_vista_despausa_de_agente_retorno_de_valores_correctos(
self, unpause_agent, manager):
self.client.login(username=self.agente_profile.user.username,
password=PASSWORD)
unpause_agent.return_value = False, False
url = reverse('api_make_unpause')
post_data = {'pause_id': 1}
response = self.client.post(url, post_data)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json()['status'], 'OK')
@patch(
'ominicontacto_app.services.asterisk.asterisk_ami.AMIManagerConnector')
@patch.object(AgentActivityAmiManager, "unpause_agent")
def test_api_vista_despausa_de_agente_retorno_de_valores_erroneos(
self, unpause_agent, manager):
self.client.login(username=self.agente_profile.user.username,
password=PASSWORD)
unpause_agent.return_value = True, False
url = reverse('api_make_unpause')
post_data = {'pause_id': 1}
response = self.client.post(url, post_data)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json()['status'], 'ERROR')