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 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)
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 test_supervision_saliente_redis_family(self):
CalificacionClienteFactory(
opcion_calificacion=self.opcion_calificacion_m1,
agente=self.agente1)
CalificacionClienteFactory(
opcion_calificacion=self.opcion_calificacion_d1,
agente=self.agente1)
CalificacionClienteFactory(
opcion_calificacion=self.opcion_calificacion_p1,
agente=self.agente1)
reporte = ReporteDeLLamadasSalientesDeSupervision()
redis_saliente = ReporteLlamadasSalienteFamily()
self.assertEqual(len(reporte.estadisticas.keys()), 2)
for id_campana in [self.manual.id, self.preview.id]:
self.assertIn(id_campana, reporte.estadisticas)
datos_redis = redis_saliente._create_dict(
reporte.estadisticas[id_campana])
self.assertEqual(datos_redis['NOMBRE'],
reporte.estadisticas[id_campana]['nombre'])
self.assertEqual(datos_redis['ESTADISTICAS'],
json.dumps(reporte.estadisticas[id_campana]))
def test_datos_reporte_grafico_calificaciones_por_agente_coinciden_estadisticas_sistema(
self, render_to_png, crea_reporte_pdf, crea_reporte_csv):
agente_profile1, agente_profile2, agente_profile3 = AgenteProfileFactory.create_batch(
3)
CalificacionClienteFactory(
opcion_calificacion=self.opcion_calificacion_gestion,
agente=agente_profile1)
CalificacionClienteFactory(
opcion_calificacion=self.opcion_calificacion_noaccion,
agente=agente_profile2)
CalificacionClienteFactory(
opcion_calificacion=self.opcion_calificacion_noaccion,
agente=agente_profile3)
url = reverse('campana_reporte_grafico', args=[self.campana_activa.pk])
response = self.client.get(url, follow=True)
estadisticas = response.context_data['graficos_estadisticas'][
'estadisticas']
self.assertContains(response, agente_profile1.user.get_full_name())
self.assertContains(response, agente_profile2.user.get_full_name())
self.assertContains(response, agente_profile3.user.get_full_name())
# se toman en cuenta las calificaciones iniciales del setUp
self.assertEqual(estadisticas['total_ventas'], 2)
self.assertEqual(estadisticas['total_calificados'], 5)
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_contabiliza_gestiones(self, _obtener_llamadas_en_espera_raw):
self.generador.generar_log(self.entrante1, False, 'COMPLETEAGENT', '35100001111',
agente=self.agente1, contacto=None, bridge_wait_time=-1,
duracion_llamada=10, archivo_grabacion='', time=None)
CalificacionClienteFactory(opcion_calificacion=self.opcion_calificacion,
agente=self.agente1)
reporte = ReporteDeLLamadasEntrantesDeSupervision()
self.assertEqual(
reporte.estadisticas[self.entrante1.id]['llamadas_atendidas'], 1)
self.assertEqual(
reporte.estadisticas[self.entrante1.id]['llamadas_expiradas'], 0)
self.assertEqual(
reporte.estadisticas[self.entrante1.id]['llamadas_abandonadas'], 0)
self.assertEqual(
reporte.estadisticas[self.entrante1.id]['gestiones'], 1)
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.campana3 = CampanaFactory(estado=Campana.ESTADO_ACTIVA)
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)
def test_calificacion_cliente_modificacion_gestion_por_no_accion(self, post):
contacto_califica = ContactoFactory.create()
self.campana.bd_contacto.contactos.add(contacto_califica)
calificacion = CalificacionClienteFactory(
opcion_calificacion=self.opcion_calificacion_gestion, agente=self.agente_profile,
contacto=contacto_califica)
RespuestaFormularioGestionFactory(calificacion=calificacion)
# Se modifica la calificacion por una de no accion
url_calificacion = reverse('calificacion_formulario_update_or_create',
kwargs={'pk_campana': self.campana.pk,
'pk_contacto': contacto_califica.pk})
post_data_calificacion = self._obtener_post_data_calificacion_cliente(
contacto=contacto_califica)
post_data_calificacion['opcion_calificacion'] = self.opcion_calificacion_no_accion.pk
self.client.post(url_calificacion, post_data_calificacion, follow=True)
self.assertIsNone(
CalificacionCliente.objects.get(opcion_calificacion__campana=self.campana,
contacto_id=contacto_califica.id).get_venta())
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_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_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):
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(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.calificacion26 = 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_observada = AuditoriaCalificacionFactory(
calificacion=self.calificacion25,
resultado=AuditoriaCalificacion.OBSERVADA)
self.auditoria_observada_revisada = AuditoriaCalificacionFactory(
calificacion=self.calificacion26,
resultado=AuditoriaCalificacion.OBSERVADA,
revisada=True)
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.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_calificacion(opcion_calificacion, agente):
CalificacionClienteFactory(opcion_calificacion=opcion_calificacion, agente=agente)
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 modificar_calificacion():
calificacion = CalificacionClienteFactory(
opcion_calificacion=self.opcion_calificacion_no_accion)
calificacion.contacto = self.contacto
calificacion.save()
def test_no_se_admite_mas_de_una_calificacion_para_un_contacto_en_una_campana_creacion(self):
opcion_calificacion = self.calificacion_cliente.opcion_calificacion
contacto = self.contacto
self.assertRaises(ValidationError, lambda: CalificacionClienteFactory(
opcion_calificacion=opcion_calificacion, contacto=contacto))
class CalificacionTests(OMLBaseTest):
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_campana_dialer(self):
self.campana_dialer = CampanaFactory.create(type=Campana.TYPE_DIALER)
self.campana_dialer.opciones_calificacion.add(self.opcion_calificacion_gestion)
self.campana_dialer.opciones_calificacion.add(self.opcion_calificacion_agenda)
self.contacto_dialer = ContactoFactory.create()
self.campana_dialer.bd_contacto.contactos.add(self.contacto_dialer)
self.queue_dialer = QueueFactory.create(campana=self.campana_dialer)
QueueMemberFactory.create(member=self.agente_profile, queue_name=self.queue_dialer)
def _obtener_post_data_calificacion_cliente(self, campana=None, contacto=None):
if campana is None:
campana = self.campana
if contacto is None:
contacto = self.contacto
post_data = {
'contacto_form-telefono': contacto.telefono,
'campana': campana.pk,
'contacto': contacto.pk,
'agente': self.agente_profile.pk,
'opcion_calificacion': '',
}
return post_data
def test_no_se_admite_tipo_calificacion_cliente_vacia_en_creacion_calificacion(self):
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()
response = self.client.post(url, post_data, follow=True)
calificacion_form = response.context_data.get('calificacion_form')
self.assertFalse(calificacion_form.is_valid())
def test_no_se_admite_tipo_calificacion_cliente_vacia_en_modificacion_calificacion(self):
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()
response = self.client.post(url, post_data, follow=True)
calificacion_form = response.context_data.get('calificacion_form')
self.assertFalse(calificacion_form.is_valid())
def no_puede_calificar_si_no_esta_asignado(self):
campana2 = CampanaFactory.create()
contacto2 = ContactoFactory.create(bd_contacto=campana2.bd_contacto)
url = reverse('calificacion_formulario_update_or_create',
kwargs={'pk_campana': campana2.pk,
'pk_contacto': contacto2.pk})
response = self.client.get(url, follow=True)
self.assertContains(response, _("No tiene permiso para calificar llamadas de esa campaña."))
@patch('requests.post')
def test_calificacion_cliente_creacion_redirecciona_formulario_gestion(self, post):
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'] = self.opcion_calificacion_gestion.pk
response = self.client.post(url, post_data, follow=True)
self.assertTemplateUsed(response, 'formulario/respuesta_formulario_gestion_agente.html')
self.assertTrue(self.campo_formulario.nombre_campo in response.context_data['form'].fields)
@patch('requests.post')
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)
@patch('requests.post')
def test_calificacion_cliente_modificacion_redirecciona_formulario_gestion(self, post):
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'] = self.opcion_calificacion_gestion.pk
response = self.client.post(url, post_data, follow=True)
self.assertTemplateUsed(response, 'formulario/respuesta_formulario_gestion_agente.html')
@patch('requests.post')
def test_calificacion_cliente_modificacion_gestion_por_no_accion(self, post):
contacto_califica = ContactoFactory.create()
self.campana.bd_contacto.contactos.add(contacto_califica)
calificacion = CalificacionClienteFactory(
opcion_calificacion=self.opcion_calificacion_gestion, agente=self.agente_profile,
contacto=contacto_califica)
RespuestaFormularioGestionFactory(calificacion=calificacion)
# Se modifica la calificacion por una de no accion
url_calificacion = reverse('calificacion_formulario_update_or_create',
kwargs={'pk_campana': self.campana.pk,
'pk_contacto': contacto_califica.pk})
post_data_calificacion = self._obtener_post_data_calificacion_cliente(
contacto=contacto_califica)
post_data_calificacion['opcion_calificacion'] = self.opcion_calificacion_no_accion.pk
self.client.post(url_calificacion, post_data_calificacion, follow=True)
self.assertIsNone(
CalificacionCliente.objects.get(opcion_calificacion__campana=self.campana,
contacto_id=contacto_califica.id).get_venta())
def test_existe_calificacion_especial_agenda(self):
self.assertTrue(NombreCalificacion.objects.filter(nombre=settings.CALIFICACION_REAGENDA))
def _obtener_post_data_calificacion_manual(self):
post_data = {
'agente': self.agente_profile.pk,
'calificacion': '',
'observaciones': 'test',
'campana': self.campana.pk,
'agendado': False,
'telefono': self.contacto.pk
}
return post_data
@patch('requests.post')
def test_escoger_calificacion_agenda_redirecciona_formulario_agenda(self, post):
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'] = self.opcion_calificacion_agenda.pk
response = self.client.post(url, post_data, follow=True)
self.assertTemplateUsed(response,
'agente/frame/agenda_contacto/create_agenda_contacto.html')
@patch('requests.post')
def test_calificacion_agenda_modificacion_redirecciona_update_agenda(self, post):
self.calificacion_cliente.opcion_calificacion = self.opcion_calificacion_agenda
self.calificacion_cliente.agendado = False
self.calificacion_cliente.save()
AgendaContactoFactory(
agente=self.agente_profile, contacto=self.contacto, campana=self.campana)
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'] = self.opcion_calificacion_agenda.pk
response = self.client.post(url, post_data, follow=True)
self.assertTemplateUsed(response, 'agenda_contacto/update_agenda_contacto.html')
@patch('requests.post')
def test_calificacion_cliente_marcada_agendado_cuando_se_salva_agenda(self, post):
self.calificacion_cliente.opcion_calificacion = self.opcion_calificacion_agenda
self.calificacion_cliente.agendado = False
self.calificacion_cliente.save()
url = reverse('agenda_contacto_create',
kwargs={'pk_campana': self.campana.pk,
'pk_contacto': self.contacto.pk})
post_data = self._obtener_post_data_agenda()
self.assertFalse(self.calificacion_cliente.agendado)
self.client.post(url, post_data, follow=True)
self.calificacion_cliente.refresh_from_db()
self.assertTrue(self.calificacion_cliente.agendado)
def _obtener_post_data_agenda(self):
observaciones = 'test_schedule'
siguiente_dia = timezone.now() + timezone.timedelta(days=1)
fecha = str(siguiente_dia.date())
hora = str(siguiente_dia.time())
post_data = {'contacto': self.contacto.pk,
'campana': self.campana.pk,
'agente': self.agente_profile.pk,
'fecha': fecha,
'telefono': self.contacto.telefono,
'hora': hora,
'tipo_agenda': AgendaContacto.TYPE_PERSONAL,
'observaciones': observaciones}
return post_data
@patch('requests.post')
def test_no_se_programan_en_wombat_agendas_globales_calificaciones_campanas_no_dialer(
self, post):
self.campana.type = Campana.TYPE_PREVIEW
self.campana.save()
self.calificacion_cliente.opcion_calificacion = self.opcion_calificacion_agenda
self.calificacion_cliente.save()
url = reverse('agenda_contacto_create',
kwargs={'pk_campana': self.campana.pk,
'pk_contacto': self.contacto.pk})
post_data = self._obtener_post_data_agenda()
post_data['tipo_agenda'] = AgendaContacto.TYPE_GLOBAL
self.client.post(url, post_data, follow=True)
self.assertEqual(post.call_count, 0)
@patch('requests.post')
def test_se_programan_en_wombat_agendas_globales_calificaciones_campanas_dialer(
self, post):
self.campana.type = Campana.TYPE_DIALER
self.campana.save()
self.calificacion_cliente.opcion_calificacion = self.opcion_calificacion_agenda
self.calificacion_cliente.save()
url = reverse('agenda_contacto_create',
kwargs={'pk_campana': self.campana.pk,
'pk_contacto': self.contacto.pk})
post_data = self._obtener_post_data_agenda()
post_data['tipo_agenda'] = AgendaContacto.TYPE_GLOBAL
self.client.post(url, post_data, follow=True)
self.assertEqual(post.call_count, 1)
@patch('requests.post')
def test_creacion_agenda_contacto_adiciona_campo_campana(self, post):
self.calificacion_cliente.opcion_calificacion_gestion = self.opcion_calificacion_agenda
url = reverse('agenda_contacto_create',
kwargs={'pk_campana': self.campana.pk,
'pk_contacto': self.contacto.pk})
post_data = self._obtener_post_data_agenda()
self.client.post(url, post_data, follow=True)
agenda_contacto = AgendaContacto.objects.first()
self.assertEqual(agenda_contacto.campana.pk, self.campana.pk)
def test_llamada_manual_telefono_no_contacto_crea_contacto(self):
# garantizamos un número distinto al existente en la campaña
contactos_ids = self.campana.bd_contacto.contactos.values_list('id', flat=True)
contactos_ids = list(contactos_ids)
telefono = str(self.contacto.telefono) + '11'
post_data = {
'opcion_calificacion': self.opcion_calificacion_gestion.pk,
'contacto_form-telefono': telefono,
'contacto_form-nombre': 'Nuevo Contacto'
}
url = reverse('calificar_por_telefono',
kwargs={'pk_campana': self.campana.pk,
'telefono': telefono})
response = self.client.post(url, post_data, follow=True)
self.assertEqual(response.status_code, 200)
nuevo_contacto = self.campana.bd_contacto.contactos.exclude(id__in=contactos_ids)
self.assertEqual(nuevo_contacto.count(), 1)
nuevo_contacto = nuevo_contacto[0]
if self.campana.type != Campana.TYPE_ENTRANTE:
self.assertEqual(nuevo_contacto.telefono, telefono)
self.assertIn('Nuevo Contacto', nuevo_contacto.datos)
self.assertFalse(nuevo_contacto.es_originario)
def test_llamada_manual_telefono_no_contacto_muestra_formulario_calificacion_blanco(self):
# garantizamos un número distinto al existente en la campaña
telefono = str(self.contacto.telefono) + '11'
url = reverse('calificar_por_telefono',
kwargs={'pk_campana': self.campana.pk,
'telefono': telefono})
response = self.client.get(url, follow=True)
contacto_form = response.context_data['contacto_form']
datos_contacto_form = set(contacto_form.initial.values())
self.assertEqual(datos_contacto_form, set([telefono]))
def test_ocultar_opciones_de_calificacion(self):
contacto = self.contacto
telefono = contacto.telefono
url = reverse('calificar_por_telefono',
kwargs={'pk_campana': self.campana.pk, 'telefono': telefono})
response = self.client.get(url, follow=True)
opciones_form = response.context_data['form']
choices = [x for x in opciones_form.fields['opcion_calificacion'].choices]
# Controlo que estén todas las opciones
self.assertEqual(len(choices), self.campana.opciones_calificacion.count() + 1)
opcion = self.opcion_calificacion_no_accion
self.assertIn((opcion.id, opcion.nombre), choices)
opcion.oculta = True
opcion.save()
response = self.client.get(url, follow=True)
opciones_form = response.context_data['form']
choices = [x for x in opciones_form.fields['opcion_calificacion'].choices]
# Controlo que no este la opción oculta
self.assertEqual(len(choices), self.campana.opciones_calificacion.count())
self.assertNotIn((opcion.id, opcion.nombre), choices)
def test_no_ocultar_opciones_de_calificacion_oculta_si_corresponde_a_la_calificacion(self):
contacto = self.contacto
telefono = contacto.telefono
url = reverse('calificar_por_telefono',
kwargs={'pk_campana': self.campana.pk, 'telefono': telefono})
response = self.client.get(url, follow=True)
opciones_form = response.context_data['form']
choices = [x for x in opciones_form.fields['opcion_calificacion'].choices]
# Controlo que estén todas las opciones
self.assertEqual(len(choices), self.campana.opciones_calificacion.count() + 1)
opcion = self.calificacion_cliente.opcion_calificacion
self.assertIn((opcion.id, opcion.nombre), choices)
opcion.oculta = True
opcion.save()
response = self.client.get(url, follow=True)
opciones_form = response.context_data['form']
# Controlo que estén todas las opciones
choices = [x for x in opciones_form.fields['opcion_calificacion'].choices]
self.assertEqual(len(choices), self.campana.opciones_calificacion.count() + 1)
self.assertIn((opcion.id, opcion.nombre), choices)
def test_llamada_manual_telefono_con_1_contacto_muestra_datos_contacto_formulario(self):
contacto = self.contacto
telefono = contacto.telefono
url = reverse('calificar_por_telefono',
kwargs={'pk_campana': self.campana.pk,
'telefono': telefono})
response = self.client.get(url, follow=True)
contacto_form = response.context_data['contacto_form']
datos_contacto_form = set(contacto_form.initial.values())
datos_contacto_model = set(json.loads(contacto.datos) + [str(telefono)])
datos_contacto_model.add(contacto.id_externo)
self.assertEqual(datos_contacto_form, datos_contacto_model)
def test_llamada_manual_telefono_con_n_contactos_redirecciona_vista_escoger_contacto(self):
contacto = self.contacto
ContactoFactory(bd_contacto=self.campana.bd_contacto, telefono=contacto.telefono)
telefono = contacto.telefono
url = reverse('calificar_por_telefono',
kwargs={'pk_campana': self.campana.pk,
'telefono': telefono})
response = self.client.get(url, follow=True)
self.assertTemplateUsed(response, 'agente/contactos_telefonos_repetidos.html')
def test_muestra_nombre_campana(self):
url = reverse('calificar_por_telefono',
kwargs={'pk_campana': self.campana.pk,
'telefono': '351111111111'})
response = self.client.get(url, follow=True)
self.assertContains(response, self.campana.nombre)
def test_oculta_nombre_campana(self):
self.campana.mostrar_nombre = False
self.campana.save()
url = reverse('calificar_por_telefono',
kwargs={'pk_campana': self.campana.pk,
'telefono': '351111111111'})
response = self.client.get(url, follow=True)
self.assertNotContains(response, self.campana.nombre)
def get_call_data(self):
call_data = {"id_campana": self.campana.id,
"campana_type": self.campana.type,
"telefono": "3512349992",
"call_id": '123456789',
"call_type": "4",
"id_contacto": self.contacto.id,
"rec_filename": "",
"call_wait_duration": ""}
return call_data
def test_muestra_link_sitio_externo(self):
self.campana.type = Campana.TYPE_PREVIEW
self.campana.tipo_interaccion = Campana.SITIO_EXTERNO
sitio_externo = SitioExternoFactory()
self.campana.sitio_externo = sitio_externo
self.campana.save()
parametro1 = ParametrosCrmFactory(campana=self.campana)
call_data = self.get_call_data()
url = reverse('calificar_llamada', kwargs={'call_data_json': json.dumps(call_data)})
response = self.client.get(url)
self.assertContains(response, sitio_externo.url)
self.assertContains(response, '"%s": "%s"' % (parametro1.nombre, parametro1.valor))
def test_redirecciona_a_sitio_externo(self):
self.campana.type = Campana.TYPE_PREVIEW
self.campana.tipo_interaccion = Campana.SITIO_EXTERNO
sitio_externo = SitioExternoFactory(disparador=SitioExterno.AUTOMATICO,
metodo=SitioExterno.GET,
objetivo=SitioExterno.EMBEBIDO)
self.campana.sitio_externo = sitio_externo
self.campana.save()
parametro1 = ParametrosCrmFactory(campana=self.campana)
call_data = self.get_call_data()
url = reverse('calificar_llamada', kwargs={'call_data_json': json.dumps(call_data)})
response = self.client.get(url, follow=False)
self.assertEqual(response.status_code, 302)
param_1 = '%s=%s' % (parametro1.nombre, parametro1.valor)
equal_url = (response.url == '%s?%s' % (sitio_externo.url, param_1))
self.assertTrue(equal_url)
@patch('requests.get')
def test_hace_peticion_sitio_externo_en_servidor(self, request_get):
self.campana.type = Campana.TYPE_PREVIEW
self.campana.tipo_interaccion = Campana.SITIO_EXTERNO
sitio_externo = SitioExternoFactory(disparador=SitioExterno.SERVER,
metodo=SitioExterno.GET,
objetivo=None, formato=None)
self.campana.sitio_externo = sitio_externo
self.campana.save()
ParametrosCrmFactory(campana=self.campana)
call_data = self.get_call_data()
url = reverse('calificar_llamada', kwargs={'call_data_json': json.dumps(call_data)})
self.client.get(url)
parametros = sitio_externo.get_parametros(self.agente_profile,
self.campana,
self.contacto,
call_data)
request_get.assert_called_with(sitio_externo.url, params=parametros)
def test_se_muestra_historico_calificaciones_contacto_llamada_entrante(self):
self.campana.type = Campana.TYPE_ENTRANTE
self.campana.save()
observacion_anterior = self.calificacion_cliente.observaciones
self.calificacion_cliente.observaciones = "NUEVA OBSERVACION"
self.calificacion_cliente.save()
call_data = self.get_call_data()
call_data["call_type"] = str(self.campana.type)
url = reverse('calificar_llamada', kwargs={'call_data_json': json.dumps(call_data)})
response = self.client.get(url)
self.assertContains(response, observacion_anterior)
def test_no_se_muestra_historico_calificaciones_contacto_llamada_no_entrante(self):
self.campana.type = Campana.TYPE_PREVIEW
self.campana.save()
observacion_anterior = self.calificacion_cliente.observaciones
self.calificacion_cliente.observaciones = "NUEVA OBSERVACION"
self.calificacion_cliente.save()
call_data = self.get_call_data()
call_data["call_type"] = str(self.campana.type)
url = reverse('calificar_llamada', kwargs={'call_data_json': json.dumps(call_data)})
response = self.client.get(url)
self.assertNotContains(response, observacion_anterior)
def test_llamada_entrante_con_numero_privado_inicializa_nuevo_contacto(self):
self.campana.type = Campana.TYPE_ENTRANTE
self.campana.save()
call_id = "123456789.34"
telefono = "NUMERO PRIVADO"
call_data = self.get_call_data()
call_data["telefono"] = str(telefono)
call_data["call_id"] = call_id
call_data["call_type"] = str(self.campana.type)
url = reverse('calificar_llamada', kwargs={'call_data_json': json.dumps(call_data)})
response = self.client.get(url)
contacto_form = response.context_data['contacto_form']
self.assertEqual(contacto_form.instance.pk, None)
def test_metodo_contactos_no_calificados_devuelve_valores_correctos(self):
contactos_no_calificados_count = self.campana.obtener_contactos_no_calificados().count()
self.assertEqual(contactos_no_calificados_count, 0)
def test_calificacion_cliente_cambio_a_no_agenda_elimina_agendas__globales_existentes(self):
self.calificacion_cliente.opcion_calificacion = self.opcion_calificacion_agenda
self.calificacion_cliente.save()
AgendaContactoFactory(
agente=self.agente_profile, contacto=self.contacto, campana=self.campana,
tipo_agenda=AgendaContacto.TYPE_PERSONAL)
self.assertTrue(AgendaContacto.objects.exists())
self.calificacion_cliente.opcion_calificacion = self.opcion_calificacion_no_accion
self.calificacion_cliente.save()
self.assertFalse(AgendaContacto.objects.exists())
def test_calificacion_cliente_cambio_a_no_agenda_no_elimina_agendas_personales_existentes(self):
self.calificacion_cliente.opcion_calificacion = self.opcion_calificacion_agenda
self.calificacion_cliente.save()
AgendaContactoFactory(
agente=self.agente_profile, contacto=self.contacto, campana=self.campana,
tipo_agenda=AgendaContacto.TYPE_GLOBAL)
self.assertTrue(AgendaContacto.objects.exists())
self.calificacion_cliente.opcion_calificacion = self.opcion_calificacion_no_accion
self.calificacion_cliente.save()
self.assertTrue(AgendaContacto.objects.exists())
def test_vista_calificar_contacto_muestra_botones_click2call(self):
url = reverse('calificacion_formulario_update_or_create',
kwargs={'pk_campana': self.campana.pk,
'pk_contacto': self.contacto.pk})
response = self.client.get(url)
self.assertTemplateUsed(response, 'formulario/calificacion_create_update_agente.html')
click2call = "makeClick2Call('%s', '%s', '%s', '%s', 'agendas')" % \
(self.campana.id, self.campana.type, self.contacto.id, self.contacto.telefono)
self.assertContains(response, click2call)
bd_metadata = self.contacto.bd_contacto.get_metadata()
campos_telefono = bd_metadata.nombres_de_columnas_de_telefonos
datos_contacto = self.contacto.obtener_datos()
for campo_telefono in campos_telefono:
telefono = datos_contacto[campo_telefono]
click2call = "makeClick2Call('%s', '%s', '%s', '%s', 'agendas')" % \
(self.campana.id, self.campana.type, self.contacto.id, telefono)
self.assertContains(response, click2call)
def test_no_se_admite_mas_de_una_calificacion_para_un_contacto_en_una_campana_creacion(self):
opcion_calificacion = self.calificacion_cliente.opcion_calificacion
contacto = self.contacto
self.assertRaises(ValidationError, lambda: CalificacionClienteFactory(
opcion_calificacion=opcion_calificacion, contacto=contacto))
def test_no_se_admite_mas_de_una_calificacion_para_un_contacto_en_una_campana_modificacion(
self):
def modificar_calificacion():
calificacion = CalificacionClienteFactory(
opcion_calificacion=self.opcion_calificacion_no_accion)
calificacion.contacto = self.contacto
calificacion.save()
self.assertRaises(ValidationError, modificar_calificacion)
def test_no_permitir_eliminar_calificacion_agenda_por_url(self):
url = reverse('calificacion_delete', kwargs={'pk': 1})
response = self.client.get(url, follow=True)
self.assertEqual(response.status_code, 403)
@patch('api_app.services.calificacion_llamada.CalificacionLLamada.create_family')
def test_campana_fuerza_calificar_llamada_impacta_en_redis_get(self, create_family):
self.campana.type = Campana.TYPE_MANUAL
call_data = self.get_call_data()
call_data['force_disposition'] = True
call_data_json = json.dumps(call_data)
url = reverse('calificar_llamada', kwargs={'call_data_json': call_data_json})
self.client.get(url)
create_family.assert_called_with(self.agente_profile, call_data, call_data_json,
calificado=False, gestion=False, id_calificacion=None)
@patch('api_app.services.calificacion_llamada.CalificacionLLamada.create_family')
def test_campana_fuerza_calificar_llamada_impacta_en_redis_post(self, create_family):
self.campana.type = Campana.TYPE_MANUAL
call_data = self.get_call_data()
call_data['force_disposition'] = True
call_data_json = json.dumps(call_data)
url = reverse('calificar_llamada', kwargs={'call_data_json': call_data_json})
post_data = self._obtener_post_data_calificacion_cliente()
post_data['opcion_calificacion'] = self.opcion_calificacion_no_accion.pk
self.client.post(url, post_data, follow=True)
create_family.assert_called_with(self.agente_profile, call_data, call_data_json,
calificado=True, gestion=False, id_calificacion=None)
class CalificacionTests(OMLBaseTest):
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 test_filtrar_por_agente(self):
url = reverse('agenda_contactos_por_campana',
kwargs={'pk_campana': self.campana.id})
response = self.client.get(url, follow=True)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.redirect_chain, [])
self.assertContains(response, self.agente_1.user.get_full_name())
self.assertContains(response, self.agente_2.user.get_full_name())
self.assertNotContains(response, self.agente_3.user.get_full_name())
self.assertContains(response, self.contacto_1.telefono)
self.assertContains(response, self.contacto_2.telefono)
fecha = self.agenda_1.fecha.strftime('%d/%m/%Y - %d/%m/%Y')
response = self.client.post(url,
data={
'fecha': fecha,
'usuario': self.agente_1.user.id
})
self.assertEqual(response.status_code, 200)
self.assertContains(response, self.contacto_1.telefono)
self.assertNotContains(response, self.contacto_2.telefono)
def test_reasignar_agente(self):
url = reverse('api_reasignar_agenda_contacto')
response = self.client.post(url,
data={
'agenda_id': self.agenda_1.id,
'agent_id': self.agente_2.id
})
self.assertEqual(response.status_code, 200)
response_json = response.json()
self.assertEqual(response_json['status'], 'OK')
self.assertEqual(response_json['agenda_id'], str(self.agenda_1.id))
self.assertEqual(response_json['agent_name'],
self.agente_2.user.get_full_name())
self.agenda_1.refresh_from_db()
self.assertEqual(self.agenda_1.agente, self.agente_2)
self.calificacion_1.refresh_from_db()
self.assertEqual(self.calificacion_1.agente, self.agente_2)