Ejemplo n.º 1
0
    def test_genera_entrante_incompleta(self):
        generador = GeneradorDeLlamadaLogs()
        generador.generar_log(self.entrante,
                              False,
                              'ABANDON',
                              '123',
                              self.agente1,
                              bridge_wait_time=5)
        logs_generados = LlamadaLog.objects.filter(campana_id=self.entrante.id)
        eventos_esperados = set(('ENTERQUEUE', 'ABANDON'))
        self.assertEqual(self.set_de_eventos(logs_generados),
                         eventos_esperados)

        enterqueue = logs_generados.get(event='ENTERQUEUE')
        self.assertEqual(enterqueue.campana_id, self.entrante.id)
        self.assertEqual(enterqueue.tipo_campana, self.entrante.type)
        self.assertEqual(enterqueue.tipo_llamada, self.entrante.type)
        self.assertEqual(enterqueue.contacto_id, -1)
        self.assertEqual(enterqueue.agente_id, -1)
        self.assertEqual(enterqueue.bridge_wait_time, -1)
        self.assertEqual(enterqueue.duracion_llamada, -1)
        self.assertEqual(enterqueue.archivo_grabacion, '')

        abandon = logs_generados.get(event='ABANDON')
        self.assertEqual(abandon.campana_id, self.entrante.id)
        self.assertEqual(abandon.tipo_campana, self.entrante.type)
        self.assertEqual(abandon.tipo_llamada, self.entrante.type)
        self.assertEqual(abandon.contacto_id, -1)
        self.assertEqual(abandon.agente_id, -1)
        self.assertEqual(abandon.bridge_wait_time, 5)
        self.assertEqual(abandon.duracion_llamada, -1)
        self.assertEqual(abandon.archivo_grabacion, '')
Ejemplo n.º 2
0
    def test_devuelve_correctamente_no_contactacion(self):
        """
        este test testea todos los resultados las cantidad de los no
        contactdos chequeando que devuelva correctamente
        """
        contactos = self.campana.bd_contacto.contactos.all()
        generador = GeneradorDeLlamadaLogs()
        cant_llamados = 100
        for _ in range(0, cant_llamados):
            contacto = random.choice(contactos)
            estado = random.choice(self.estados)
            generador.generar_log(self.campana, False, estado,
                                  contacto.telefono, self.agente, contacto)

        cantidades = {}
        for estado in self.estados:
            cantidades[EstadisticasContactacion.MAP_ESTADO_ID[estado]] = 0

        no_llamados = cant_llamados
        for contacto in contactos:
            logs = LlamadaLog.objects.filter(
                contacto_id=contacto.id).order_by('-id')
            if logs:
                log = logs[0]
                self.assertIn(log.event, self.estados)
                cantidades[EstadisticasContactacion.MAP_ESTADO_ID[
                    log.event]] += 1
                no_llamados -= 1

        estadisticas = EstadisticasContactacion()
        no_contactados = estadisticas.obtener_cantidad_no_contactados(
            self.campana)
        for key, value in no_contactados.items():
            self.assertEqual(cantidades[key], value.cantidad)
Ejemplo n.º 3
0
    def test_genera_preview_incompleta(self):
        generador = GeneradorDeLlamadaLogs()
        generador.generar_log(self.preview,
                              False,
                              'BUSY',
                              '123',
                              self.agente1,
                              self.contacto_p,
                              bridge_wait_time=5)
        logs_generados = LlamadaLog.objects.filter(campana_id=self.preview.id)
        eventos_esperados = set(('DIAL', 'BUSY'))
        self.assertEqual(self.set_de_eventos(logs_generados),
                         eventos_esperados)

        dial = logs_generados.get(event='DIAL')
        self.assertEqual(dial.campana_id, self.preview.id)
        self.assertEqual(dial.tipo_campana, self.preview.type)
        self.assertEqual(dial.tipo_llamada, self.preview.type)
        self.assertEqual(dial.agente_id, self.agente1.id)

        busy = logs_generados.get(event='BUSY')
        self.assertEqual(busy.campana_id, self.preview.id)
        self.assertEqual(busy.tipo_campana, self.preview.type)
        self.assertEqual(busy.tipo_llamada, self.preview.type)
        self.assertEqual(busy.bridge_wait_time, 5)
Ejemplo n.º 4
0
    def test_genera_dialer_manual_incompleta(self):
        generador = GeneradorDeLlamadaLogs()
        generador.generar_log(self.dialer,
                              True,
                              'BUSY',
                              '123',
                              self.agente1,
                              bridge_wait_time=5)
        logs_generados = LlamadaLog.objects.filter(campana_id=self.dialer.id)
        eventos_esperados = set(('DIAL', 'BUSY'))
        self.assertEqual(self.set_de_eventos(logs_generados),
                         eventos_esperados)

        dial = logs_generados.get(event='DIAL')
        self.assertEqual(dial.campana_id, self.dialer.id)
        self.assertEqual(dial.tipo_campana, self.dialer.type)
        self.assertEqual(dial.tipo_llamada, Campana.TYPE_MANUAL)
        self.assertEqual(dial.agente_id, self.agente1.id)

        busy = logs_generados.get(event='BUSY')
        self.assertEqual(busy.campana_id, self.dialer.id)
        self.assertEqual(busy.tipo_campana, self.dialer.type)
        self.assertEqual(busy.tipo_llamada, Campana.TYPE_MANUAL)
        self.assertEqual(busy.agente_id, self.agente1.id)
        self.assertEqual(busy.bridge_wait_time, 5)
    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 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()
     super(DashboardAgenteTests, self).setUp()
     self.agente_profile = self.crear_agente_profile()
     self.campana_activa = CampanaFactory.create(
         estado=Campana.ESTADO_ACTIVA, type=Campana.TYPE_PREVIEW)
     self.generador = GeneradorDeLlamadaLogs()
Ejemplo n.º 7
0
    def _generar_llamadas_y_calificaciones(self, estados):
        contactos = self.campana.bd_contacto.contactos.all()
        opciones_calificacion = self.campana.opciones_calificacion.all()

        generador = GeneradorDeLlamadaLogs()
        for contacto in contactos:
            contactacion = random.choice([
                'contacta_califica', 'contacta_no_califica', 'no_contacta',
                'no_llama'
            ])

            if contactacion == 'contacta_califica':
                generador.generar_log(self.campana, False, 'COMPLETEOUTNUM',
                                      contacto.telefono, self.agente, contacto,
                                      1, 1)
                opcion_calificacion = random.choice(opciones_calificacion)
                self.crear_calificacion_cliente(self.agente, contacto,
                                                opcion_calificacion)
            if contactacion == 'contacta_no_califica':
                generador.generar_log(self.campana, False, 'COMPLETEOUTNUM',
                                      contacto.telefono, self.agente, contacto,
                                      1, 1)
            if contactacion == 'no_contacta':
                estado = random.choice(estados)
                generador.generar_log(self.campana, False, estado,
                                      contacto.telefono, None, contacto)
            if contactacion == 'no_llama':
                pass
Ejemplo n.º 8
0
 def test_obtiene_contactos_no_llamados_campana_activas(self):
     reciclador = RecicladorContactosCampanaDIALER()
     contactos = self.campana_2.bd_contacto.contactos.all()
     generador = GeneradorDeLlamadaLogs()
     cant_llamados = 20
     # Al ser una campana activa puede haber contactos no llamados, por lo tanto
     # solo llamamos a 20 de 100 contactos
     for i in range(0, cant_llamados):
         contacto = contactos[i]
         estado = random.choice(self.estados)
         generador.generar_log(self.campana_2, False, estado,
                               contacto.telefono, None, contacto)
     contactos_no_llamados = reciclador._obtener_contactos_no_llamados(
         self.campana_2)
     self.assertEqual(len(contactos_no_llamados), 80)
Ejemplo n.º 9
0
    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)
Ejemplo n.º 10
0
 def generar_llamadas(self, nro_llamadas):
     self.crear_agentes()
     self.crear_campanas()
     generador = GeneradorDeLlamadaLogs()
     for i in range(nro_llamadas):
         try:
             self.llamada_aleatoria(generador)
         except Exception as e:
             raise CommandError('Fallo del comando: {0}'.format(e.message))
Ejemplo n.º 11
0
    def test_genera_entrante_completa(self):
        generador = GeneradorDeLlamadaLogs()
        generador.generar_log(self.entrante,
                              False,
                              'COMPLETEAGENT',
                              '123',
                              self.agente1,
                              bridge_wait_time=5,
                              duracion_llamada=44,
                              archivo_grabacion='archi')
        logs_generados = LlamadaLog.objects.filter(campana_id=self.entrante.id)
        eventos_esperados = set(('ENTERQUEUE', 'CONNECT', 'COMPLETEAGENT'))
        self.assertEqual(self.set_de_eventos(logs_generados),
                         eventos_esperados)

        enterqueue = logs_generados.get(event='ENTERQUEUE')
        self.assertEqual(enterqueue.campana_id, self.entrante.id)
        self.assertEqual(enterqueue.tipo_campana, self.entrante.type)
        self.assertEqual(enterqueue.tipo_llamada, self.entrante.type)
        self.assertEqual(enterqueue.contacto_id, -1)
        self.assertEqual(enterqueue.agente_id, -1)
        self.assertEqual(enterqueue.bridge_wait_time, -1)
        self.assertEqual(enterqueue.duracion_llamada, -1)
        self.assertEqual(enterqueue.archivo_grabacion, '')

        connect = logs_generados.get(event='CONNECT')
        self.assertEqual(connect.campana_id, self.entrante.id)
        self.assertEqual(connect.tipo_campana, self.entrante.type)
        self.assertEqual(connect.tipo_llamada, self.entrante.type)
        self.assertEqual(connect.agente_id, self.agente1.id)
        self.assertEqual(connect.contacto_id, -1)
        self.assertEqual(connect.bridge_wait_time, 5)
        self.assertEqual(connect.duracion_llamada, -1)
        self.assertEqual(connect.archivo_grabacion, '')

        complete = logs_generados.get(event='COMPLETEAGENT')
        self.assertEqual(complete.campana_id, self.entrante.id)
        self.assertEqual(complete.tipo_campana, self.entrante.type)
        self.assertEqual(complete.tipo_llamada, self.entrante.type)
        self.assertEqual(complete.agente_id, self.agente1.id)
        self.assertEqual(complete.contacto_id, -1)
        self.assertEqual(complete.bridge_wait_time, 5)
        self.assertEqual(complete.duracion_llamada, 44)
        self.assertEqual(complete.archivo_grabacion, 'archi')
    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)
Ejemplo n.º 13
0
    def test_genera_preview_completa(self):
        generador = GeneradorDeLlamadaLogs()
        generador.generar_log(self.preview,
                              False,
                              'COMPLETEAGENT',
                              '123',
                              self.agente1,
                              self.contacto_p,
                              bridge_wait_time=5,
                              duracion_llamada=44,
                              archivo_grabacion='archi')
        logs_generados = LlamadaLog.objects.filter(campana_id=self.preview.id)
        eventos_esperados = set(('DIAL', 'ANSWER', 'COMPLETEAGENT'))
        self.assertEqual(self.set_de_eventos(logs_generados),
                         eventos_esperados)

        dial = logs_generados.get(event='DIAL')
        self.assertEqual(dial.campana_id, self.preview.id)
        self.assertEqual(dial.tipo_campana, self.preview.type)
        self.assertEqual(dial.tipo_llamada, self.preview.type)
        self.assertEqual(dial.agente_id, self.agente1.id)
        self.assertEqual(dial.contacto_id, self.contacto_p.id)

        answer = logs_generados.get(event='ANSWER')
        self.assertEqual(answer.campana_id, self.preview.id)
        self.assertEqual(answer.tipo_campana, self.preview.type)
        self.assertEqual(answer.tipo_llamada, self.preview.type)
        self.assertEqual(answer.agente_id, self.agente1.id)
        self.assertEqual(answer.contacto_id, self.contacto_p.id)
        self.assertEqual(answer.bridge_wait_time, 5)

        complete = logs_generados.get(event='COMPLETEAGENT')
        self.assertEqual(complete.campana_id, self.preview.id)
        self.assertEqual(complete.tipo_campana, self.preview.type)
        self.assertEqual(complete.tipo_llamada, self.preview.type)
        self.assertEqual(complete.agente_id, self.agente1.id)
        self.assertEqual(complete.contacto_id, self.contacto_p.id)
        self.assertEqual(complete.bridge_wait_time, 5)
        self.assertEqual(complete.duracion_llamada, 44)
        self.assertEqual(complete.archivo_grabacion, 'archi')
Ejemplo n.º 14
0
    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)
Ejemplo n.º 15
0
    def test_llamadas_de_tipo_por_fecha(self):
        tipo = str(Campana.TYPE_ENTRANTE)
        campana = self.entrante
        generador = GeneradorDeLlamadaLogs()
        for i in range(5):
            generador.generar_log(campana,
                                  False,
                                  'COMPLETEOUTNUM',
                                  '123',
                                  self.agente1,
                                  bridge_wait_time=4,
                                  time=self.durante)
        for i in range(3):
            generador.generar_log(campana,
                                  False,
                                  'COMPLETEAGENT',
                                  '123',
                                  self.agente1,
                                  bridge_wait_time=6)

        str_ayer = self.durante.strftime('%d-%m-%Y')
        str_hoy = self.hasta.strftime('%d-%m-%Y')

        self.hasta = fecha_hora_local(now())
        reporte = ReporteDeLlamadas(self.desde, self.hasta, True,
                                    self.supervisor.user)
        self.assertIn(tipo,
                      reporte.estadisticas_por_fecha['llamadas_por_tipo'])
        self.assertIn(
            str_ayer,
            reporte.estadisticas_por_fecha['llamadas_por_tipo'][tipo])
        self.assertIn(
            str_hoy, reporte.estadisticas_por_fecha['llamadas_por_tipo'][tipo])
        datos_ayer = reporte.estadisticas_por_fecha['llamadas_por_tipo'][tipo][
            str_ayer]
        datos_hoy = reporte.estadisticas_por_fecha['llamadas_por_tipo'][tipo][
            str_hoy]
        self.assertEqual(datos_ayer['atendidas'], 5)
        self.assertEqual(datos_ayer['total'], 5)
        self.assertEqual(datos_hoy['atendidas'], 3)
        self.assertEqual(datos_hoy['total'], 3)

        self.assertIn(
            tipo,
            reporte.estadisticas_por_fecha['tipos_de_llamada_por_campana'])
        tipos_por_campana = reporte.estadisticas_por_fecha[
            'tipos_de_llamada_por_campana'][tipo]
        self.assertIn(str_ayer, tipos_por_campana[self.entrante.id])
        self.assertIn(str_hoy, tipos_por_campana[self.entrante.id])
        datos_ayer = tipos_por_campana[self.entrante.id][str_ayer]
        datos_hoy = tipos_por_campana[self.entrante.id][str_hoy]
        self.assertEqual(datos_ayer['atendidas'], 5)
        self.assertEqual(datos_ayer['recibidas'], 5)
        self.assertEqual(datos_ayer['t_espera_conexion'], 4)
        self.assertEqual(datos_hoy['atendidas'], 3)
        self.assertEqual(datos_hoy['recibidas'], 3)
        self.assertEqual(datos_hoy['t_espera_conexion'], 6)
Ejemplo n.º 16
0
    def test_genera_dialer_manual_completa(self):
        generador = GeneradorDeLlamadaLogs()
        generador.generar_log(self.dialer,
                              True,
                              'COMPLETEOUTNUM',
                              '123',
                              self.agente1,
                              bridge_wait_time=5,
                              duracion_llamada=44,
                              archivo_grabacion='archi')
        logs_generados = LlamadaLog.objects.filter(campana_id=self.dialer.id)
        eventos_esperados = set(('DIAL', 'ANSWER', 'COMPLETEOUTNUM'))
        self.assertEqual(self.set_de_eventos(logs_generados),
                         eventos_esperados)

        dial = logs_generados.get(event='DIAL')
        self.assertEqual(dial.campana_id, self.dialer.id)
        self.assertEqual(dial.tipo_campana, self.dialer.type)
        self.assertEqual(dial.tipo_llamada, Campana.TYPE_MANUAL)
        self.assertEqual(dial.agente_id, self.agente1.id)

        answer = logs_generados.get(event='ANSWER')
        self.assertEqual(answer.campana_id, self.dialer.id)
        self.assertEqual(answer.tipo_campana, self.dialer.type)
        self.assertEqual(answer.tipo_llamada, Campana.TYPE_MANUAL)
        self.assertEqual(answer.agente_id, self.agente1.id)
        self.assertEqual(answer.bridge_wait_time, 5)

        complete = logs_generados.get(event='COMPLETEOUTNUM')
        self.assertEqual(complete.campana_id, self.dialer.id)
        self.assertEqual(complete.tipo_campana, self.dialer.type)
        self.assertEqual(complete.tipo_llamada, Campana.TYPE_MANUAL)
        self.assertEqual(complete.agente_id, self.agente1.id)
        self.assertEqual(complete.bridge_wait_time, 5)
        self.assertEqual(complete.duracion_llamada, 44)
        self.assertEqual(complete.archivo_grabacion, 'archi')
Ejemplo n.º 17
0
    def test_incremental_llamada_preview(self):
        tipo = str(Campana.TYPE_PREVIEW)
        campana = self.preview
        generador = GeneradorDeLlamadaLogs()

        # Genero una llamada preview que termina en BUSY
        generador.generar_log(campana,
                              False,
                              'BUSY',
                              '123',
                              self.agente1,
                              bridge_wait_time=5)
        self.hasta = now()
        reporte = ReporteDeLlamadas(self.desde, self.hasta, True,
                                    self.supervisor.user)
        estadisticas = reporte.estadisticas

        self.assertEqual(estadisticas['total_llamadas_procesadas'], 1)
        por_tipo = estadisticas['llamadas_por_tipo'][tipo]
        self.assertEqual(por_tipo['total'], 1)
        self.assertEqual(por_tipo['conectadas'], 0)
        self.assertEqual(por_tipo['no_conectadas'], 1)
        llamadas = estadisticas['llamadas_por_campana'][campana.id]
        self.assertEqual(llamadas['total'], 1)
        self.assertEqual(llamadas['manuales'], 0)
        tipos = estadisticas['tipos_de_llamada_por_campana'][tipo]
        self.assertEqual(tipos[campana.id]['t_espera_conexion'], 5)
        self.assertEqual(tipos[campana.id]['efectuadas'], 1)
        self.assertEqual(tipos[campana.id]['conectadas'], 0)
        self.assertEqual(tipos[campana.id]['no_conectadas'], 1)

        # Genero una llamada preview que termina en COMPLETEAGENT y otra en COMPLETEOUTNUM
        generador.generar_log(campana,
                              False,
                              'COMPLETEAGENT',
                              '1234',
                              self.agente1,
                              bridge_wait_time=4,
                              duracion_llamada=20)
        generador.generar_log(campana,
                              False,
                              'COMPLETEOUTNUM',
                              '1234',
                              self.agente1,
                              bridge_wait_time=6,
                              duracion_llamada=40)
        self.hasta = now()
        reporte = ReporteDeLlamadas(self.desde, self.hasta, True,
                                    self.supervisor.user)
        estadisticas = reporte.estadisticas

        self.assertEqual(estadisticas['total_llamadas_procesadas'], 3)
        por_tipo = estadisticas['llamadas_por_tipo'][tipo]
        self.assertEqual(por_tipo['total'], 3)
        self.assertEqual(por_tipo['conectadas'], 2)
        self.assertEqual(por_tipo['no_conectadas'], 1)
        llamadas = estadisticas['llamadas_por_campana'][campana.id]
        self.assertEqual(llamadas['total'], 3)
        self.assertEqual(llamadas['manuales'], 0)
        tipos = estadisticas['tipos_de_llamada_por_campana'][tipo]
        self.assertEqual(tipos[campana.id]['t_espera_conexion'], 5)
        self.assertEqual(tipos[campana.id]['efectuadas'], 3)
        self.assertEqual(tipos[campana.id]['conectadas'], 2)
        self.assertEqual(tipos[campana.id]['no_conectadas'], 1)

        # Genero llamadas preview manuales que terminan en BUSY y en COMPLETEOUTNUM
        generador.generar_log(campana,
                              True,
                              'BUSY',
                              '1234',
                              self.agente1,
                              bridge_wait_time=4)
        generador.generar_log(campana,
                              True,
                              'COMPLETEOUTNUM',
                              '1234',
                              self.agente1,
                              bridge_wait_time=8,
                              duracion_llamada=40)
        self.hasta = now()
        reporte = ReporteDeLlamadas(self.desde, self.hasta, True,
                                    self.supervisor.user)
        estadisticas = reporte.estadisticas

        self.assertEqual(estadisticas['total_llamadas_procesadas'], 5)
        por_tipo_preview = estadisticas['llamadas_por_tipo'][tipo]
        self.assertEqual(por_tipo_preview['total'], 3)
        self.assertEqual(por_tipo_preview['conectadas'], 2)
        self.assertEqual(por_tipo_preview['no_conectadas'], 1)
        por_tipo_manual = estadisticas['llamadas_por_tipo'][str(
            Campana.TYPE_MANUAL)]
        self.assertEqual(por_tipo_manual['total'], 2)
        self.assertEqual(por_tipo_manual['conectadas'], 1)
        self.assertEqual(por_tipo_manual['no_conectadas'], 1)
        llamadas = estadisticas['llamadas_por_campana'][campana.id]
        self.assertEqual(llamadas['total'], 5)
        self.assertEqual(llamadas['manuales'], 2)
        tipos = estadisticas['tipos_de_llamada_por_campana'][tipo]
        self.assertEqual(tipos[campana.id]['t_espera_conexion'], 5.4)
        self.assertEqual(tipos[campana.id]['efectuadas'], 5)
        self.assertEqual(tipos[campana.id]['conectadas'], 3)
        self.assertEqual(tipos[campana.id]['no_conectadas'], 2)
        self.assertEqual(tipos[campana.id]['efectuadas_manuales'], 2)
        self.assertEqual(tipos[campana.id]['conectadas_manuales'], 1)
        self.assertEqual(tipos[campana.id]['no_conectadas_manuales'], 1)
        self.assertEqual(tipos[campana.id]['t_espera_conexion_manuales'], 6)
Ejemplo n.º 18
0
    def test_incremental_llamada_entrante(self):
        tipo = str(Campana.TYPE_ENTRANTE)
        campana = self.entrante
        generador = GeneradorDeLlamadaLogs()

        # Genero una llamada ENTRANTE que termina en ABANDON
        generador.generar_log(campana,
                              False,
                              'ABANDON',
                              '123',
                              self.agente1,
                              bridge_wait_time=5)
        self.hasta = now()
        reporte = ReporteDeLlamadas(self.desde, self.hasta, True,
                                    self.supervisor.user)
        estadisticas = reporte.estadisticas

        self.assertEqual(estadisticas['total_llamadas_procesadas'], 1)
        por_tipo = estadisticas['llamadas_por_tipo'][tipo]
        self.assertEqual(por_tipo['total'], 1)
        self.assertEqual(por_tipo['atendidas'], 0)
        self.assertEqual(por_tipo['expiradas'], 0)
        self.assertEqual(por_tipo['abandonadas'], 1)
        llamadas = estadisticas['llamadas_por_campana'][campana.id]
        self.assertEqual(llamadas['total'], 1)
        self.assertEqual(llamadas['manuales'], 0)
        tipos = estadisticas['tipos_de_llamada_por_campana'][tipo]
        self.assertEqual(tipos[campana.id]['recibidas'], 1)
        self.assertEqual(tipos[campana.id]['atendidas'], 0)
        self.assertEqual(tipos[campana.id]['expiradas'], 0)
        self.assertEqual(tipos[campana.id]['abandonadas'], 1)
        self.assertEqual(tipos[campana.id]['t_espera_conexion'], 0)
        self.assertEqual(tipos[campana.id]['t_abandono'], 5)

        # Genero una llamada ENTRANTE que termina en EXITWITHTIMEOUT
        generador.generar_log(campana,
                              False,
                              'EXITWITHTIMEOUT',
                              '123',
                              self.agente1,
                              bridge_wait_time=6)
        self.hasta = now()
        reporte = ReporteDeLlamadas(self.desde, self.hasta, True,
                                    self.supervisor.user)
        estadisticas = reporte.estadisticas

        self.assertEqual(estadisticas['total_llamadas_procesadas'], 2)
        por_tipo = estadisticas['llamadas_por_tipo'][tipo]
        self.assertEqual(por_tipo['total'], 2)
        self.assertEqual(por_tipo['atendidas'], 0)
        self.assertEqual(por_tipo['expiradas'], 1)
        self.assertEqual(por_tipo['abandonadas'], 1)
        llamadas = estadisticas['llamadas_por_campana'][campana.id]
        self.assertEqual(llamadas['total'], 2)
        self.assertEqual(llamadas['manuales'], 0)
        tipos = estadisticas['tipos_de_llamada_por_campana'][tipo]
        self.assertEqual(tipos[campana.id]['recibidas'], 2)
        self.assertEqual(tipos[campana.id]['atendidas'], 0)
        self.assertEqual(tipos[campana.id]['expiradas'], 1)
        self.assertEqual(tipos[campana.id]['abandonadas'], 1)
        self.assertEqual(tipos[campana.id]['t_espera_conexion'], 0)
        self.assertEqual(tipos[campana.id]['t_abandono'], 5)

        # Genero una llamada ENTRANTE que termina en COMPLETEOUTNUM
        generador.generar_log(campana,
                              False,
                              'COMPLETEOUTNUM',
                              '123',
                              self.agente1,
                              bridge_wait_time=7,
                              duracion_llamada=30)
        self.hasta = now()
        reporte = ReporteDeLlamadas(self.desde, self.hasta, True,
                                    self.supervisor.user)
        estadisticas = reporte.estadisticas

        self.assertEqual(estadisticas['total_llamadas_procesadas'], 3)
        por_tipo = estadisticas['llamadas_por_tipo'][tipo]
        self.assertEqual(por_tipo['total'], 3)
        self.assertEqual(por_tipo['atendidas'], 1)
        self.assertEqual(por_tipo['expiradas'], 1)
        self.assertEqual(por_tipo['abandonadas'], 1)
        llamadas = estadisticas['llamadas_por_campana'][campana.id]
        self.assertEqual(llamadas['total'], 3)
        self.assertEqual(llamadas['manuales'], 0)
        tipos = estadisticas['tipos_de_llamada_por_campana'][tipo]
        self.assertEqual(tipos[campana.id]['recibidas'], 3)
        self.assertEqual(tipos[campana.id]['atendidas'], 1)
        self.assertEqual(tipos[campana.id]['expiradas'], 1)
        self.assertEqual(tipos[campana.id]['abandonadas'], 1)
        self.assertEqual(tipos[campana.id]['t_espera_conexion'], 7)
        self.assertEqual(tipos[campana.id]['t_abandono'], 5)

        # Genero llamadas diaer manuales CANCEL, COMPLETEOUTNUM
        generador.generar_log(campana,
                              True,
                              'CANCEL',
                              '123',
                              self.agente1,
                              bridge_wait_time=5)
        generador.generar_log(campana,
                              True,
                              'COMPLETEOUTNUM',
                              '123',
                              self.agente1,
                              bridge_wait_time=7,
                              duracion_llamada=30)
        self.hasta = now()
        reporte = ReporteDeLlamadas(self.desde, self.hasta, True,
                                    self.supervisor.user)
        estadisticas = reporte.estadisticas

        por_tipo_entrante = estadisticas['llamadas_por_tipo'][tipo]
        self.assertEqual(por_tipo_entrante['total'], 3)
        self.assertEqual(por_tipo_entrante['atendidas'], 1)
        self.assertEqual(por_tipo_entrante['expiradas'], 1)
        self.assertEqual(por_tipo_entrante['abandonadas'], 1)
        por_tipo_manual = estadisticas['llamadas_por_tipo'][str(
            Campana.TYPE_MANUAL)]
        self.assertEqual(por_tipo_manual['total'], 2)
        self.assertEqual(por_tipo_manual['conectadas'], 1)
        self.assertEqual(por_tipo_manual['no_conectadas'], 1)
        llamadas = estadisticas['llamadas_por_campana'][campana.id]
        self.assertEqual(llamadas['total'], 5)
        self.assertEqual(llamadas['manuales'], 2)
        tipos = estadisticas['tipos_de_llamada_por_campana'][tipo]
        self.assertEqual(tipos[campana.id]['recibidas'], 3)
        self.assertEqual(tipos[campana.id]['atendidas'], 1)
        self.assertEqual(tipos[campana.id]['expiradas'], 1)
        self.assertEqual(tipos[campana.id]['abandonadas'], 1)
        self.assertEqual(tipos[campana.id]['t_espera_conexion'], 7)
        self.assertEqual(tipos[campana.id]['t_abandono'], 5)
        self.assertEqual(tipos[campana.id]['efectuadas_manuales'], 2)
        self.assertEqual(tipos[campana.id]['conectadas_manuales'], 1)
        self.assertEqual(tipos[campana.id]['no_conectadas_manuales'], 1)
        self.assertEqual(tipos[campana.id]['t_espera_conexion_manuales'], 6)
Ejemplo n.º 19
0
class ReporteDeLLamadasSalientesDeSupervisionTest(TestCase):
    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 test_reporte_vacio(self):
        reporte = ReporteDeLLamadasSalientesDeSupervision()
        for id_campana in [self.manual.id, self.dialer.id, self.preview.id]:
            self.assertNotIn(id_campana, reporte.estadisticas)
        self.assertNotIn(self.manual2.id, reporte.estadisticas)
        self.assertNotIn(self.dialer2.id, reporte.estadisticas)
        self.assertNotIn(self.preview2.id, reporte.estadisticas)

    def test_contabiliza_efectuadas_conectadas(self):
        self.generador.generar_log(self.manual,
                                   False,
                                   'COMPLETEAGENT',
                                   '35100001111',
                                   agente=self.agente1,
                                   contacto=None,
                                   bridge_wait_time=-1,
                                   duracion_llamada=10,
                                   archivo_grabacion='',
                                   time=None)
        self.generador.generar_log(self.preview,
                                   False,
                                   'COMPLETEAGENT',
                                   '35100001112',
                                   agente=self.agente1,
                                   contacto=None,
                                   bridge_wait_time=-1,
                                   duracion_llamada=10,
                                   archivo_grabacion='',
                                   time=None)
        self.generador.generar_log(self.preview,
                                   False,
                                   'COMPLETEAGENT',
                                   '35100001113',
                                   agente=self.agente1,
                                   contacto=None,
                                   bridge_wait_time=-1,
                                   duracion_llamada=10,
                                   archivo_grabacion='',
                                   time=None)
        # No contabiliza dialers
        self.generador.generar_log(self.dialer,
                                   True,
                                   'COMPLETEAGENT',
                                   '35100001113',
                                   agente=self.agente1,
                                   contacto=None,
                                   bridge_wait_time=-1,
                                   duracion_llamada=10,
                                   archivo_grabacion='',
                                   time=None)
        reporte = ReporteDeLLamadasSalientesDeSupervision()
        self.assertEqual(reporte.estadisticas[self.manual.id]['efectuadas'], 1)
        self.assertEqual(reporte.estadisticas[self.manual.id]['conectadas'], 1)
        self.assertEqual(reporte.estadisticas[self.manual.id]['no_conectadas'],
                         0)
        self.assertEqual(reporte.estadisticas[self.manual.id]['gestiones'], 0)
        self.assertEqual(reporte.estadisticas[self.preview.id]['efectuadas'],
                         2)
        self.assertEqual(reporte.estadisticas[self.preview.id]['conectadas'],
                         2)
        self.assertEqual(
            reporte.estadisticas[self.preview.id]['no_conectadas'], 0)
        self.assertEqual(reporte.estadisticas[self.preview.id]['gestiones'], 0)
        self.assertNotIn(self.dialer.id, reporte.estadisticas)

    def test_contabiliza_efectuadas_no_conectadas(self):
        self.generador.generar_log(self.manual,
                                   False,
                                   'BUSY',
                                   '35100001111',
                                   agente=self.agente1,
                                   contacto=None,
                                   bridge_wait_time=-1,
                                   duracion_llamada=10,
                                   archivo_grabacion='',
                                   time=None)
        self.generador.generar_log(self.preview,
                                   False,
                                   'NOANSWER',
                                   '35100001112',
                                   agente=self.agente1,
                                   contacto=None,
                                   bridge_wait_time=-1,
                                   duracion_llamada=10,
                                   archivo_grabacion='',
                                   time=None)
        self.generador.generar_log(self.preview,
                                   False,
                                   'BLACKLIST',
                                   '35100001113',
                                   agente=self.agente1,
                                   contacto=None,
                                   bridge_wait_time=-1,
                                   duracion_llamada=10,
                                   archivo_grabacion='',
                                   time=None)
        # No contabiliza Dialers
        self.generador.generar_log(self.dialer,
                                   True,
                                   'CONGESTION',
                                   '35100001113',
                                   agente=self.agente1,
                                   contacto=None,
                                   bridge_wait_time=-1,
                                   duracion_llamada=10,
                                   archivo_grabacion='',
                                   time=None)
        reporte = ReporteDeLLamadasSalientesDeSupervision()
        self.assertEqual(reporte.estadisticas[self.manual.id]['efectuadas'], 1)
        self.assertEqual(reporte.estadisticas[self.manual.id]['conectadas'], 0)
        self.assertEqual(reporte.estadisticas[self.manual.id]['no_conectadas'],
                         1)
        self.assertEqual(reporte.estadisticas[self.manual.id]['gestiones'], 0)
        self.assertEqual(reporte.estadisticas[self.preview.id]['efectuadas'],
                         2)
        self.assertEqual(reporte.estadisticas[self.preview.id]['conectadas'],
                         0)
        self.assertEqual(
            reporte.estadisticas[self.preview.id]['no_conectadas'], 2)
        self.assertEqual(reporte.estadisticas[self.preview.id]['gestiones'], 0)
        self.assertNotIn(self.dialer.id, reporte.estadisticas)

    def test_contabiliza_gestiones(self):
        CalificacionClienteFactory(
            opcion_calificacion=self.opcion_calificacion_m1,
            agente=self.agente1)
        CalificacionClienteFactory(
            opcion_calificacion=self.opcion_calificacion_p1,
            agente=self.agente1)
        CalificacionClienteFactory(
            opcion_calificacion=self.opcion_calificacion_d1,
            agente=self.agente1)
        reporte = ReporteDeLLamadasSalientesDeSupervision()
        self.assertNotIn(self.dialer.id, reporte.estadisticas)
        for id_campana in [self.manual.id, self.preview.id]:
            self.assertIn(id_campana, reporte.estadisticas)
            self.assertEqual(reporte.estadisticas[id_campana]['efectuadas'], 0)
            self.assertEqual(reporte.estadisticas[id_campana]['conectadas'], 0)
            self.assertEqual(reporte.estadisticas[id_campana]['no_conectadas'],
                             0)
            self.assertEqual(reporte.estadisticas[id_campana]['gestiones'], 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]))
class ReporteDeLLamadasEntrantesDeSupervisionTest(OMLBaseTest):

    PWD = u'admin123'

    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)

    @patch.object(ReporteDeLLamadasEntrantesDeSupervision,
                  '_obtener_llamadas_en_espera_raw')
    def test_contabiliza_expiradas(self, _obtener_llamadas_en_espera_raw):
        self.generador.generar_log(self.entrante1,
                                   False,
                                   'EXITWITHTIMEOUT',
                                   '35100001111',
                                   agente=self.agente1,
                                   contacto=None,
                                   bridge_wait_time=-1,
                                   duracion_llamada=-1,
                                   archivo_grabacion='',
                                   time=None)
        reporte = ReporteDeLLamadasEntrantesDeSupervision()
        self.assertEqual(
            reporte.estadisticas[self.entrante1.id]['llamadas_atendidas'], 0)
        self.assertEqual(
            reporte.estadisticas[self.entrante1.id]['llamadas_expiradas'], 1)
        self.assertEqual(
            reporte.estadisticas[self.entrante1.id]['llamadas_abandonadas'], 0)
        self.assertEqual(reporte.estadisticas[self.entrante1.id]['gestiones'],
                         0)

    @patch.object(ReporteDeLLamadasEntrantesDeSupervision,
                  '_obtener_llamadas_en_espera_raw')
    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)

    @patch.object(ReporteDeLLamadasEntrantesDeSupervision,
                  '_obtener_llamadas_en_espera_raw')
    def test_contabiliza_promedio_tiempo_espera(
            self, _obtener_llamadas_en_espera_raw):
        callid_call1 = 1
        callid_call2 = 2
        self.generador.generar_log(self.entrante1,
                                   False,
                                   'COMPLETEAGENT',
                                   '35100001111',
                                   agente=self.agente1,
                                   contacto=None,
                                   bridge_wait_time=3,
                                   duracion_llamada=10,
                                   archivo_grabacion='',
                                   time=None,
                                   callid=callid_call1)
        self.generador.generar_log(self.entrante1,
                                   False,
                                   'COMPLETEOUTNUM',
                                   '35100001112',
                                   agente=self.agente1,
                                   contacto=None,
                                   bridge_wait_time=7,
                                   duracion_llamada=10,
                                   archivo_grabacion='',
                                   time=None,
                                   callid=callid_call1)
        self.generador.generar_log(self.entrante2,
                                   False,
                                   'COMPLETEAGENT',
                                   '3510000117',
                                   agente=self.agente1,
                                   contacto=None,
                                   bridge_wait_time=4,
                                   duracion_llamada=10,
                                   archivo_grabacion='',
                                   time=None,
                                   callid=callid_call2)
        self.generador.generar_log(self.entrante2,
                                   False,
                                   'COMPLETEAGENT',
                                   '35100001110',
                                   agente=self.agente1,
                                   contacto=None,
                                   bridge_wait_time=8,
                                   duracion_llamada=10,
                                   archivo_grabacion='',
                                   time=None,
                                   callid=callid_call2)

        reporte = ReporteDeLLamadasEntrantesDeSupervision()
        estadisticas = reporte.estadisticas
        self.assertEqual(
            estadisticas[self.entrante1.pk]['tiempo_acumulado_espera'], 10)
        self.assertEqual(
            estadisticas[self.entrante2.pk]['tiempo_acumulado_espera'], 12)

    @patch.object(ReporteDeLLamadasEntrantesDeSupervision,
                  '_obtener_llamadas_en_espera_raw')
    def test_contabilizar_promedio_llamadas_abandonadas(
            self, _obtener_llamadas_en_espera_raw):
        self.generador.generar_log(self.entrante1,
                                   False,
                                   'ABANDON',
                                   '35100001111',
                                   agente=self.agente1,
                                   contacto=None,
                                   bridge_wait_time=5,
                                   duracion_llamada=10,
                                   archivo_grabacion='',
                                   time=None)
        LlamadaLogFactory(tipo_campana=Campana.TYPE_ENTRANTE,
                          tipo_llamada=LlamadaLog.LLAMADA_ENTRANTE,
                          campana_id=self.entrante1.pk,
                          event='ABANDONWEL',
                          bridge_wait_time=2)
        reporte = ReporteDeLLamadasEntrantesDeSupervision()
        estadisticas = reporte.estadisticas
        self.assertEqual(
            estadisticas[self.entrante1.pk]['tiempo_acumulado_abandonadas'], 7)

    @patch.object(ReporteDeLLamadasEntrantesDeSupervision,
                  '_obtener_llamadas_en_espera_raw')
    def test_reporte_vacio(self, _obtener_llamadas_en_espera_raw):
        reporte = ReporteDeLLamadasEntrantesDeSupervision()
        self.assertNotIn(self.entrante1.id, reporte.estadisticas)
        self.assertNotIn(self.entrante2.id, reporte.estadisticas)

    @patch.object(ReporteDeLLamadasEntrantesDeSupervision,
                  '_obtener_llamadas_en_espera_raw')
    def test_contabiliza_atendidas(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)
        # No debe contar esta manual
        self.generador.generar_log(self.entrante1,
                                   True,
                                   'COMPLETEAGENT',
                                   '35100001112',
                                   agente=self.agente1,
                                   contacto=None,
                                   bridge_wait_time=-1,
                                   duracion_llamada=10,
                                   archivo_grabacion='',
                                   time=None)
        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'],
                         0)

    def _generar_ami_response_llamadas_espera(self, campana_entrante):
        return (
            'Event: QueueEntry\r\nQueue: {0}_{1}\r\nMax: 5\r\nStrategy: '
            'rrmemory\r\nCalls: 0\r\nHoldtime: 0\r\nTalkTime: 0\r\n'
            'Completed: 0\r\nAbandoned: 0\r\n'
            'ServiceLevel: 30\r\nServicelevelPerf: 0.0\r\nServicelevelPerf2: 0.0\r\n'
            'Weight: 0\r\n'
            'ActionID: d9555aefdc48-00000001\r\n\r\nEvent: QueueStatusComplete\r\nActionID: '
            'd9555aefdc48-00000001\r\n'
            'EventList: Complete\r\nListItems: 31\r\n').format(
                campana_entrante.id, campana_entrante.nombre)

    @patch.object(ReporteDeLLamadasEntrantesDeSupervision,
                  '_obtener_llamadas_en_espera_raw')
    def test_contabilizar_llamadas_en_espera(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)
        _obtener_llamadas_en_espera_raw.return_value = self._generar_ami_response_llamadas_espera(
            self.entrante1)
        reporte = ReporteDeLLamadasEntrantesDeSupervision()
        estadisticas = reporte.estadisticas
        self.assertEqual(estadisticas[self.entrante1.pk]['llamadas_en_espera'],
                         1)
class DashboardAgenteTests(OMLBaseTest):

    PWD = u'admin123'

    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()
        super(DashboardAgenteTests, self).setUp()
        self.agente_profile = self.crear_agente_profile()
        self.campana_activa = CampanaFactory.create(
            estado=Campana.ESTADO_ACTIVA, type=Campana.TYPE_PREVIEW)
        self.generador = GeneradorDeLlamadaLogs()

    def test_se_muestran_estadisticas_del_dia_actual(self):
        ayer = now() - timedelta(days=1)
        self.generador.generar_log(self.campana_activa,
                                   False,
                                   'COMPLETEAGENT',
                                   '35100001111',
                                   agente=self.agente_profile,
                                   contacto=None,
                                   bridge_wait_time=-1,
                                   duracion_llamada=10,
                                   archivo_grabacion='',
                                   time=ayer)
        self.generador.generar_log(self.campana_activa,
                                   False,
                                   'COMPLETEOUTNUM',
                                   '35100001112',
                                   agente=self.agente_profile,
                                   contacto=None,
                                   bridge_wait_time=-1,
                                   duracion_llamada=10,
                                   archivo_grabacion='',
                                   time=None)
        reporte = ReporteEstadisticasDiariaAgente()
        logs_agente_reporte = reporte.estadisticas[
            self.agente_profile.pk]['logs']
        self.assertEqual(len(logs_agente_reporte), 1)

    def test_se_muestran_las_ultimas_10_llamadas(self):
        numero_llamada_excluida = '3510000111'
        ahora = now()
        self.generador.generar_log(self.campana_activa,
                                   False,
                                   'COMPLETEAGENT',
                                   numero_llamada_excluida,
                                   agente=self.agente_profile,
                                   contacto=None,
                                   bridge_wait_time=-1,
                                   duracion_llamada=10,
                                   archivo_grabacion='',
                                   time=ahora)
        for i in range(1, 11):
            time_llamada = ahora + timedelta(minutes=i)
            self.generador.generar_log(self.campana_activa,
                                       False,
                                       'COMPLETEAGENT',
                                       '35100213121',
                                       agente=self.agente_profile,
                                       contacto=None,
                                       bridge_wait_time=-1,
                                       duracion_llamada=10,
                                       archivo_grabacion='',
                                       time=time_llamada)
        reporte = ReporteEstadisticasDiariaAgente()
        reporte_agente = reporte.estadisticas[self.agente_profile.pk]
        llamada_excluida_encontrada = False
        for log in reporte_agente['logs']:
            if log['phone'] == numero_llamada_excluida:
                llamada_excluida_encontrada = True
        self.assertFalse(llamada_excluida_encontrada)

    def test_se_muestra_el_tiempo_de_sesion_correctamente(self):
        horas_sesion = 1
        tiempo_inicial = now()
        ActividadAgenteLogFactory.create(event='UNPAUSEALL',
                                         agente_id=self.agente_profile.id,
                                         time=tiempo_inicial)
        tiempo_removemember_1 = tiempo_inicial + timedelta(microseconds=20000)
        ActividadAgenteLogFactory.create(event='REMOVEMEMBER',
                                         agente_id=self.agente_profile.id,
                                         time=tiempo_removemember_1)
        tiempo_addmember = tiempo_removemember_1 + timedelta(microseconds=3000)
        ActividadAgenteLogFactory.create(time=tiempo_addmember,
                                         event='ADDMEMBER',
                                         agente_id=self.agente_profile.id,
                                         pausa_id='')
        tiempo_removemember_2 = tiempo_addmember + timedelta(
            hours=horas_sesion)
        ActividadAgenteLogFactory.create(time=tiempo_removemember_2,
                                         event='REMOVEMEMBER',
                                         agente_id=self.agente_profile.id,
                                         pausa_id='')
        reporte = ReporteEstadisticasDiariaAgente()
        reporte_agente = reporte.estadisticas[self.agente_profile.pk]
        self.assertEqual(reporte_agente['tiempos'].sesion,
                         timedelta(hours=horas_sesion))

    def test_se_muestran_los_tiempos_de_pausa_correctamente(self):
        horas_sesion = 1
        tiempo_inicial = now()
        pausa1 = PausaFactory(tipo=Pausa.TIPO_PRODUCTIVA)
        pausa2 = PausaFactory(tipo=Pausa.TIPO_RECREATIVA)
        ActividadAgenteLogFactory.create(event='UNPAUSEALL',
                                         agente_id=self.agente_profile.id,
                                         time=tiempo_inicial)
        tiempo_removemember_1 = tiempo_inicial + timedelta(microseconds=20000)
        ActividadAgenteLogFactory.create(event='REMOVEMEMBER',
                                         agente_id=self.agente_profile.id,
                                         time=tiempo_removemember_1)
        tiempo_addmember = tiempo_removemember_1 + timedelta(microseconds=3000)
        ActividadAgenteLogFactory.create(time=tiempo_addmember,
                                         event='ADDMEMBER',
                                         agente_id=self.agente_profile.id,
                                         pausa_id='')
        tiempo_inicio_pausa_1 = tiempo_addmember + timedelta(minutes=2)
        ActividadAgenteLogFactory.create(time=tiempo_inicio_pausa_1,
                                         event='PAUSEALL',
                                         agente_id=self.agente_profile.id,
                                         pausa_id=pausa1.id)
        tiempo_final_pausa_1 = tiempo_inicio_pausa_1 + timedelta(minutes=2)
        ActividadAgenteLogFactory.create(time=tiempo_final_pausa_1,
                                         event='UNPAUSEALL',
                                         agente_id=self.agente_profile.id,
                                         pausa_id=pausa1.id)
        tiempo_inicio_pausa_2 = tiempo_final_pausa_1 + timedelta(minutes=2)
        ActividadAgenteLogFactory.create(time=tiempo_inicio_pausa_2,
                                         event='PAUSEALL',
                                         agente_id=self.agente_profile.id,
                                         pausa_id=pausa2.id)
        tiempo_final_pausa_2 = tiempo_inicio_pausa_2 + timedelta(minutes=2)
        ActividadAgenteLogFactory.create(time=tiempo_final_pausa_2,
                                         event='UNPAUSEALL',
                                         agente_id=self.agente_profile.id,
                                         pausa_id=pausa2.id)
        tiempo_removemember_2 = tiempo_final_pausa_2 + timedelta(
            hours=horas_sesion)
        ActividadAgenteLogFactory.create(time=tiempo_removemember_2,
                                         event='REMOVEMEMBER',
                                         agente_id=self.agente_profile.id,
                                         pausa_id='')
        reporte = ReporteEstadisticasDiariaAgente()
        reporte_agente = reporte.estadisticas[self.agente_profile.pk]
        self.assertEqual(reporte_agente['tiempos'].pausa, timedelta(minutes=4))
        self.assertEqual(reporte_agente['tiempos'].pausa_recreativa,
                         timedelta(minutes=2))
Ejemplo n.º 22
0
    def test_incremental_llamada_dialer(self):
        tipo = str(Campana.TYPE_DIALER)
        campana = self.dialer
        generador = GeneradorDeLlamadaLogs()

        # Genero una llamada DIALER que termina en BUSY
        generador.generar_log(campana,
                              False,
                              'BUSY',
                              '123',
                              self.agente1,
                              bridge_wait_time=5)
        self.hasta = now()
        reporte = ReporteDeLlamadas(self.desde, self.hasta, True,
                                    self.supervisor.user)
        estadisticas = reporte.estadisticas

        self.assertEqual(estadisticas['total_llamadas_procesadas'], 1)
        por_tipo = estadisticas['llamadas_por_tipo'][tipo]
        self.assertEqual(por_tipo['total'], 1)
        self.assertEqual(por_tipo['atendidas'], 0)
        self.assertEqual(por_tipo['no_atendidas'], 1)
        self.assertEqual(por_tipo['perdidas'], 0)
        llamadas = estadisticas['llamadas_por_campana'][campana.id]
        self.assertEqual(llamadas['total'], 1)
        self.assertEqual(llamadas['manuales'], 0)
        tipos = estadisticas['tipos_de_llamada_por_campana'][tipo]
        self.assertEqual(tipos[campana.id]['efectuadas'], 1)
        self.assertEqual(tipos[campana.id]['atendidas'], 0)
        self.assertEqual(tipos[campana.id]['conectadas'], 0)
        self.assertEqual(tipos[campana.id]['expiradas'], 0)
        self.assertEqual(tipos[campana.id]['abandonadas'], 0)
        self.assertEqual(tipos[campana.id]['t_espera_conexion'], 0)
        self.assertEqual(tipos[campana.id]['t_espera_atencion'], 0)
        self.assertEqual(tipos[campana.id]['t_abandono'], 0)

        # Genero una llamada DIALER que termina en ABANDON
        generador.generar_log(campana,
                              False,
                              'ABANDON',
                              '123',
                              self.agente1,
                              bridge_wait_time=5)
        self.hasta = now()
        reporte = ReporteDeLlamadas(self.desde, self.hasta, True,
                                    self.supervisor.user)
        estadisticas = reporte.estadisticas

        self.assertEqual(estadisticas['total_llamadas_procesadas'], 2)
        por_tipo = estadisticas['llamadas_por_tipo'][tipo]
        self.assertEqual(por_tipo['total'], 2)
        self.assertEqual(por_tipo['atendidas'], 1)
        self.assertEqual(por_tipo['no_atendidas'], 1)
        self.assertEqual(por_tipo['perdidas'], 1)
        llamadas = estadisticas['llamadas_por_campana'][campana.id]
        self.assertEqual(llamadas['total'], 2)
        self.assertEqual(llamadas['manuales'], 0)
        tipos = estadisticas['tipos_de_llamada_por_campana'][tipo]
        self.assertEqual(tipos[campana.id]['efectuadas'], 2)
        self.assertEqual(tipos[campana.id]['atendidas'], 1)
        self.assertEqual(tipos[campana.id]['conectadas'], 0)
        self.assertEqual(tipos[campana.id]['expiradas'], 0)
        self.assertEqual(tipos[campana.id]['abandonadas'], 1)
        self.assertEqual(tipos[campana.id]['t_espera_conexion'], 0)
        self.assertEqual(tipos[campana.id]['t_espera_atencion'], 5)
        self.assertEqual(tipos[campana.id]['t_abandono'], 5)

        # Genero una llamada DIALER que termina en EXITWITHTIMEOUT
        generador.generar_log(campana,
                              False,
                              'EXITWITHTIMEOUT',
                              '123',
                              self.agente1,
                              bridge_wait_time=4)
        self.hasta = now()
        reporte = ReporteDeLlamadas(self.desde, self.hasta, True,
                                    self.supervisor.user)
        estadisticas = reporte.estadisticas

        self.assertEqual(estadisticas['total_llamadas_procesadas'], 3)
        por_tipo = estadisticas['llamadas_por_tipo'][tipo]
        self.assertEqual(por_tipo['total'], 3)
        self.assertEqual(por_tipo['atendidas'], 2)
        self.assertEqual(por_tipo['no_atendidas'], 1)
        self.assertEqual(por_tipo['perdidas'], 2)
        llamadas = estadisticas['llamadas_por_campana'][campana.id]
        self.assertEqual(llamadas['total'], 3)
        self.assertEqual(llamadas['manuales'], 0)
        tipos = estadisticas['tipos_de_llamada_por_campana'][tipo]
        self.assertEqual(tipos[campana.id]['efectuadas'], 3)
        self.assertEqual(tipos[campana.id]['atendidas'], 2)
        self.assertEqual(tipos[campana.id]['conectadas'], 0)
        self.assertEqual(tipos[campana.id]['expiradas'], 1)
        self.assertEqual(tipos[campana.id]['abandonadas'], 1)
        self.assertEqual(tipos[campana.id]['t_espera_conexion'], 0)
        self.assertEqual(tipos[campana.id]['t_espera_atencion'], 4.5)
        self.assertEqual(tipos[campana.id]['t_abandono'], 5)

        # Genero dos llamadas DIALER que terminan en COMPLETEAGENT y COMPLETEOUTNUM
        generador.generar_log(campana,
                              False,
                              'COMPLETEAGENT',
                              '123',
                              self.agente1,
                              bridge_wait_time=8,
                              duracion_llamada=18)
        generador.generar_log(campana,
                              False,
                              'COMPLETEOUTNUM',
                              '123',
                              self.agente1,
                              bridge_wait_time=10,
                              duracion_llamada=22)
        self.hasta = now()
        reporte = ReporteDeLlamadas(self.desde, self.hasta, True,
                                    self.supervisor.user)
        estadisticas = reporte.estadisticas

        self.assertEqual(estadisticas['total_llamadas_procesadas'], 5)
        por_tipo = estadisticas['llamadas_por_tipo'][tipo]
        self.assertEqual(por_tipo['total'], 5)
        self.assertEqual(por_tipo['atendidas'], 4)
        self.assertEqual(por_tipo['no_atendidas'], 1)
        self.assertEqual(por_tipo['perdidas'], 2)
        llamadas = estadisticas['llamadas_por_campana'][campana.id]
        self.assertEqual(llamadas['total'], 5)
        self.assertEqual(llamadas['manuales'], 0)
        tipos = estadisticas['tipos_de_llamada_por_campana'][tipo]
        self.assertEqual(tipos[campana.id]['efectuadas'], 5)
        self.assertEqual(tipos[campana.id]['atendidas'], 4)
        self.assertEqual(tipos[campana.id]['conectadas'], 2)
        self.assertEqual(tipos[campana.id]['expiradas'], 1)
        self.assertEqual(tipos[campana.id]['abandonadas'], 1)
        self.assertEqual(tipos[campana.id]['t_espera_conexion'], 9)
        self.assertEqual(tipos[campana.id]['t_espera_atencion'], 6.75)
        self.assertEqual(tipos[campana.id]['t_abandono'], 5)

        # Genero llamadas dialer Manuales CANCEL, COMPLETEOUTNUM
        generador.generar_log(campana,
                              True,
                              'CANCEL',
                              '123',
                              self.agente1,
                              bridge_wait_time=4)
        generador.generar_log(campana,
                              True,
                              'COMPLETEOUTNUM',
                              '123',
                              self.agente1,
                              bridge_wait_time=8,
                              duracion_llamada=30)
        self.hasta = now()
        reporte = ReporteDeLlamadas(self.desde, self.hasta, True,
                                    self.supervisor.user)
        estadisticas = reporte.estadisticas

        self.assertEqual(estadisticas['total_llamadas_procesadas'], 7)
        por_tipo_dialer = estadisticas['llamadas_por_tipo'][tipo]
        self.assertEqual(por_tipo_dialer['total'], 5)
        self.assertEqual(por_tipo_dialer['atendidas'], 4)
        self.assertEqual(por_tipo_dialer['no_atendidas'], 1)
        self.assertEqual(por_tipo_dialer['perdidas'], 2)
        por_tipo_manual = estadisticas['llamadas_por_tipo'][str(
            Campana.TYPE_MANUAL)]
        self.assertEqual(por_tipo_manual['total'], 2)
        self.assertEqual(por_tipo_manual['conectadas'], 1)
        self.assertEqual(por_tipo_manual['no_conectadas'], 1)
        llamadas = estadisticas['llamadas_por_campana'][campana.id]
        self.assertEqual(llamadas['total'], 7)
        self.assertEqual(llamadas['manuales'], 2)
        tipos = estadisticas['tipos_de_llamada_por_campana'][tipo]
        self.assertEqual(tipos[campana.id]['efectuadas'], 5)
        self.assertEqual(tipos[campana.id]['atendidas'], 4)
        self.assertEqual(tipos[campana.id]['conectadas'], 2)
        self.assertEqual(tipos[campana.id]['expiradas'], 1)
        self.assertEqual(tipos[campana.id]['abandonadas'], 1)
        self.assertEqual(tipos[campana.id]['t_espera_conexion'], 9)
        self.assertEqual(tipos[campana.id]['t_espera_atencion'], 6.75)
        self.assertEqual(tipos[campana.id]['t_abandono'], 5)
        self.assertEqual(tipos[campana.id]['efectuadas_manuales'], 2)
        self.assertEqual(tipos[campana.id]['conectadas_manuales'], 1)
        self.assertEqual(tipos[campana.id]['no_conectadas_manuales'], 1)
        self.assertEqual(tipos[campana.id]['t_espera_conexion_manuales'], 6)
Ejemplo n.º 23
0
    def test_genera_dialer_incompleta_por_exitwithtimeout(self):
        generador = GeneradorDeLlamadaLogs()
        generador.generar_log(self.dialer,
                              False,
                              'EXITWITHTIMEOUT',
                              '123',
                              self.agente1,
                              self.contacto_d,
                              bridge_wait_time=5,
                              duracion_llamada=44)
        logs_generados = LlamadaLog.objects.filter(campana_id=self.dialer.id)
        # ASUMO que al ser EXITWITHTIMEOUT, la pata dial detecta que el agente terminó la conexión
        eventos_esperados = set(('DIAL', 'ANSWER', 'COMPLETEAGENT',
                                 'ENTERQUEUE', 'EXITWITHTIMEOUT'))
        self.assertEqual(self.set_de_eventos(logs_generados),
                         eventos_esperados)

        dial = logs_generados.get(event='DIAL')
        self.assertEqual(dial.campana_id, self.dialer.id)
        self.assertEqual(dial.tipo_campana, self.dialer.type)
        self.assertEqual(dial.tipo_llamada, self.dialer.type)
        self.assertEqual(dial.agente_id, -1)
        self.assertEqual(dial.contacto_id, self.contacto_d.id)
        self.assertEqual(dial.numero_marcado, '123')

        answer = logs_generados.get(event='ANSWER')
        self.assertEqual(answer.campana_id, self.dialer.id)
        self.assertEqual(answer.tipo_campana, self.dialer.type)
        self.assertEqual(answer.tipo_llamada, self.dialer.type)
        self.assertEqual(answer.agente_id, -1)
        self.assertEqual(answer.contacto_id, self.contacto_d.id)
        self.assertEqual(answer.bridge_wait_time, 5)

        complete = logs_generados.get(event='COMPLETEAGENT', agente_id=-1)
        self.assertEqual(complete.campana_id, self.dialer.id)
        self.assertEqual(complete.tipo_campana, self.dialer.type)
        self.assertEqual(complete.tipo_llamada, self.dialer.type)
        self.assertEqual(complete.contacto_id, self.contacto_d.id)
        self.assertEqual(complete.bridge_wait_time, 5)
        self.assertEqual(complete.duracion_llamada, 44)
        self.assertEqual(complete.archivo_grabacion, '')

        enterqueue = logs_generados.get(event='ENTERQUEUE')
        self.assertEqual(enterqueue.campana_id, self.dialer.id)
        self.assertEqual(enterqueue.tipo_campana, self.dialer.type)
        self.assertEqual(enterqueue.tipo_llamada, self.dialer.type)
        self.assertEqual(enterqueue.contacto_id, self.contacto_d.id)
        self.assertEqual(enterqueue.agente_id, -1)
        self.assertEqual(enterqueue.bridge_wait_time, -1)
        self.assertEqual(enterqueue.duracion_llamada, -1)
        self.assertEqual(enterqueue.archivo_grabacion, '')

        abandon = logs_generados.get(event='EXITWITHTIMEOUT')
        self.assertEqual(abandon.campana_id, self.dialer.id)
        self.assertEqual(abandon.tipo_campana, self.dialer.type)
        self.assertEqual(abandon.tipo_llamada, self.dialer.type)
        self.assertEqual(abandon.contacto_id, self.contacto_d.id)
        self.assertEqual(abandon.agente_id, -1)
        self.assertEqual(abandon.bridge_wait_time, 5)
        self.assertEqual(abandon.duracion_llamada, -1)
        self.assertEqual(abandon.archivo_grabacion, '')
Ejemplo n.º 24
0
    def test_genera_dialer_completa_completeagent(self):
        generador = GeneradorDeLlamadaLogs()
        generador.generar_log(self.dialer,
                              False,
                              'COMPLETEAGENT',
                              '123',
                              self.agente1,
                              self.contacto_d,
                              bridge_wait_time=5,
                              duracion_llamada=44,
                              archivo_grabacion='archi')
        logs_generados = LlamadaLog.objects.filter(campana_id=self.dialer.id)
        eventos_esperados = set(
            ('DIAL', 'ANSWER', 'COMPLETEAGENT', 'ENTERQUEUE', 'CONNECT'))
        self.assertEqual(self.set_de_eventos(logs_generados),
                         eventos_esperados)

        # Pata Dialer
        dial = logs_generados.get(event='DIAL')
        self.assertEqual(dial.campana_id, self.dialer.id)
        self.assertEqual(dial.tipo_campana, self.dialer.type)
        self.assertEqual(dial.tipo_llamada, self.dialer.type)
        self.assertEqual(dial.agente_id, -1)
        self.assertEqual(dial.contacto_id, self.contacto_d.id)

        answer = logs_generados.get(event='ANSWER')
        self.assertEqual(answer.campana_id, self.dialer.id)
        self.assertEqual(answer.tipo_campana, self.dialer.type)
        self.assertEqual(answer.tipo_llamada, self.dialer.type)
        self.assertEqual(answer.agente_id, -1)
        self.assertEqual(answer.contacto_id, self.contacto_d.id)
        self.assertEqual(answer.bridge_wait_time, 5)

        complete_dial = logs_generados.get(event='COMPLETEAGENT', agente_id=-1)
        self.assertEqual(complete_dial.campana_id, self.dialer.id)
        self.assertEqual(complete_dial.tipo_campana, self.dialer.type)
        self.assertEqual(complete_dial.tipo_llamada, self.dialer.type)
        self.assertEqual(complete_dial.agente_id, -1)
        self.assertEqual(complete_dial.contacto_id, self.contacto_d.id)
        self.assertEqual(complete_dial.bridge_wait_time, 5)
        self.assertEqual(complete_dial.duracion_llamada, 44)
        self.assertEqual(complete_dial.archivo_grabacion, '')

        # Pata Agente
        enterqueue = logs_generados.get(event='ENTERQUEUE')
        self.assertEqual(enterqueue.campana_id, self.dialer.id)
        self.assertEqual(enterqueue.tipo_campana, self.dialer.type)
        self.assertEqual(enterqueue.tipo_llamada, self.dialer.type)
        self.assertEqual(enterqueue.contacto_id, self.contacto_d.id)
        self.assertEqual(enterqueue.agente_id, -1)
        self.assertEqual(enterqueue.bridge_wait_time, -1)
        self.assertEqual(enterqueue.duracion_llamada, -1)
        self.assertEqual(enterqueue.archivo_grabacion, '')

        connect = logs_generados.get(event='CONNECT')
        self.assertEqual(connect.campana_id, self.dialer.id)
        self.assertEqual(connect.tipo_campana, self.dialer.type)
        self.assertEqual(connect.tipo_llamada, self.dialer.type)
        self.assertEqual(connect.agente_id, self.agente1.id)
        self.assertEqual(connect.contacto_id, self.contacto_d.id)
        self.assertEqual(connect.bridge_wait_time, 5)
        self.assertEqual(connect.duracion_llamada, -1)
        self.assertEqual(connect.archivo_grabacion, '')

        complete = logs_generados.get(event='COMPLETEAGENT',
                                      agente_id=self.agente1.id)
        self.assertEqual(complete.campana_id, self.dialer.id)
        self.assertEqual(complete.tipo_campana, self.dialer.type)
        self.assertEqual(complete.tipo_llamada, self.dialer.type)
        self.assertEqual(complete.agente_id, self.agente1.id)
        self.assertEqual(complete.contacto_id, self.contacto_d.id)
        self.assertEqual(complete.bridge_wait_time, 5)
        self.assertEqual(complete.duracion_llamada, 44)
        self.assertEqual(complete.archivo_grabacion, 'archi')