public void TestAgregarPropuesta()
        {
            //Se obtiene el número de propuestas totales antes de la inserción
            comandoEntidad = LogicaTangerine.Fabrica.FabricaComandos.ComandoConsultarXIdPropuesta(laPropuesta);
            comandoInt     = LogicaTangerine.Fabrica.FabricaComandos.ComandoConsultarNumeroPropuestas();
            contador       = comandoInt.Ejecutar();
            //Se inserta la propuesta
            comandoBool = LogicaTangerine.Fabrica.FabricaComandos.ComandoAgregarPropuesta(laPropuesta);
            Assert.IsTrue(comandoBool.Ejecutar());
            //Se checkea que aumente en una unidad el total de las propuestas en la base de datos.
            Assert.AreEqual(comandoInt.Ejecutar(), contador + 1);
            comandoEntidad = LogicaTangerine.Fabrica.FabricaComandos.ComandoConsultarXIdPropuesta(laPropuesta);
            laPropuesta2   = (DominioTangerine.Entidades.M6.Propuesta)comandoEntidad.Ejecutar();
            Assert.AreEqual(laPropuesta.Descripcion, laPropuesta2.Descripcion);
            Assert.AreEqual(laPropuesta.TipoDuracion, laPropuesta2.TipoDuracion);
            Assert.AreEqual(laPropuesta.CantDuracion, laPropuesta2.CantDuracion);
            Assert.AreEqual(laPropuesta.Acuerdopago, laPropuesta2.Acuerdopago);
            Assert.AreEqual(laPropuesta.Estatus, laPropuesta2.Estatus);
            Assert.AreEqual(laPropuesta.Moneda, laPropuesta2.Moneda);
            Assert.AreEqual(laPropuesta.Entrega, laPropuesta2.Entrega);
            Assert.AreEqual(laPropuesta.Feincio, laPropuesta2.Feincio);
            Assert.AreEqual(laPropuesta.Fefinal, laPropuesta2.Fefinal);
            Assert.AreEqual(laPropuesta.Costo, laPropuesta2.Costo);
            Assert.AreEqual(laPropuesta.IdCompañia, laPropuesta2.IdCompañia);

            //Elimino la propuesta de prueba
            comandoBool  = LogicaTangerine.Fabrica.FabricaComandos.ComandoBorrarPropuesta(laPropuesta);
            confirmacion = comandoBool.Ejecutar();
        }
 public void TestEliminarRequerimiento()
 {
     //Se obtiene el número de propuestas totales antes del insertado
     comandoInt = LogicaTangerine.Fabrica.FabricaComandos.ComandoConsultarNumeroRequerimientos();
     contador   = comandoInt.Ejecutar();
     //Se inserta el requerimiento
     comandoBool = LogicaTangerine.Fabrica.FabricaComandos.ComandoAgregarRequerimiento(elRequerimiento);
     Assert.IsTrue(comandoBool.Ejecutar());
     //Elimino el requerimiento de prueba
     comandoBool = LogicaTangerine.Fabrica.FabricaComandos.ComandoEliminarRequerimiento(elRequerimiento);
     Assert.IsTrue(comandoBool.Ejecutar());
     //Se checkea que haya disminuido en una unidad la cantidad de requerimientos en la base de datos
     Assert.AreEqual(comandoInt.Ejecutar(), contador);
     try
     {
         //Se intenta consultar el requerimiento anteriormente eliminado.
         comandoEntidad  = LogicaTangerine.Fabrica.FabricaComandos.ComandoConsultarXIdRequerimiento(elRequerimiento);
         elRequerimiento = (DominioTangerine.Entidades.M6.Requerimiento)comandoEntidad.Ejecutar();
     }
     //Se chequea que no haya sido encontrada.
     catch (ExcepcionesTangerine.ExceptionsTangerine)
     {
         Assert.IsTrue(true);
     }
 }
        public void TestAgregarRequerimiento()
        {
            //Se inserta la propuesta
            comandoBool = LogicaTangerine.Fabrica.FabricaComandos.ComandoAgregarPropuesta(laPropuesta);
            Assert.IsTrue(comandoBool.Ejecutar());
            //Se obtiene el número de requerimientos totales antes de la inserción
            comandoInt = LogicaTangerine.Fabrica.FabricaComandos.ComandoConsultarNumeroRequerimientos();
            contador   = comandoInt.Ejecutar();
            //Se agrega un Requerimiento y pruebo que se agregó
            comandoBool = LogicaTangerine.Fabrica.FabricaComandos.ComandoAgregarRequerimiento(elRequerimiento);
            Assert.IsTrue(comandoBool.Ejecutar());
            //Se checkea que la cantidad total de requerimientos en la base de datos haya aumentado en una unidad
            Assert.AreEqual(comandoInt.Ejecutar(), contador + 1);
            //Pruebo que el requerimiento pertenece a la propuesta que acabo de agregar
            comandoListEntidad  = LogicaTangerine.Fabrica.FabricaComandos.ComandoConsultarRequerimientoXPropuesta(laPropuesta);
            listaRequerimientos = comandoListEntidad.Ejecutar();
            Assert.AreEqual("NombreRequerimiento1",
                            ((DominioTangerine.Entidades.M6.Requerimiento)listaRequerimientos.ElementAt(0)).CodigoRequerimiento);
            Assert.AreEqual("DescripcionRequerimientoPrueba1",
                            ((DominioTangerine.Entidades.M6.Requerimiento)listaRequerimientos.ElementAt(0)).Descripcion);
            Assert.AreEqual("NombrePropuestaPrueba",
                            ((DominioTangerine.Entidades.M6.Requerimiento)listaRequerimientos.ElementAt(0)).CodigoPropuesta);

            //Elimino la propuesta de prueba junto con el requerimiento
            comandoBool  = LogicaTangerine.Fabrica.FabricaComandos.ComandoBorrarPropuesta(laPropuesta);
            confirmacion = comandoBool.Ejecutar();
        }
 public void TestEliminarPropuesta()
 {
     //Se obtiene el número de propuestas totales antes del insertado
     comandoInt     = LogicaTangerine.Fabrica.FabricaComandos.ComandoConsultarNumeroPropuestas();
     comandoEntidad = LogicaTangerine.Fabrica.FabricaComandos.ComandoConsultarXIdPropuesta(laPropuesta);
     comandoBool    = LogicaTangerine.Fabrica.FabricaComandos.ComandoAgregarPropuesta(laPropuesta);
     contador       = comandoInt.Ejecutar();
     //Se inserta la propuesta
     Assert.IsTrue(comandoBool.Ejecutar());
     //Elimino la propuesta de prueba
     comandoBool  = LogicaTangerine.Fabrica.FabricaComandos.ComandoBorrarPropuesta(laPropuesta);
     confirmacion = comandoBool.Ejecutar();
     //Se checkea que haya disminuido en una unidad la cantidad de propuestas en la base de datos
     Assert.AreEqual(comandoInt.Ejecutar(), contador);
     try
     {
         //Se intenta consultar la propuesta anteriormente eliminada.
         laPropuesta2 = (DominioTangerine.Entidades.M6.Propuesta)comandoEntidad.Ejecutar();
     }
     //Se chequea que no haya sido encontrada.
     catch (ExcepcionesTangerine.ExceptionsTangerine)
     {
         Assert.IsTrue(true);
     }
 }
        public void TestModificarPropuesta()
        {
            //Se inserta la propuesta
            comandoEntidad = LogicaTangerine.Fabrica.FabricaComandos.ComandoConsultarXIdPropuesta(laPropuesta);
            comandoBool    = LogicaTangerine.Fabrica.FabricaComandos.ComandoAgregarPropuesta(laPropuesta);
            Assert.IsTrue(comandoBool.Ejecutar());
            laPropuesta2 = new DominioTangerine.Entidades.M6.Propuesta("NombrePropuestaPrueba",
                                                                       "DescripcionProPuestaPruebaModificada", "MesesModificados", "3", "AcuerdoM", "PendientePruebaModif", "Dolar",
                                                                       1, Date1, Date2, 100, "1");
            //Se modifica la propuesta
            comandoBool = LogicaTangerine.Fabrica.FabricaComandos.ComandoModificarPropuesta(laPropuesta2);
            Assert.IsTrue(comandoBool.Ejecutar());
            laPropuesta3 = (DominioTangerine.Entidades.M6.Propuesta)comandoEntidad.Ejecutar();
            //Comparo y confirmo la modificacion
            Assert.AreEqual(laPropuesta2.Descripcion, laPropuesta3.Descripcion);
            Assert.AreEqual(laPropuesta2.TipoDuracion, laPropuesta3.TipoDuracion);
            Assert.AreEqual(laPropuesta2.TipoDuracion, laPropuesta3.TipoDuracion);
            Assert.AreEqual(laPropuesta2.Acuerdopago, laPropuesta3.Acuerdopago);
            Assert.AreEqual(laPropuesta2.Estatus, laPropuesta3.Estatus);
            Assert.AreEqual(laPropuesta2.Moneda, laPropuesta3.Moneda);
            Assert.AreEqual(laPropuesta2.Entrega, laPropuesta3.Entrega);
            Assert.AreEqual(laPropuesta2.Feincio, laPropuesta3.Feincio);
            Assert.AreEqual(laPropuesta2.Fefinal, laPropuesta3.Fefinal);
            Assert.AreEqual(laPropuesta2.Costo, laPropuesta3.Costo);
            Assert.AreEqual(laPropuesta2.IdCompañia, laPropuesta3.IdCompañia);

            //Elimino la propuesta de prueba
            comandoBool  = LogicaTangerine.Fabrica.FabricaComandos.ComandoBorrarPropuesta(laPropuesta2);
            confirmacion = comandoBool.Ejecutar();
        }
예제 #6
0
        /// <summary>
        /// Método que devuelve el usuario por defecto para un empleado
        /// </summary>
        /// <returns>Retorna el usuario por defecto</returns>
        public override string Ejecutar()
        {
            string usuarioNuevo = "";

            try
            {
                _nombre   = _nombre.ToLower();
                _apellido = _apellido.ToLower();

                LogicaTangerine.Comando <String> commandObtenerNombre   = FabricaComandos.obtenerCaracteres(_nombre, 2);
                LogicaTangerine.Comando <String> commandObtenerApellido = FabricaComandos.obtenerCaracteres(_apellido, 4);

                //Obtiene los 2 primeros caracteres del nombre
                usuarioNuevo = commandObtenerNombre.Ejecutar();
                //Obtiene los 4 primeros caracteres del apellido
                usuarioNuevo = usuarioNuevo + commandObtenerApellido.Ejecutar();
            }
            catch (NullReferenceException ex)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);
                throw new ExceptionM2Tangerine("Ingreso de un argumento con valor invalido", ex);
            }
            catch (Exception ex)
            {
                Logger.EscribirError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name, ex);
                throw new ExceptionM2Tangerine("DS-202", "Metodo no implementado", ex);
            }

            return(usuarioNuevo);
        }
        public void TestModificarRequerimiento()
        {
            elRequerimiento2 = new DominioTangerine.Entidades.M6.Requerimiento("NombreRequerimiento1",
                                                                               "DescripcionRequerimientoPrueba1Modificado", "NombrePropuestaPrueba");
            //Se inserta la propuesta
            comandoBool = LogicaTangerine.Fabrica.FabricaComandos.ComandoAgregarPropuesta(laPropuesta);
            Assert.IsTrue(comandoBool.Ejecutar());
            //Agregar un Requerimiento y pruebo que se agregó
            comandoBool = LogicaTangerine.Fabrica.FabricaComandos.ComandoAgregarRequerimiento(elRequerimiento);
            Assert.IsTrue(comandoBool.Ejecutar());
            //Modifico el requerimiento
            comandoBool = LogicaTangerine.Fabrica.FabricaComandos.ComandoModificarRequerimiento(elRequerimiento2);
            Assert.IsTrue(comandoBool.Ejecutar());
            //Consulto el requerimiento modificado
            comandoListEntidad  = LogicaTangerine.Fabrica.FabricaComandos.ComandoConsultarRequerimientoXPropuesta(laPropuesta);
            listaRequerimientos = comandoListEntidad.Ejecutar();
            Assert.AreEqual("NombreRequerimiento1",
                            ((DominioTangerine.Entidades.M6.Requerimiento)listaRequerimientos.ElementAt(0)).CodigoRequerimiento);
            Assert.AreEqual("DescripcionRequerimientoPrueba1Modificado",
                            ((DominioTangerine.Entidades.M6.Requerimiento)listaRequerimientos.ElementAt(0)).Descripcion);
            Assert.AreEqual("NombrePropuestaPrueba",
                            ((DominioTangerine.Entidades.M6.Requerimiento)listaRequerimientos.ElementAt(0)).CodigoPropuesta);

            //Elimino la propuesta de prueba junto con el requerimiento
            comandoBool  = LogicaTangerine.Fabrica.FabricaComandos.ComandoBorrarPropuesta(laPropuesta);
            confirmacion = comandoBool.Ejecutar();
        }
 public void TestConsultarRequerimientosXPropuesta()
 {
     elRequerimiento2 = new DominioTangerine.Entidades.M6.Requerimiento("NombreRequerimiento1",
                                                                        "DescripcionRequerimientoPrueba", "NombrePropuestaPrueba");
     elRequerimiento3 = new DominioTangerine.Entidades.M6.Requerimiento("NombreRequerimiento2",
                                                                        "DescripcionRequerimientoPrueba2", "NombrePropuestaPrueba");
     //Se inserta la propuesta
     comandoBool = LogicaTangerine.Fabrica.FabricaComandos.ComandoAgregarPropuesta(laPropuesta);
     Assert.IsTrue(comandoBool.Ejecutar());
     //Agregar un Requerimiento y pruebo que se agregó
     comandoBool = LogicaTangerine.Fabrica.FabricaComandos.ComandoAgregarRequerimiento(elRequerimiento);
     Assert.IsTrue(comandoBool.Ejecutar());
     comandoBool = LogicaTangerine.Fabrica.FabricaComandos.ComandoAgregarRequerimiento(elRequerimiento2);
     Assert.IsTrue(comandoBool.Ejecutar());
     comandoBool = LogicaTangerine.Fabrica.FabricaComandos.ComandoAgregarRequerimiento(elRequerimiento3);
     Assert.IsTrue(comandoBool.Ejecutar());
     comandoListEntidad  = LogicaTangerine.Fabrica.FabricaComandos.ComandoConsultarRequerimientoXPropuesta(laPropuesta);
     listaRequerimientos = comandoListEntidad.Ejecutar();
     foreach (Entidad requerimiento in listaRequerimientos)
     {
         Assert.AreEqual(((DominioTangerine.Entidades.M6.Requerimiento)requerimiento).CodigoPropuesta,
                         "NombrePropuestaPrueba");
     }
     //Elimino la propuesta de prueba junto con los requerimientos
     comandoBool  = LogicaTangerine.Fabrica.FabricaComandos.ComandoBorrarPropuesta(laPropuesta);
     confirmacion = comandoBool.Ejecutar();
 }
        public void TestComandoVerificarAccesoAOpciones()
        {
            List <String> listaResultado;

            LogicaTangerine.Comando <List <String> > commandVerificarAccesoAOpciones =
                FabricaComandos.obtenerComandoVerificarAccesoAOpciones("Gerente");
            listaResultado = commandVerificarAccesoAOpciones.Ejecutar();
            Assert.IsNotEmpty(listaResultado);
        }
        public void TestComandoVerificarAccesoAPagina()
        {
            bool resultado;

            LogicaTangerine.Comando <Boolean> commandVerificarAccesoAPagina =
                FabricaComandos.obtenerComandoVerificarAccesoAPagina("../../GUI/M2/RegistroUsuario.aspx", "Programador");
            resultado = commandVerificarAccesoAPagina.Ejecutar();
            Assert.IsNotNull(resultado);
        }
        public void TestPresentadorClientePotencial()
        {
            comandoRespuesta = LogicaTangerine.Fabrica.FabricaComandos.ObtenerComandoAgregarClientePotencial(elCliente1);
            Assert.IsTrue(comandoRespuesta.Ejecutar());

            Assert.False(presentadorAgregar.VerificarDatosDeCliente("Prueba",
                                                                    "J-121212121212-4", "*****@*****.**"));

            comandoRespuesta = LogicaTangerine.Fabrica.FabricaComandos.ObtenerComandoEliminarClientePotencial(elCliente1);
            Assert.IsTrue(comandoRespuesta.Ejecutar());
        }
        public void TestConsultaTodasPropuesta()
        {
            //Se inserta la propuesta para tener un minimo
            comandoListEntidad = LogicaTangerine.Fabrica.FabricaComandos.ComandoConsultarPropuestaXProyecto();
            comandoEntidad     = LogicaTangerine.Fabrica.FabricaComandos.ComandoConsultarXIdPropuesta(laPropuesta);
            comandoBool        = LogicaTangerine.Fabrica.FabricaComandos.ComandoAgregarPropuesta(laPropuesta);

            confirmacion = comandoBool.Ejecutar();
            //Se cuentan la cantidad de propuestas
            comandoListEntidad = LogicaTangerine.Fabrica.FabricaComandos.ComandoConsultarTodosPropuesta();
            listaPropuestas    = comandoListEntidad.Ejecutar();
            //Se almacena el tamaño de la estructura de propuestas
            int cantidadPropuestas = listaPropuestas.Count;

            comandoListEntidad = LogicaTangerine.Fabrica.FabricaComandos.CrearConsultarCompaniasActivas();
            //Se obtienen las compañías activas
            List <Entidad> companias = comandoListEntidad.Ejecutar();
            //Se crea una estructura de datos
            ArrayList idscompaniasactivas = new ArrayList();

            //Se llena la estructura de datos con los ids de las compañias activas
            foreach (Entidad compania in companias)
            {
                idscompaniasactivas.Add(((DominioTangerine.Entidades.M4.CompaniaM4)compania).Id.ToString());
            }
            //Se inicializa un contador para las propuestas
            contador = 0;
            //Se recorre la estructura con las propuestas y se cuentan las propuestas que cuyo id de compañía estén en la estructura anteriormente creada
            foreach (Entidad propuesta in listaPropuestas)
            {
                if (idscompaniasactivas.Contains(((DominioTangerine.Entidades.M6.Propuesta)propuesta).IdCompañia))
                {
                    //Se verifica que los campos no estén en null
                    Assert.NotNull(((DominioTangerine.Entidades.M6.Propuesta)propuesta).Descripcion);
                    Assert.NotNull(((DominioTangerine.Entidades.M6.Propuesta)propuesta).TipoDuracion);
                    Assert.NotNull(((DominioTangerine.Entidades.M6.Propuesta)propuesta).CantDuracion);
                    Assert.NotNull(((DominioTangerine.Entidades.M6.Propuesta)propuesta).Acuerdopago);
                    Assert.NotNull(((DominioTangerine.Entidades.M6.Propuesta)propuesta).Estatus);
                    Assert.NotNull(((DominioTangerine.Entidades.M6.Propuesta)propuesta).Moneda);
                    Assert.NotNull(((DominioTangerine.Entidades.M6.Propuesta)propuesta).Entrega);
                    Assert.NotNull(((DominioTangerine.Entidades.M6.Propuesta)propuesta).Feincio);
                    Assert.NotNull(((DominioTangerine.Entidades.M6.Propuesta)propuesta).Fefinal);
                    Assert.NotNull(((DominioTangerine.Entidades.M6.Propuesta)propuesta).Costo);
                    Assert.NotNull(((DominioTangerine.Entidades.M6.Propuesta)propuesta).IdCompañia);
                    contador++;
                }
            }
            //Se verifica que la totalidad de las propuestas en la estructura de datos pertenezcan a una compañia activa
            Assert.AreEqual(cantidadPropuestas, contador);
            //Elimino la propuesta de prueba
            comandoBool  = LogicaTangerine.Fabrica.FabricaComandos.ComandoBorrarPropuesta(laPropuesta);
            confirmacion = comandoBool.Ejecutar();
        }
예제 #13
0
        public void TestComandoObtenerCaracteres()
        {
            String resultado, resultado2;
            String testPrueba = "prueba";

            LogicaTangerine.Comando <String> commandObtenerCaracteres  = FabricaComandos.obtenerCaracteres(testPrueba, 2);
            LogicaTangerine.Comando <String> commandObtenerCaracteres2 = FabricaComandos.obtenerCaracteres("", 2);
            resultado  = commandObtenerCaracteres.Ejecutar();
            resultado2 = commandObtenerCaracteres2.Ejecutar();
            Assert.AreEqual("pr", resultado);
            Assert.IsEmpty(resultado2);
        }
예제 #14
0
        public void TestComandoConsultarUltimoIDEmpleado()
        {
            bool resultado;

            LogicaTangerine.Comando <Boolean> commandAgregarUsuario = FabricaComandos.agregarUsuario(elUsuario1);
            resultado = commandAgregarUsuario.Ejecutar();
            Assert.IsTrue(resultado);
            LogicaTangerine.Comando <int> commandConsultarUltimoIDEmpleado = FabricaComandos.consultarIDUltimoEmpleado();
            int lastID = commandConsultarUltimoIDEmpleado.Ejecutar();

            Assert.IsTrue(lastID > 0);
        }
        /// <summary>
        /// Carga en la tabla todos los empleados
        /// </summary>
        public void iniciarVista()
        {
            try
            {
                _vista.empleado = null;
                LogicaTangerine.Comando <List <Entidad> > theComando = LogicaTangerine.Fabrica.FabricaComandos.ConsultarEmpleados();
                List <Entidad> listaDeEmpleados = theComando.Ejecutar();

                foreach (Entidad theEmpleador in listaDeEmpleados)
                {
                    DominioTangerine.Entidades.M10.EmpleadoM10         empleador         = (DominioTangerine.Entidades.M10.EmpleadoM10)theEmpleador;
                    LogicaTangerine.Comando <DominioTangerine.Entidad> theComandoObtener =
                        LogicaTangerine.Fabrica.FabricaComandos.obtenerUsuario(empleador.emp_id);
                    DominioTangerine.Entidad theUser             = theComandoObtener.Ejecutar();
                    DominioTangerine.Entidades.M2.UsuarioM2 user = (DominioTangerine.Entidades.M2.UsuarioM2)theUser;

                    _vista.empleado += ResourceGUIM2.OpenTR;
                    _vista.empleado += ResourceGUIM2.OpenTD + empleador.emp_p_nombre + ResourceGUIM2.CloseTD;
                    _vista.empleado += ResourceGUIM2.OpenTD + empleador.emp_p_apellido + ResourceGUIM2.CloseTD;
                    if (user.nombreUsuario != null)
                    {
                        _vista.empleado += ResourceGUIM2.OpenTD + user.nombreUsuario + ResourceGUIM2.CloseTD;
                        _vista.empleado += ResourceGUIM2.OpenTD + user.rol.nombre + ResourceGUIM2.CloseTD;
                        _vista.empleado += ResourceGUIM2.OpenTD + ResourceGUIM2.llamadoNuevaPagina + empleador.emp_id +
                                           ResourceGUIM2.CloseBotonParametro + ResourceGUIM2.BotonModificar + empleador.emp_id +
                                           ResourceGUIM2.CloseBotonParametro + ResourceGUIM2.CloseTD;
                        _vista.empleado += ResourceGUIM2.CloseTR;
                    }
                    else
                    {
                        _vista.empleado += ResourceGUIM2.OpenTD + " " + ResourceGUIM2.CloseTD;
                        _vista.empleado += ResourceGUIM2.OpenTD + " " + ResourceGUIM2.CloseTD;
                        _vista.empleado += ResourceGUIM2.OpenTD + ResourceGUIM2.Botonblock +
                                           ResourceGUIM2.CloseBotonParametroDesactivado + ResourceGUIM2.BotonModificarBlock +
                                           ResourceGUIM2.CloseBotonParametroDesactivado + ResourceGUIM2.CloseTD;
                        _vista.empleado += ResourceGUIM2.CloseTR;
                    }
                }
            }
            catch (ExcepcionesTangerine.M2.ExceptionM2Tangerine ex)
            {
                _vista.alertaClase = ResourceGUIM2.alertaError;
                _vista.alertaRol   = ResourceGUIM2.tipoAlerta;
                _vista.alerta      = ResourceGUIM2.alertaHtml + ex.Message + ResourceGUIM2.alertaHtmlFinal;
            }
            catch (ExcepcionesTangerine.ExceptionTGConBD e)
            {
                _vista.alertaClase = ResourceGUIM2.alertaError;
                _vista.alertaRol   = ResourceGUIM2.tipoAlerta;
                _vista.alerta      = ResourceGUIM2.alertaHtml + e.Message + ResourceGUIM2.alertaHtmlFinal;
            }
        }
        public void TestComandoModificarRol()
        {
            bool resultado, resultado2;

            LogicaTangerine.Comando <Boolean> commandAgregarUsuario = FabricaComandos.agregarUsuario(elUsuario);
            resultado = commandAgregarUsuario.Ejecutar();
            Assert.IsTrue(resultado);
            DominioTangerine.Entidades.M2.UsuarioM2 theUsuario          = (DominioTangerine.Entidades.M2.UsuarioM2)elUsuario;
            LogicaTangerine.Comando <Boolean>       commandModificarRol = FabricaComandos.obtenerComandoModificarRol(theUsuario.nombreUsuario,
                                                                                                                     theUsuario.rol.nombre);
            resultado2 = commandModificarRol.Ejecutar();
            Assert.IsTrue(resultado2);
        }
        public void TestComandoModificarRolUsuario()
        {
            bool resultado, resultado2;

            LogicaTangerine.Comando <Boolean> commandAgregarUsuario = FabricaComandos.agregarUsuario(elUsuario);
            resultado = commandAgregarUsuario.Ejecutar();
            Assert.IsTrue(resultado);
            elUsuario = DominioTangerine.Fabrica.FabricaEntidades.crearUsuarioCompleto("Daniel", "1234", new DateTime(2015, 2, 10),
                                                                                       "Activo", elRol1, 1);
            LogicaTangerine.Comando <Boolean> commandModificarRolUsuario = FabricaComandos.obtenerComandoModificarRolUsuario(elUsuario);
            resultado2 = commandModificarRolUsuario.Ejecutar();
            Assert.IsTrue(resultado2);
        }
예제 #18
0
        public void TestComandoAgregarUsuario()
        {
            bool resultado;

            LogicaTangerine.Comando <Boolean> commandAgregarUsuario = FabricaComandos.agregarUsuario(elUsuario);
            resultado = commandAgregarUsuario.Ejecutar();
            Assert.IsTrue(resultado);
            IDAOUsuarios daoUsuario = DatosTangerine.Fabrica.FabricaDAOSqlServer.crearDaoUsuario();

            elUsuario2 = DominioTangerine.Fabrica.FabricaEntidades.crearUsuarioCompletoConID(daoUsuario.ConsultLastUserID(),
                                                                                             "Daniel", "1234", new DateTime(2015, 2, 10), "Activo", elRol, 1);
            DominioTangerine.Entidades.M2.UsuarioM2 theUsuario2 = (DominioTangerine.Entidades.M2.UsuarioM2)elUsuario2;
            answer = daoUsuario.BorrarUsuario(theUsuario2.Id);
        }
 public void TestConsultaRequerimientoXId()
 {
     //Se inserta el requerimiento
     comandoBool = LogicaTangerine.Fabrica.FabricaComandos.ComandoAgregarRequerimiento(elRequerimiento);
     Assert.IsTrue(comandoBool.Ejecutar());
     comandoEntidad   = LogicaTangerine.Fabrica.FabricaComandos.ComandoConsultarXIdRequerimiento(elRequerimiento);
     elRequerimiento2 = (DominioTangerine.Entidades.M6.Requerimiento)comandoEntidad.Ejecutar();
     Assert.AreEqual(elRequerimiento.CodigoRequerimiento, elRequerimiento2.CodigoRequerimiento);
     Assert.AreEqual(elRequerimiento.Descripcion, elRequerimiento2.Descripcion);
     Assert.AreEqual(elRequerimiento.CodigoPropuesta, elRequerimiento2.CodigoPropuesta);
     //Elimino el requerimiento
     comandoBool  = LogicaTangerine.Fabrica.FabricaComandos.ComandoEliminarRequerimiento(elRequerimiento);
     confirmacion = comandoBool.Ejecutar();
 }
        public void TestComandoObtenerRolUsuario()
        {
            bool resultado;

            LogicaTangerine.Comando <Boolean> commandAgregarUsuario = FabricaComandos.agregarUsuario(elUsuario);
            resultado = commandAgregarUsuario.Ejecutar();
            Assert.IsTrue(resultado);
            elUsuario = DominioTangerine.Fabrica.FabricaEntidades.crearUsuarioCompleto("Daniel", "1234", new DateTime(2015, 2, 10),
                                                                                       "Activo", elRol1, 1);
            LogicaTangerine.Comando <DominioTangerine.Entidad> commandObtenerRolUsuario
                = FabricaComandos.obtenerComandoObtenerRolUsuario(2);
            DominioTangerine.Entidad            theRol = commandObtenerRolUsuario.Ejecutar();
            DominioTangerine.Entidades.M2.RolM2 rol    = (DominioTangerine.Entidades.M2.RolM2)theRol;
            Assert.IsNotNull(rol);
        }
예제 #21
0
 /// <summary>
 /// Registra el usuario en la Base de Datos
 /// </summary>
 public bool registrar()
 {
     try
     {
         LogicaTangerine.Comando <Boolean> theComando = LogicaTangerine.Fabrica.FabricaComandos.prepararUsuario(_vista.usuario,
                                                                                                                _vista.contrasena, _vista.comboRol, _numFicha);
         return(theComando.Ejecutar());
     }
     catch (ExcepcionesTangerine.M2.ExceptionM2Tangerine ex)
     {
         _vista.alertaClase = ResourceGUIM2.alertaError;
         _vista.alertaRol   = ResourceGUIM2.tipoAlerta;
         _vista.alerta      = ResourceGUIM2.alertaHtml + ex.Message + ResourceGUIM2.alertaHtmlFinal;
         return(false);
     }
 }
예제 #22
0
 /// <summary>
 /// Asigna un nuevo nombre de usuario al usuario en cuestión
 /// </summary>
 public bool asignar()
 {
     try
     {
         LogicaTangerine.Comando <Boolean> theComando =
             LogicaTangerine.Fabrica.FabricaComandos.modificarUsuario(int.Parse(_vista.fichaEmpleado), _vista.nombreUsuario);
         return(theComando.Ejecutar());
     }
     catch (ExcepcionesTangerine.M2.ExceptionM2Tangerine ex)
     {
         _vista.alertaClase   = ResourceGUIM2.alertaError;
         _vista.alertaUsuario = ResourceGUIM2.tipoAlerta;
         _vista.alerta        = ResourceGUIM2.alertaHtml + ex.Message + ResourceGUIM2.alertaHtmlFinal;
         return(false);
     }
 }
예제 #23
0
 /// <summary>
 /// Asigna un nuevo rol al usuario en cuestión
 /// </summary>
 public bool asignar()
 {
     try
     {
         LogicaTangerine.Comando <Boolean> theComando =
             LogicaTangerine.Fabrica.FabricaComandos.obtenerComandoModificarRol(_vista.usuario, _vista.comboBoxRol);
         return(theComando.Ejecutar());
     }
     catch (ExcepcionesTangerine.M2.ExceptionM2Tangerine ex)
     {
         _vista.alertaClase = ResourceGUIM2.alertaError;
         _vista.alertaRol   = ResourceGUIM2.tipoAlerta;
         _vista.alerta      = ResourceGUIM2.alertaHtml + ex.Message + ResourceGUIM2.alertaHtmlFinal;
         return(false);
     }
 }
        public void TestComandoObtenerOpciones()
        {
            bool resultado;

            LogicaTangerine.Comando <Boolean> commandAgregarUsuario = FabricaComandos.agregarUsuario(elUsuario);
            resultado = commandAgregarUsuario.Ejecutar();
            Assert.IsTrue(resultado);
            elUsuario = DominioTangerine.Fabrica.FabricaEntidades.crearUsuarioCompleto("Daniel", "1234", new DateTime(2015, 2, 10),
                                                                                       "Activo", elRol1, 1);
            LogicaTangerine.Comando <DominioTangerine.Entidad> commandObtenerOpciones
                = FabricaComandos.obtenerComandoObtenerOpciones("Gestión de Pagos", 2);
            DominioTangerine.Entidad theResultado = commandObtenerOpciones.Ejecutar();
            DominioTangerine.Entidades.M2.ListaGenericaM2 <DominioTangerine.Entidades.M2.OpcionM2> lista
                = (DominioTangerine.Entidades.M2.ListaGenericaM2 <DominioTangerine.Entidades.M2.OpcionM2>)theResultado;
            Assert.IsNotEmpty(lista);
        }
예제 #25
0
        /// <summary>
        /// Método que inicia la vista de la página registrar usuario
        /// </summary>
        public void inicioVista()
        {
            try
            {
                _vista.tablaEmpleado = null;
                LogicaTangerine.Comando <List <Entidad> > theComando = LogicaTangerine.Fabrica.FabricaComandos.ConsultarEmpleados();
                List <Entidad> listaDeEmpleados = theComando.Ejecutar();
                foreach (Entidad theEmpleado in listaDeEmpleados)
                {
                    DominioTangerine.Entidades.M10.EmpleadoM10 empleado            = (DominioTangerine.Entidades.M10.EmpleadoM10)theEmpleado;
                    LogicaTangerine.Comando <Boolean>          theComandoVerificar =
                        LogicaTangerine.Fabrica.FabricaComandos.verificarUsuario(empleado.emp_id);
                    _vista.tablaEmpleado += ResourceGUIM2.OpenTR;
                    _vista.tablaEmpleado += ResourceGUIM2.OpenTD + empleado.Emp_p_nombre + ResourceGUIM2.CloseTD;
                    _vista.tablaEmpleado += ResourceGUIM2.OpenTD + empleado.Emp_p_apellido + ResourceGUIM2.CloseTD;
                    _vista.tablaEmpleado += ResourceGUIM2.OpenTD + empleado.Emp_cedula + ResourceGUIM2.CloseTD;
                    _vista.tablaEmpleado += ResourceGUIM2.OpenTD + empleado.jobs.Nombre + ResourceGUIM2.CloseTD;

                    if (!theComandoVerificar.Ejecutar())
                    {
                        _vista.tablaEmpleado += ResourceGUIM2.OpenTD + ResourceGUIM2.BotonRegNuevaVentana + empleado.emp_id +
                                                ResourceGUIM2.NombreEmpleado + empleado.emp_p_nombre + ResourceGUIM2.ApellidoEmpleado +
                                                empleado.emp_p_apellido + ResourceGUIM2.RolEmpleado + empleado.jobs.Nombre +
                                                ResourceGUIM2.CloseBotonParametro + ResourceGUIM2.CloseTD;
                    }
                    else
                    {
                        _vista.tablaEmpleado += ResourceGUIM2.OpenTD + ResourceGUIM2.BotonRegBlock +
                                                ResourceGUIM2.CloseBotonParametroDesactivado + ResourceGUIM2.CloseTD;
                    }

                    _vista.tablaEmpleado += ResourceGUIM2.CloseTR;
                }
            }
            catch (ExcepcionesTangerine.M2.ExceptionM2Tangerine ex)
            {
                _vista.alertaClase = ResourceGUIM2.alertaError;
                _vista.alertaRol   = ResourceGUIM2.tipoAlerta;
                _vista.alerta      = ResourceGUIM2.alertaHtml + ex.Message + ResourceGUIM2.alertaHtmlFinal;
            }
            catch (ExcepcionesTangerine.ExceptionTGConBD e)
            {
                _vista.alertaClase = ResourceGUIM2.alertaError;
                _vista.alertaRol   = ResourceGUIM2.tipoAlerta;
                _vista.alerta      = ResourceGUIM2.alertaHtml + e.Message + ResourceGUIM2.alertaHtmlFinal;
            }
        }
예제 #26
0
 /// <summary>
 /// Metodo que inicializa la vista de AccionRegistrar generando un nombre usuario
 /// </summary>
 public void inicioVista()
 {
     try
     {
         _vista.ficha    = _numFicha.ToString();
         _vista.comboRol = _rol;
         LogicaTangerine.Comando <String> theComando =
             LogicaTangerine.Fabrica.FabricaComandos.crearUsuario(_nombreUser, _apellidoUser);
         _vista.usuario = theComando.Ejecutar();
     }
     catch (ExcepcionesTangerine.M2.ExceptionM2Tangerine ex)
     {
         _vista.alertaClase = ResourceGUIM2.alertaError;
         _vista.alertaRol   = ResourceGUIM2.tipoAlerta;
         _vista.alerta      = ResourceGUIM2.alertaHtml + ex.Message + ResourceGUIM2.alertaHtmlFinal;
     }
 }
예제 #27
0
 /// <summary>
 /// Verificar si el nombre de usuario ya existe en la BD.
 /// </summary>
 /// <returns>Retorna un valor booleano indicando si el usuario ya existe</returns>
 public bool usuarioExistente()
 {
     try
     {
         bool respuesta = false;
         LogicaTangerine.Comando <Boolean> comando = LogicaTangerine.Fabrica.FabricaComandos.validarUsuario(_vista.nombreUsuario);
         respuesta = comando.Ejecutar();
         return(respuesta);
     }
     catch (ExcepcionesTangerine.M2.ExceptionM2Tangerine ex)
     {
         _vista.alertaClase   = ResourceGUIM2.alertaError;
         _vista.alertaUsuario = ResourceGUIM2.tipoAlerta;
         _vista.alerta        = ResourceGUIM2.alertaHtml + ex.Message + ResourceGUIM2.alertaHtmlFinal;
         return(false);
     }
 }
예제 #28
0
        public void TestComandoCrearUsuarioDefault()
        {
            String resultado, resultado2;

            LogicaTangerine.Comando <String> commandCrearUsuarioDefault  = FabricaComandos.crearUsuario("gianfranco", "berlino");
            LogicaTangerine.Comando <String> commandCrearUsuarioDefault2 = FabricaComandos.crearUsuario("", "");
            resultado  = commandCrearUsuarioDefault.Ejecutar();
            resultado2 = commandCrearUsuarioDefault2.Ejecutar();
            Assert.AreEqual(usuarioDefault, resultado);
            Assert.IsEmpty(resultado2);
            IDAOUsuarios daoUsuario = DatosTangerine.Fabrica.FabricaDAOSqlServer.crearDaoUsuario();

            elUsuario2 = DominioTangerine.Fabrica.FabricaEntidades.crearUsuarioCompletoConID(daoUsuario.ConsultLastUserID(), "Daniel",
                                                                                             "1234", new DateTime(2015, 2, 10), "Activo", elRol, 1);
            DominioTangerine.Entidades.M2.UsuarioM2 theUsuario2 = (DominioTangerine.Entidades.M2.UsuarioM2)elUsuario2;
            answer = daoUsuario.BorrarUsuario(theUsuario2.Id);
        }
예제 #29
0
 /// <summary>
 /// Inicio de vista de la página de Cambiar Usuario
 /// </summary>
 public void inicioVista()
 {
     try
     {
         LogicaTangerine.Comando <DominioTangerine.Entidad> theComando =
             LogicaTangerine.Fabrica.FabricaComandos.obtenerUsuario(_numFicha);
         DominioTangerine.Entidad theUser             = theComando.Ejecutar();
         DominioTangerine.Entidades.M2.UsuarioM2 user = (DominioTangerine.Entidades.M2.UsuarioM2)theUser;
         _vista.fichaEmpleado = _numFicha.ToString();
         _vista.nombreUsuario = user.nombreUsuario;
     }
     catch (ExcepcionesTangerine.M2.ExceptionM2Tangerine ex)
     {
         _vista.alertaClase   = ResourceGUIM2.alertaError;
         _vista.alertaUsuario = ResourceGUIM2.tipoAlerta;
         _vista.alerta        = ResourceGUIM2.alertaHtml + ex.Message + ResourceGUIM2.alertaHtmlFinal;
     }
 }
        public void TestPresentadorModificarClientePotencial()
        {
            comandoRespuesta = LogicaTangerine.Fabrica.FabricaComandos.ObtenerComandoAgregarClientePotencial(elCliente1);
            Assert.IsTrue(comandoRespuesta.Ejecutar());

            comandoNumero = LogicaTangerine.Fabrica.FabricaComandos.ObtenerComandoUltimoIdClientePotencial();
            elCliente1.Id = comandoNumero.Ejecutar();

            comandoRespuesta = LogicaTangerine.Fabrica.FabricaComandos.ObtenerComandoAgregarClientePotencial(elCliente2);
            Assert.IsTrue(comandoRespuesta.Ejecutar());

            Assert.False(presentadorModificar.VerificarDatosDeCliente("Prueba2",
                                                                      "J-121212121212-4", "*****@*****.**", elCliente1.Id));

            comandoRespuesta = LogicaTangerine.Fabrica.FabricaComandos.ObtenerComandoEliminarClientePotencial(elCliente1);
            Assert.IsTrue(comandoRespuesta.Ejecutar());

            comandoRespuesta = LogicaTangerine.Fabrica.FabricaComandos.ObtenerComandoEliminarClientePotencial(elCliente2);
            Assert.IsTrue(comandoRespuesta.Ejecutar());
        }