示例#1
0
    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)
示例#2
0
 def test_no_se_permite_eliminar_sitio_externo_asociado_campana(self):
     url = reverse('sitio_externo_delete', args=[self.sitio_externo.pk])
     self.client.login(username=self.admin.username, password=self.PWD)
     CampanaFactory.create(sitio_externo=self.sitio_externo, tipo_interaccion=2)
     n_sitio_externo = SitioExterno.objects.count()
     self.client.post(url, follow=True)
     self.assertEqual(SitioExterno.objects.count(), n_sitio_externo)
示例#3
0
    def setUp(self):
        super(ReglaIncidenciaPorCalificacionTests, self).setUp()

        self.admin = self.crear_administrador()
        self.client.login(username=self.admin.username, password=PASSWORD)

        self.formulario = FormularioFactory()
        self.campo_formulario = FieldFormularioFactory(
            formulario=self.formulario)
        self.campana = CampanaFactory.create(type=Campana.TYPE_DIALER)
        self.nombre_opcion_1 = NombreCalificacionFactory.create()
        self.opcion_calificacion_1 = OpcionCalificacionFactory.create(
            campana=self.campana,
            nombre=self.nombre_opcion_1.nombre,
            tipo=OpcionCalificacion.GESTION,
            formulario=self.formulario)
        self.campana.opciones_calificacion.add(self.opcion_calificacion_1)
        self.nombre_opcion_2 = NombreCalificacionFactory.create()
        self.opcion_calificacion_2 = OpcionCalificacionFactory.create(
            campana=self.campana,
            nombre=self.nombre_opcion_2.nombre,
            tipo=OpcionCalificacion.NO_ACCION)
        self.campana.opciones_calificacion.add(self.opcion_calificacion_2)
        self.contacto = ContactoFactory.create()
        self.campana.bd_contacto.contactos.add(self.contacto)

        self.campana_extra = CampanaFactory.create(type=Campana.TYPE_DIALER)
        self.nombre_opcion_extra = NombreCalificacionFactory.create()
        self.opcion_calificacion_extra = OpcionCalificacionFactory.create(
            campana=self.campana_extra,
            nombre=self.nombre_opcion_extra.nombre,
            tipo=OpcionCalificacion.NO_ACCION)
        self.campana_extra.opciones_calificacion.add(
            self.opcion_calificacion_extra)
示例#4
0
    def setUp(self):
        super(GeneradorDeLlamadaLogsTests, self).setUp()
        self.manual = CampanaFactory.create(type=Campana.TYPE_MANUAL)
        self.usr_agente1 = UserFactory.create(username='******',
                                              is_agente=True)
        self.agente1 = AgenteProfileFactory.create(user=self.usr_agente1)

        self.dialer = CampanaFactory.create(type=Campana.TYPE_DIALER)
        self.contacto_d = ContactoFactory(bd_contacto=self.dialer.bd_contacto)

        self.entrante = CampanaFactory.create(type=Campana.TYPE_ENTRANTE)

        self.preview = CampanaFactory.create(type=Campana.TYPE_PREVIEW)
        self.contacto_p = ContactoFactory(bd_contacto=self.preview.bd_contacto)
示例#5
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)
示例#6
0
 def _agregar_campana_y_contacto(self, agente_profile, tipo_campana):
     campana = CampanaFactory.create(type=tipo_campana,
                                     tiempo_desconexion=3,
                                     estado=Campana.ESTADO_ACTIVA)
     self._hacer_miembro(agente_profile, campana)
     contacto = ContactoFactory.create(bd_contacto=campana.bd_contacto)
     return campana, contacto
    def setUp(self):
        super(AuditoriaDeGestionTests, self).setUp()

        self.supervisor = self.crear_supervisor_profile()
        self.client.login(username=self.supervisor.user.username,
                          password=PASSWORD)

        self.campana = CampanaFactory.create(estado=Campana.ESTADO_ACTIVA)
        self.campana.supervisors.add(self.supervisor.user)

        self.opcion_calificacion_gestion = OpcionCalificacionFactory.create(
            campana=self.campana, tipo=OpcionCalificacion.GESTION)
        self.opcion_calificacion_no_gestion = OpcionCalificacionFactory.create(
            campana=self.campana, tipo=OpcionCalificacion.NO_ACCION)

        self.contacto_gestion = ContactoFactory.create()
        self.campana.bd_contacto.contactos.add(self.contacto_gestion)
        self.contacto_no_gestion = ContactoFactory.create()
        self.campana.bd_contacto.contactos.add(self.contacto_no_gestion)

        self.agente = self.crear_agente_profile()
        self.calificacion_gestion = CalificacionClienteFactory(
            opcion_calificacion=self.opcion_calificacion_gestion,
            agente=self.agente,
            contacto=self.contacto_gestion)
        self.calificacion_no_gestion = CalificacionClienteFactory(
            opcion_calificacion=self.opcion_calificacion_no_gestion,
            agente=self.agente,
            contacto=self.contacto_no_gestion)
示例#8
0
    def setUp(self):
        super(CalificacionTests, self).setUp()

        self.agente_profile = self.crear_agente_profile()
        self.usuario_agente = self.agente_profile.user

        self.campana = CampanaFactory.create()
        self.nombre_opcion_gestion = NombreCalificacionFactory.create()
        self.nombre_calificacion_agenda = NombreCalificacion.objects.get(
            nombre=settings.CALIFICACION_REAGENDA)
        self.formulario = FormularioFactory()
        self.campo_formulario = FieldFormularioFactory(formulario=self.formulario)
        self.opcion_calificacion_gestion = OpcionCalificacionFactory.create(
            campana=self.campana, nombre=self.nombre_opcion_gestion.nombre,
            tipo=OpcionCalificacion.GESTION, formulario=self.formulario)
        self.opcion_calificacion_agenda = OpcionCalificacionFactory.create(
            campana=self.campana, nombre=self.nombre_calificacion_agenda.nombre,
            tipo=OpcionCalificacion.AGENDA)
        self.opcion_calificacion_camp_manual = OpcionCalificacionFactory.create(
            campana=self.campana, nombre=self.nombre_opcion_gestion.nombre)
        self.opcion_calificacion_no_accion = OpcionCalificacionFactory.create(
            campana=self.campana, tipo=OpcionCalificacion.NO_ACCION)

        self.contacto = ContactoFactory.create()
        self.campana.bd_contacto.contactos.add(self.contacto)

        self.queue = QueueFactory.create(campana=self.campana)

        self.calificacion_cliente = CalificacionClienteFactory(
            opcion_calificacion=self.opcion_calificacion_camp_manual, agente=self.agente_profile,
            contacto=self.contacto)

        QueueMemberFactory.create(member=self.agente_profile, queue_name=self.queue)

        self.client.login(username=self.usuario_agente.username, password=PASSWORD)
    def setUp(self):
        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)
示例#10
0
    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."))
示例#11
0
    def setUp(self):
        super(APITest, self).setUp()
        self.factory = RequestFactory()

        self.supervisor_admin = self.crear_supervisor_profile(
            rol=User.ADMINISTRADOR)
        self.supervisor = self.crear_supervisor_profile(rol=User.SUPERVISOR)
        self.agente_profile = self.crear_agente_profile()

        self.campana_activa = CampanaFactory.create(
            estado=Campana.ESTADO_ACTIVA,
            type=Campana.TYPE_MANUAL,
            nombre='activa uno')
        self.campana_activa_2 = CampanaFactory.create(
            estado=Campana.ESTADO_ACTIVA,
            type=Campana.TYPE_PREVIEW,
            nombre='activa dos')
        self.campana_activa_supervisor = CampanaFactory.create(
            estado=Campana.ESTADO_ACTIVA,
            type=Campana.TYPE_ENTRANTE,
            nombre='activa supervisor uno')
        self.campana_activa_supervisor.supervisors.add(self.supervisor.user)
        self.campana_finalizada = CampanaFactory(
            estado=Campana.ESTADO_FINALIZADA)
        self.queue = QueueFactory.create(campana=self.campana_activa)
        self.queue1 = QueueFactory.create(campana=self.campana_activa_2)
        self.queue2 = QueueFactory.create(
            campana=self.campana_activa_supervisor)
        self.queue3 = QueueFactory.create(campana=self.campana_finalizada)
        QueueMemberFactory.create(member=self.agente_profile,
                                  queue_name=self.queue)
        self.sistema_externo = SistemaExternoFactory()
        self.opcion_calificacion = OpcionCalificacionFactory(
            campana=self.campana_activa)

        self.contacto = ContactoFactory(
            bd_contacto=self.campana_activa.bd_contacto)
        self.calificacion_cliente = CalificacionClienteFactory(
            opcion_calificacion=self.opcion_calificacion,
            agente=self.agente_profile,
            contacto=self.contacto)

        for user in User.objects.all():
            Token.objects.create(user=user)
 def setUp(self):
     self.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()
示例#13
0
    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 setUp(self):
        super(ReporteDeLLamadasEntrantesDeSupervisionTest, self).setUp()
        self.generador = GeneradorDeLlamadaLogs()

        self.supervisor = SupervisorProfileFactory()
        self.supervisor.user.set_password(self.PWD)
        self.supervisor.user.save()

        self.agente1 = AgenteProfileFactory()

        self.entrante1 = CampanaFactory.create(
            type=Campana.TYPE_ENTRANTE,
            nombre='camp-entrante-1',
            estado=Campana.ESTADO_ACTIVA,
            supervisors=[self.supervisor.user])
        self.opcion_calificacion = OpcionCalificacionFactory(
            campana=self.entrante1, tipo=OpcionCalificacion.GESTION)
        # Campaña que no debe estar en los reportes por no ser del supervisor
        self.entrante2 = CampanaFactory.create(type=Campana.TYPE_ENTRANTE,
                                               nombre='camp-entrante-2',
                                               estado=Campana.ESTADO_ACTIVA)
    def setUp(self):
        super(StatusCalificacionLlamadaTest, self).setUp()
        user = self.crear_user_agente(username='******')
        self.agente = self.crear_agente_profile(user)
        self.agente.grupo.obligar_calificacion = True
        self.client.login(username=user.username, password=PASSWORD)

        self.campana = CampanaFactory.create()
        QueueFactory(campana=self.campana)
        QueueMemberFactory.create(member=self.agente,
                                  queue_name=self.campana.queue_campana)
        self.contacto = ContactoFactory.create()
        self.campana.bd_contacto.contactos.add(self.contacto)
 def setUp(self):
     self.agente_1 = self.crear_agente_profile()
     self.agente_2 = self.crear_agente_profile()
     self.supervisor = self.crear_supervisor_profile()
     self.campana_preview = CampanaFactory.create(
         type=Campana.TYPE_PREVIEW, tiempo_desconexion=2, estado=Campana.ESTADO_ACTIVA)
     QueueFactory.create(campana=self.campana_preview)
     self._hacer_miembro(self.agente_1, self.campana_preview)
     self._hacer_miembro(self.agente_2, self.campana_preview)
     self.contacto_1 = ContactoFactory.create(bd_contacto=self.campana_preview.bd_contacto)
     self.contacto_2 = ContactoFactory.create(bd_contacto=self.campana_preview.bd_contacto)
     self.campana_preview.establecer_valores_iniciales_agente_contacto(False, False)
     self.client.login(username=self.agente_1.user.username, password=PASSWORD)
示例#17
0
    def setUp(self):
        super(LimitarAgendasPersonalesTests, self).setUp()

        self.grupo1 = GrupoFactory(nombre='grupo1', limitar_agendas_personales=True,
                                   cantidad_agendas_personales=1)
        self.grupo2 = GrupoFactory(nombre='grupo2', limitar_agendas_personales=True,
                                   cantidad_agendas_personales=0)
        self.grupo3 = GrupoFactory(nombre='grupo3', limitar_agendas_personales=False,
                                   cantidad_agendas_personales=0)

        self.agente_1 = self.crear_agente_profile()
        self.agente_1.grupo = self.grupo1
        self.agente_1.save()

        self.agente_2 = self.crear_agente_profile()
        self.agente_2.grupo = self.grupo2
        self.agente_2.save()

        self.agente_3 = self.crear_agente_profile()
        self.agente_3.grupo = self.grupo3
        self.agente_3.save()

        self.contacto = ContactoFactory.create()

        self.campana_preview = CampanaFactory.create(estado=Campana.ESTADO_ACTIVA,
                                                     type=Campana.TYPE_PREVIEW)
        self.campana_dialer = CampanaFactory.create(estado=Campana.ESTADO_ACTIVA,
                                                    type=Campana.TYPE_DIALER)

        self.nombre_calificacion_agenda = NombreCalificacion.objects.get(
            nombre=settings.CALIFICACION_REAGENDA)

        self.opcion_calificacion_agenda_campana_preview = OpcionCalificacionFactory.create(
            campana=self.campana_preview, nombre=self.nombre_calificacion_agenda.nombre,
            tipo=OpcionCalificacion.AGENDA)
        self.opcion_calificacion_agenda_campana_dialer = OpcionCalificacionFactory.create(
            campana=self.campana_dialer, nombre=self.nombre_calificacion_agenda.nombre,
            tipo=OpcionCalificacion.AGENDA)
示例#18
0
    def setUp(self):
        super(CalificacionTests, self).setUp()

        self.agente_1 = self.crear_agente_profile()
        self.agente_2 = self.crear_agente_profile()
        self.agente_3 = self.crear_agente_profile()
        self.supervisor = self.crear_supervisor_profile()

        self.campana = CampanaFactory.create(estado=Campana.ESTADO_ACTIVA,
                                             type=Campana.TYPE_MANUAL)
        self.campana.supervisors.add(self.supervisor.user)

        self.nombre_calificacion_agenda = NombreCalificacion.objects.get(
            nombre=settings.CALIFICACION_REAGENDA)
        self.opcion_calificacion_agenda = OpcionCalificacionFactory.create(
            campana=self.campana,
            nombre=self.nombre_calificacion_agenda.nombre,
            tipo=OpcionCalificacion.AGENDA)

        self.contacto_1 = ContactoFactory.create()
        self.campana.bd_contacto.contactos.add(self.contacto_1)
        self.contacto_2 = ContactoFactory.create()
        self.campana.bd_contacto.contactos.add(self.contacto_2)

        self.calificacion_1 = CalificacionClienteFactory(
            opcion_calificacion=self.opcion_calificacion_agenda,
            agente=self.agente_1,
            contacto=self.contacto_1)
        self.agenda_1 = AgendaContactoFactory(
            agente=self.agente_1,
            contacto=self.contacto_1,
            campana=self.campana,
            tipo_agenda=AgendaContacto.TYPE_PERSONAL)
        self.calificacion_2 = CalificacionClienteFactory(
            opcion_calificacion=self.opcion_calificacion_agenda,
            agente=self.agente_2,
            contacto=self.contacto_2)
        self.agenda_2 = AgendaContactoFactory(
            agente=self.agente_2,
            contacto=self.contacto_2,
            campana=self.campana,
            tipo_agenda=AgendaContacto.TYPE_PERSONAL)

        self.queue = QueueFactory.create(campana=self.campana)
        QueueMemberFactory.create(member=self.agente_1, queue_name=self.queue)
        QueueMemberFactory.create(member=self.agente_2, queue_name=self.queue)

        self.client.login(username=self.supervisor.user.username,
                          password=PASSWORD)
    def setUp(self):
        super(BaseReporteDeLlamadasTests, self).setUp()
        self.hasta = fecha_hora_local(now())
        self.durante = fecha_hora_local(now() - timedelta(days=1))
        self.desde = datetime_hora_minima_dia(self.hasta) - timedelta(days=1)

        self.supervisor = SupervisorProfileFactory(is_administrador=True)

        self.agente1 = AgenteProfileFactory()
        self.agente2 = AgenteProfileFactory()
        self.agente3 = AgenteProfileFactory()

        self.manual = CampanaFactory.create(type=Campana.TYPE_MANUAL,
                                            nombre='camp-manual-1',
                                            estado=Campana.ESTADO_ACTIVA)

        self.dialer = CampanaFactory.create(type=Campana.TYPE_DIALER,
                                            nombre='camp-dialer-1',
                                            estado=Campana.ESTADO_ACTIVA)
        self.contacto_d = ContactoFactory(bd_contacto=self.dialer.bd_contacto)

        self.entrante = CampanaFactory.create(type=Campana.TYPE_ENTRANTE,
                                              nombre='camp-entrante-1',
                                              estado=Campana.ESTADO_ACTIVA)

        self.preview = CampanaFactory.create(type=Campana.TYPE_PREVIEW,
                                             nombre='camp-preview-1',
                                             estado=Campana.ESTADO_ACTIVA)
        self.contacto_p = ContactoFactory(bd_contacto=self.preview.bd_contacto)

        self.campanas = [
            self.manual,
            self.dialer,
            self.entrante,
            self.preview,
        ]
示例#20
0
    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)
示例#21
0
 def crear_campanas(self):
     self.campanas = {}
     estado = Campana.ESTADO_ACTIVA
     for (tipo, nombre_tipo) in Campana.TYPES_CAMPANA:
         nombre = 'campana_simulada_%s' % nombre_tipo
         qs = Campana.objects.filter(nombre=nombre)
         if qs.count() == 1:
             campana = qs[0]
         else:
             campana = CampanaFactory.create(
                 type=tipo,
                 estado=estado,
                 nombre=nombre,
                 reported_by=self.agentes[0].user)
             QueueFactory(campana=campana, name=campana.nombre)
         ContactoFactory.create_batch(5, bd_contacto=campana.bd_contacto)
         self.campanas[tipo] = campana
    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."))
示例#23
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)