Example #1
0
        /// <summary>
        /// Carga todos los datos a la lista para que se testeen
        /// </summary>
        public void CargaDeDatos()
        {
            Mueble sillaMaderaRoble     = new Madera("silla de madera", 3, (float)2.6, 38, 32, 29, eColor.Rojo, eTipoDeMadera.Roble);
            Mueble sillaMaderaRoble2    = new Madera("Silla de madera", 7, (float)2.6, 38, 32, 29, eColor.Rojo, eTipoDeMadera.Roble);
            Mueble mesaMaderaAbedul     = new Madera("Mesa de madera", 9, (float)8.7, 65, 51, 44, eColor.Negro, eTipoDeMadera.Abedul);
            Mueble escritorioMaderaPino = new Madera("Escritorio de madera", 5, (float)6.9, 46, 40, 38, eColor.Sin, eTipoDeMadera.Pino);
            Mueble sillaMetalAluminio   = new Metal("Silla de aluminio", 1, (float)4.4, 41, 34, 25, eColor.Violeta, eTipoDeMetal.Aluminio);//Deberia setear el color en Sin
            Mueble mesaMetalAcero       = new Metal("Mesa de acero", 2, (float)9.9, 66, 49, 41, eColor.Verde, eTipoDeMetal.Acero);
            Mueble mesaVidrio           = new Vidrio("Mesa de vidrio", 4, (float)7.6, 61, 47, 43);

            Fabrica.AgregarMueble = sillaMaderaRoble;
            Fabrica.AgregarMueble = sillaMaderaRoble2;
            Fabrica.AgregarMueble = mesaMaderaAbedul;
            Fabrica.AgregarMueble = escritorioMaderaPino;
            Fabrica.AgregarMueble = sillaMetalAluminio;
            Fabrica.AgregarMueble = mesaMetalAcero;
            Fabrica.AgregarMueble = mesaVidrio;

            Mueble mesaVidrio2 = new Vidrio();   //Por defecto, no deberia dejar de agregar a la lista
            Mueble mesaMadera  = new Madera();   //Por defecto, no deberia dejar de agregar a la lista
            Mueble sillaMetal  = new Metal();    //Por defecto, no deberia dejar de agregar a la lista

            Fabrica.AgregarMueble = mesaVidrio2; //NO SE AGREGA A LA LISTA
            Fabrica.AgregarMueble = mesaMadera;  //NO SE AGREGA A LA LISTA
            Fabrica.AgregarMueble = sillaMetal;  //NO SE AGREGA A LA LISTA
        }
Example #2
0
        /// <summary>
        /// Crea el tipo de producto apropiado conforme a lo ingresado en el formulario
        /// </summary>
        /// <returns></returns>
        private void CargarCamposProducto()
        {
            ETipoMadera tipoMaderaPrincipal = (ETipoMadera)cmbMaderaPrincipal.SelectedItem;
            ETipoTela   tipoTela            = (ETipoTela)cmbTipoTela.SelectedItem;
            EColor      colorTela           = (EColor)cmbColorTela.SelectedItem;

            Madera maderaPrincipal;
            Tela   telaProducto;

            if (rbTorre.Checked)
            {
                maderaPrincipal = new Madera(tipoMaderaPrincipal, EForma.Tablon, Fabrica.CANTIDAD_MADERA_TORRE_PRINCIPAL);
                telaProducto    = new Tela(colorTela, tipoTela, Fabrica.CANTIDAD_TELA_TORRE);
                EModeloTorre modeloTorre       = (EModeloTorre)cmbModeloTorre.SelectedItem;
                ETipoMadera  tipoMaderaColumna = (ETipoMadera)cmbMaderaColumna.SelectedItem;

                Madera maderaColumna = new Madera(tipoMaderaColumna, EForma.Tubo, 1);

                if (chkYute.Checked)
                {
                    int metrosYute = (int)nudCantidadYute.Value;
                    bufferProducto = new Torre(maderaPrincipal, telaProducto, modeloTorre, maderaColumna, metrosYute);
                }
                else
                {
                    bufferProducto = new Torre(maderaPrincipal, telaProducto, modeloTorre, maderaColumna);
                }
            }
            else
            {
                maderaPrincipal = new Madera(tipoMaderaPrincipal, EForma.Tablon, Fabrica.CANTIDAD_MADERA_ESTANTE);
                telaProducto    = new Tela(colorTela, tipoTela, Fabrica.CANTIDAD_TELA_ESTANTE);
                bufferProducto  = new Estante(maderaPrincipal, telaProducto, (int)nudCantidadEstantes.Value);
            }
        }
Example #3
0
        public void MueblesIguales()
        {
            //ARRANGE
            Madera madera1 = new Madera("Silla", 2, 8, 22, 33, 12, eColor.Rojo, eTipoDeMadera.Roble);
            Madera madera2 = new Madera("Silla", 2, 8, 22, 33, 12, eColor.Rojo, eTipoDeMadera.Roble);
            Metal  metal1  = new Metal("Mesa", 4, 9, 20, 37, 12, eColor.Rojo, eTipoDeMetal.Acero);
            Metal  metal2  = new Metal("Mesa", 9, 9, 20, 37, 12, eColor.Rojo, eTipoDeMetal.Acero);
            Vidrio vidrio1 = new Vidrio("Mesa", 11, 3, 25, 31, 11);
            Vidrio vidrio2 = new Vidrio("Mesa", 5, 3, 25, 31, 11);
            bool   resultado;

            //ACT
            resultado = madera1 == madera2;

            //ASSERT
            Assert.IsTrue(resultado);

            //ACT
            resultado = metal1 == metal2;

            //ASSERT
            Assert.IsTrue(resultado);

            //ACT
            resultado = vidrio1 == vidrio2;

            //ASSERT
            Assert.IsTrue(resultado);
        }
        public void Setup()
        {
            red     = new Red(10);
            bomb    = new Bomb(10);
            chuck   = new Chuck(10, 50);
            matilda = new Matilda(10);
            terence = new Terence(10);
            comunes = new PajarosComunes(10);

            pajaros = new List <Pajaros> {
                red, bomb, chuck, matilda, comunes, terence
            };

            huevo = new Huevos(1000);

            obreros = new CerditosObreros();
            madera  = new Madera(20);
            piedra  = new Piedra(5);

            obstaculos = new List <Obstaculo> {
                obreros, madera, piedra
            };

            isla = new IslaPajaro(pajaros, obstaculos);
        }
Example #5
0
        public void Initialize()
        {
            ceramica1 = new Ceramica(0.5);
            ceramica2 = new Ceramica(0.5);
            ceramica3 = new Ceramica(1.0);
            madera1   = new Madera(3, EMadera.Arce);
            madera2   = new Madera(3, EMadera.Arce);
            madera3   = new Madera(2, EMadera.Cedro);
            madera4   = new Madera(2, EMadera.Arce);
            vidrio1   = new Vidrio(0.6, EVidrio.Comun);
            vidrio2   = new Vidrio(0.6, EVidrio.Comun);
            vidrio3   = new Vidrio(0.6, EVidrio.Empañado);
            vidrio4   = new Vidrio(1.2, EVidrio.Comun);
            plastico1 = new Plastico(0.5);
            plastico2 = new Plastico(0.5);
            plastico3 = new Plastico(1.0);
            metal1    = new Metal(3.2, EMetal.Acero_Inoxidable);
            metal2    = new Metal(3.2, EMetal.Acero_Inoxidable);
            metal3    = new Metal(1.2, EMetal.Bronze);
            metal4    = new Metal(1.2, EMetal.Acero_Inoxidable);

            materiales1 = new List <Material>();
            materiales2 = new List <Material>();
            materiales3 = new List <Material>();
            materiales4 = new List <Material>();
            materiales5 = new List <Material>();

            materiales1.Add(ceramica1);
            materiales1.Add(vidrio1);
            materiales1.Add(plastico1);
            materiales1.Add(metal1);
            materiales1.Add(madera1);

            materiales2.Add(ceramica1);
            materiales2.Add(vidrio1);
            materiales2.Add(plastico1);
            materiales2.Add(metal1);
            materiales2.Add(madera1);

            materiales3.Add(metal1);
            materiales3.Add(madera1);
            materiales3.Add(ceramica1);
            materiales3.Add(vidrio1);
            materiales3.Add(plastico1);

            materiales4.Add(metal1);
            materiales4.Add(madera1);
            materiales4.Add(ceramica1);
            materiales4.Add(vidrio1);

            materiales5.Add(ceramica2);
            materiales5.Add(vidrio2);
            materiales5.Add(plastico2);
            materiales5.Add(metal4);
            materiales5.Add(madera3);
        }
Example #6
0
        /// <summary>
        /// Genera un Producto del tipo torre para hacer pruebas
        /// </summary>
        /// <returns></returns>
        public Producto getTorreValido()
        {
            Madera maderaProducto           = new Madera(ETipoMadera.Mdf, EForma.Tablon, 4);
            Madera maderaSecundariaProducto = new Madera(ETipoMadera.Mdf, EForma.Tubo, 3);
            Tela   telaProducto             = new Tela(EColor.Bordo, ETipoTela.Alfombra, 3);

            Producto output = new Torre(maderaProducto, telaProducto, Torre.EModeloTorre.King, maderaSecundariaProducto);

            return(output);
        }
Example #7
0
        /// <summary>
        /// Genera una fabrica con tres productos válidos para utilizarse en las pruebas de fabricación
        /// </summary>
        /// <returns></returns>
        public Fabrica getFabricaCompleta()
        {
            Fabrica fabrica = Fabrica.Instance;

            fabrica.ResetearFabrica();

            Insumo maderaUno        = new Madera(ETipoMadera.Mdf, EForma.Tablon, 100);
            Insumo maderaDos        = new Madera(ETipoMadera.Pino, EForma.Tablon, 200);
            Insumo maderaSecundaria = new Madera(ETipoMadera.Mdf, EForma.Tubo, 100);
            Insumo telaUno          = new Tela(EColor.Bordo, ETipoTela.Alfombra, 100);
            Insumo telaDos          = new Tela(EColor.Rosa, ETipoTela.Corderito, 200);

            Insumo adicionalUno  = new InsumoAccesorio(ETipoAccesorio.Barniz, 300);
            Insumo adicionalDos  = new InsumoAccesorio(ETipoAccesorio.Tornillo, 300);
            Insumo adicionalTres = new InsumoAccesorio(ETipoAccesorio.Pegamento, 300);

            List <Insumo> insumosAgregar = new List <Insumo>();

            insumosAgregar.Add(adicionalUno);
            insumosAgregar.Add(adicionalDos);
            insumosAgregar.Add(adicionalTres);
            insumosAgregar.Add(maderaUno);
            insumosAgregar.Add(maderaDos);

            insumosAgregar.Add(maderaSecundaria);
            insumosAgregar.Add(telaUno);
            insumosAgregar.Add(telaDos);

            Madera maderaProductoUno        = new Madera(ETipoMadera.Mdf, EForma.Tablon, 4);
            Madera maderaSecundariaProducto = new Madera(ETipoMadera.Mdf, EForma.Tubo, 3);
            Tela   telaProducto             = new Tela(EColor.Bordo, ETipoTela.Alfombra, 3);


            List <Insumo> faltantes    = new List <Insumo>();
            Producto      productoUno  = new Torre(new Madera(ETipoMadera.Mdf, EForma.Tablon, Fabrica.CANTIDAD_MADERA_TORRE_PRINCIPAL), new Tela(EColor.Bordo, ETipoTela.Alfombra, Fabrica.CANTIDAD_TELA_TORRE), Torre.EModeloTorre.King, new Madera(ETipoMadera.Mdf, EForma.Tubo, Fabrica.CANTIDAD_MADERA_TORRE_COLUMNA));
            Producto      productoDos  = new Torre(new Madera(ETipoMadera.Pino, EForma.Tablon, Fabrica.CANTIDAD_MADERA_TORRE_PRINCIPAL), new Tela(EColor.Rosa, ETipoTela.Corderito, Fabrica.CANTIDAD_TELA_TORRE), Torre.EModeloTorre.King, new Madera(ETipoMadera.Mdf, EForma.Tubo, Fabrica.CANTIDAD_MADERA_TORRE_COLUMNA));
            Producto      productoTres = new Estante(new Madera(ETipoMadera.Mdf, EForma.Tablon, Fabrica.CANTIDAD_MADERA_ESTANTE), new Tela(EColor.Rosa, ETipoTela.Corderito, Fabrica.CANTIDAD_TELA_ESTANTE), 3);

            fabrica.AgregarInsumosAStock(insumosAgregar);


            fabrica.AgregarProductoLineaProduccion(productoUno, out faltantes);
            fabrica.AgregarProductoLineaProduccion(productoDos, out faltantes);
            fabrica.AgregarProductoLineaProduccion(productoTres, out faltantes);

            return(fabrica);
        }
Example #8
0
        public void Retorna_True_Cuando_Recibe_Un_Producto_Con_Stock_Suficiente_Y_Elimina_Insumos_Del_Stock_Original()
        {
            // Arrange

            int    cantidadMaderaPrincipal  = 0;
            int    cantidadMaderaSecundaria = 0;
            int    cantidadTela             = 0;
            Insumo maderaUno        = new Madera(ETipoMadera.Mdf, EForma.Tablon, 10);
            Insumo maderaSecundaria = new Madera(ETipoMadera.Mdf, EForma.Tubo, 5);
            Insumo telaUno          = new Tela(EColor.Bordo, ETipoTela.Alfombra, 15);

            List <Insumo> faltantes = new List <Insumo>();

            Fabrica fabrica = getFabricaTest(true);

            Producto productoValido = getTorreValido();

            //Act

            bool resultado = fabrica.AgregarProductoLineaProduccion(productoValido, out faltantes);


            //Assert



            foreach (Insumo i in fabrica.ServicioInsumo.GetAll())
            {
                if (i == maderaUno)
                {
                    cantidadMaderaPrincipal += i.Cantidad;
                }
                else if (i == maderaSecundaria)
                {
                    cantidadMaderaSecundaria += i.Cantidad;
                }
                else if (i == telaUno)
                {
                    cantidadTela += i.Cantidad;
                }
            }
            Assert.IsTrue(resultado);
            Assert.AreEqual(6, cantidadMaderaPrincipal);
            Assert.AreEqual(2, cantidadMaderaSecundaria);
            Assert.AreEqual(12, cantidadTela);
        }
Example #9
0
 private void cmbOpciones_SelectedIndexChanged(object sender, EventArgs e)
 {
     cmbOpciones.Enabled = false;
     indiceOpciones      = cmbOpciones.SelectedIndex;
     if (cmbCategoria.SelectedIndex == 0)
     {
         miMetal           = (Metal)almacenMetal[cmbOpciones.SelectedIndex];
         txtbDensidad.Text = Convert.ToString(miMetal.Densidad);
         cmbMedidas.Text   = miMetal.Medidas;
     }
     if (cmbCategoria.SelectedIndex == 1)
     {
         miMadera          = (Madera)almacenMadera[cmbOpciones.SelectedIndex];
         txtbDensidad.Text = Convert.ToString(miMadera.Densidad);
         cmbMedidas.Text   = miMadera.Medidas;
     }
 }
Example #10
0
        /// <summary>
        /// Obtiene todos los registros de la tabla Torre
        /// </summary>
        /// <returns></returns>
        public override List <Torre> GetAll()
        {
            List <Torre> torres = new List <Torre>();

            try
            {
                SqlConnection connection = new SqlConnection(connectionString);



                connection.Open();

                SqlCommand command = new SqlCommand();
                command.CommandType = System.Data.CommandType.Text;
                command.Connection  = connection;

                command.CommandText = string.Format($"SELECT * FROM {table}");

                SqlDataReader dataReader = command.ExecuteReader();

                while (dataReader.Read() != false)
                {
                    Torre torre = new Torre();
                    torre.Id              = Convert.ToInt32(dataReader["id"]);
                    torre.EstadoProducto  = (EEstado)Enum.Parse(typeof(EEstado), dataReader["estadoProducto"].ToString());
                    torre.MaderaPrincipal = maderasRepo.GetById(Convert.ToInt32(dataReader["idMaderaPrincipal"]));
                    torre.TelaProducto    = telasRepo.GetById(Convert.ToInt32(dataReader["idTelaProducto"]));
                    Madera madera = maderasRepo.GetById(Convert.ToInt32(dataReader["idMaderaColumna"]));
                    torre.MaderaColumna = madera;
                    torre.MetrosYute    = Convert.ToInt32(dataReader["metrosYute"]);
                    torre.Modelo        = (EModeloTorre)Enum.Parse(typeof(EModeloTorre), dataReader["modelo"].ToString());
                    torre.YuteInstalado = Convert.ToBoolean(dataReader["yuteInstalado"]);
                    torres.Add(torre);
                }
                dataReader.Close();
                connection.Close();
            }
            catch (Exception e)
            {
                throw new Exception();
            }
            return(torres);
        }
Example #11
0
        public override void Create(Torre entity)
        {
            int columnasAfectadas = 0;

            try
            {
                using (SqlConnection connection = new SqlConnection(connectionString))
                {
                    Madera bufferMaderaPrincipal = entity.MaderaPrincipal;
                    Madera bufferMaderaColumna   = entity.MaderaColumna;
                    Tela   bufferTelaPrincipal   = entity.TelaProducto;


                    maderasRepo.Create(bufferMaderaPrincipal);
                    bufferMaderaPrincipal = maderasRepo.GetById(maderasRepo.GetMaxId());
                    maderasRepo.Create(bufferMaderaColumna);
                    bufferMaderaColumna = maderasRepo.GetById(maderasRepo.GetMaxId());
                    telasRepo.Create(bufferTelaPrincipal);
                    bufferTelaPrincipal = telasRepo.GetById(telasRepo.GetMaxId());

                    connection.Open();

                    SqlCommand command = new SqlCommand();
                    command.CommandType = System.Data.CommandType.Text;
                    command.Connection  = connection;

                    command.CommandText = $"INSERT INTO [{table}] ([estadoProducto], [idMaderaPrincipal], [idTelaProducto], [idMaderaColumna], [metrosYute], [modelo], [yuteInstalado])" + "Values (@estadoProducto, @idMaderaPrincipal, @idTelaProducto, @idMaderaColumna, @metrosYute, @modelo, @YuteInstalado)";
                    command.Parameters.AddWithValue("@estadoProducto", entity.EstadoProducto);
                    command.Parameters.AddWithValue("@idMaderaPrincipal", bufferMaderaPrincipal.Id);
                    command.Parameters.AddWithValue("@idTelaProducto", bufferTelaPrincipal.Id);
                    command.Parameters.AddWithValue("@idMaderaColumna", bufferMaderaColumna.Id);
                    command.Parameters.AddWithValue("@metrosYute", entity.MetrosYute);
                    command.Parameters.AddWithValue("@modelo", entity.Modelo);
                    command.Parameters.AddWithValue("@yuteInstalado", entity.YuteInstalado);
                    columnasAfectadas = command.ExecuteNonQuery();
                }
            }
            catch (Exception e)
            {
                throw new Exception();
            }
        }
Example #12
0
        public void TestearAgregarMueble()
        {
            //ARRANGE
            Madera madera    = new Madera("Silla", 2, 8, 22, 33, 12, eColor.Rojo, eTipoDeMadera.Roble);
            bool   resultado = false;

            //ACT
            Fabrica.AgregarMueble = madera;

            foreach (Mueble mueble in Fabrica.Muebles)
            {
                if (mueble.Equals(madera))
                {
                    resultado            = true;
                    Fabrica.QuitarMueble = madera;
                    break;
                }
            }

            //ASSERT
            Assert.IsTrue(resultado);
        }
        static void Main(string[] args)
        {
            Mueble sillaMaderaRoble     = new Madera("silla de madera", 3, (float)2.6, 38, 32, 29, eColor.Rojo, eTipoDeMadera.Roble);
            Mueble sillaMaderaRoble2    = new Madera("Silla de madera", 7, (float)2.6, 38, 32, 29, eColor.Rojo, eTipoDeMadera.Roble);
            Mueble mesaMaderaAbedul     = new Madera("Mesa de madera", 9, (float)8.7, 65, 51, 44, eColor.Negro, eTipoDeMadera.Abedul);
            Mueble escritorioMaderaPino = new Madera("Escritorio de madera", 5, (float)6.9, 46, 40, 38, eColor.Sin, eTipoDeMadera.Pino);
            Mueble sillaMetalAluminio   = new Metal("Silla de aluminio", 1, (float)4.4, 41, 34, 25, eColor.Violeta, eTipoDeMetal.Aluminio);//Deberia setear el color en Sin
            Mueble mesaMetalAcero       = new Metal("Mesa de acero", 2, (float)9.9, 66, 49, 41, eColor.Verde, eTipoDeMetal.Acero);
            Mueble mesaVidrio           = new Vidrio("Mesa de vidrio", 4, (float)7.6, 61, 47, 43);

            Fabrica.AgregarMueble = sillaMaderaRoble;
            Fabrica.AgregarMueble = sillaMaderaRoble2;
            Console.WriteLine(Fabrica.RetornarInformacionTotal());
            Fabrica.AgregarMueble = mesaMaderaAbedul;
            Fabrica.AgregarMueble = escritorioMaderaPino;
            Fabrica.AgregarMueble = sillaMetalAluminio;
            Fabrica.AgregarMueble = mesaMetalAcero;
            Fabrica.AgregarMueble = mesaVidrio;

            Console.WriteLine(sillaMetalAluminio.Facturacion());
            Console.WriteLine(sillaMaderaRoble.Facturacion());
            Console.WriteLine(mesaVidrio.Facturacion());
            Console.WriteLine(Fabrica.RetornarInformacionTotal());

            Mueble mesaVidrio2 = new Vidrio(); //Por defecto, no deberia dejar de agregar a la lista
            Mueble mesaMadera  = new Madera(); //Por defecto, no deberia dejar de agregar a la lista
            Mueble sillaMetal  = new Metal();  //Por defecto, no deberia dejar de agregar a la lista

            Fabrica.Muebles.Clear();           //Limpiamos para probar los muebles invalidos
            Console.WriteLine(mesaVidrio2);
            Console.WriteLine(mesaMadera);
            Console.WriteLine(sillaMetal);
            Fabrica.AgregarMueble = mesaVidrio2;                   //NO SE AGREGA A LA LISTA
            Fabrica.AgregarMueble = mesaMadera;                    //NO SE AGREGA A LA LISTA
            Fabrica.AgregarMueble = sillaMetal;                    //NO SE AGREGA A LA LISTA
            Console.WriteLine(Fabrica.RetornarInformacionTotal()); //No deberia retornar nada.
            Console.Read();
        }
Example #14
0
        /// <summary>
        /// Este método es utilizado para preparar una fabrica para los test de dar de alta un producto, con la variable si stockPegamentoCompleto es true, habrá
        /// suficiente stock para dar de alta una torre, en el caso de que sea false no lo habrá
        /// </summary>
        /// <param name="stockPegamentoCompleto"></param>
        /// <returns></returns>
        public Fabrica getFabricaTest(bool stockPegamentoCompleto)
        {
            Fabrica fabrica = Fabrica.Instance;

            fabrica.LanzarEventos = false;
            fabrica.ResetearFabrica();
            Insumo adicionalTres;
            Insumo maderaUno        = new Madera(ETipoMadera.Mdf, EForma.Tablon, 10);
            Insumo maderaSecundaria = new Madera(ETipoMadera.Mdf, EForma.Tubo, 5);
            Insumo telaUno          = new Tela(EColor.Bordo, ETipoTela.Alfombra, 15);

            Insumo adicionalUno = new InsumoAccesorio(ETipoAccesorio.Barniz, 6);
            Insumo adicionalDos = new InsumoAccesorio(ETipoAccesorio.Tornillo, 24);

            if (stockPegamentoCompleto)
            {
                adicionalTres = new InsumoAccesorio(ETipoAccesorio.Pegamento, 6);
            }
            else
            {
                adicionalTres = new InsumoAccesorio(ETipoAccesorio.Pegamento, 1);
            }


            List <Insumo> insumosAgregar = new List <Insumo>();

            insumosAgregar.Add(adicionalUno);
            insumosAgregar.Add(adicionalDos);
            insumosAgregar.Add(adicionalTres);
            insumosAgregar.Add(maderaUno);
            insumosAgregar.Add(maderaSecundaria);
            insumosAgregar.Add(telaUno);

            fabrica.AgregarInsumosAStock(insumosAgregar);

            return(fabrica);
        }
Example #15
0
        /// <summary>
        /// Inserta en la BD un Producto del tipo Estante
        /// </summary>
        /// <param name="entity"></param>
        public override void Create(Estante entity)
        {
            int columnasAfectadas = 0;

            try
            {
                using (SqlConnection connection = new SqlConnection(connectionString))
                {
                    Madera bufferMaderaPrincipal = entity.MaderaPrincipal;
                    Tela   bufferTelaPrincipal   = entity.TelaProducto;

                    maderasRepo.Create(bufferMaderaPrincipal);
                    telasRepo.Create(bufferTelaPrincipal);

                    bufferMaderaPrincipal = maderasRepo.GetById(maderasRepo.GetMaxId());
                    bufferTelaPrincipal   = telasRepo.GetById(telasRepo.GetMaxId());

                    connection.Open();

                    SqlCommand command = new SqlCommand();
                    command.CommandType = System.Data.CommandType.Text;
                    command.Connection  = connection;

                    command.CommandText = $"INSERT INTO [{table}] ([estadoProducto], [idMaderaProducto], [idTelaProducto], [cantidadEstantes])" + "Values (@estadoProducto, @idMaderaProducto, @idTelaProducto, @cantidadEstantes)";
                    command.Parameters.AddWithValue("@estadoProducto", entity.EstadoProducto);
                    command.Parameters.AddWithValue("@idMaderaProducto", bufferMaderaPrincipal.Id);
                    command.Parameters.AddWithValue("@idTelaProducto", bufferTelaPrincipal.Id);
                    command.Parameters.AddWithValue("@cantidadEstantes", entity.CantidadEstantes);
                    columnasAfectadas = command.ExecuteNonQuery();
                }
            }
            catch (Exception e)
            {
                throw new Exception();
            }
        }
Example #16
0
        static void Main(string[] args)
        {
            Console.Title = "Seghesio, Marcos Daniel TP3 2D";


            Console.WriteLine("-----------------------------------------------------------------------");
            Console.WriteLine("----------Fabrica de Productos para Gatos: demostración Consola--------");
            Console.WriteLine("-----------------------------------------------------------------------");


            Console.WriteLine("------------PRESIONE UNA TECLA PARA CONTINUAR--------------------------");
            Console.ReadKey();


            // Declarar los objetos necesarios para leer archivos XML

            FabricaXmlService serviceXmlFabrica = new FabricaXmlService($"{AppDomain.CurrentDomain.BaseDirectory}Origen\\");
            Fabrica           fabrica           = serviceXmlFabrica.ReadXmlFabrica();

            Console.WriteLine("\n-----------------------------------------------------------------------");
            Console.WriteLine("------------Atributos asignados a fabrica correctamente----------------");
            Console.WriteLine("-----------------------------------------------------------------------");


            Console.WriteLine("-----------------------------------------------------------------------");
            Console.WriteLine("---------------------Iterar lista de insumos --------------------------");
            Console.WriteLine("-----------------------------------------------------------------------");


            foreach (Insumo i in fabrica.StockInsumos)
            {
                Console.WriteLine(i.Mostrar());
            }

            Console.Write("------------PRESIONE UNA TECLA PARA CONTINUAR--------------------------");
            Console.ReadKey();
            Console.Clear();

            //1- Usuario Ingresa insumos a fabrica existente

            Console.WriteLine("-----------------------------------------------------------------------");
            Console.WriteLine("---------------------Agregar nuevos Insumos----------------------------");
            Console.WriteLine("-----------------------------------------------------------------------");

            List <Insumo> insumosAgregar = new List <Insumo>();

            Insumo maderaUno        = new Madera(ETipoMadera.Pino, EForma.Tablon, 10);
            Insumo maderaSecundaria = new Madera(ETipoMadera.Pino, EForma.Tubo, 5);
            Insumo telaUno          = new Tela(EColor.Rosa, ETipoTela.Alfombra, 15);


            Insumo adicionalUno    = new InsumoAccesorio(ETipoAccesorio.Barniz, 10);
            Insumo adicionalDos    = new InsumoAccesorio(ETipoAccesorio.Tornillo, 24);
            Insumo adicionalTres   = new InsumoAccesorio(ETipoAccesorio.Pegamento, 10);
            Insumo adicionalCuatro = new InsumoAccesorio(ETipoAccesorio.Yute, 10);



            insumosAgregar += maderaUno;
            insumosAgregar += maderaUno;
            insumosAgregar += maderaSecundaria;
            insumosAgregar += telaUno;
            insumosAgregar += adicionalUno;
            insumosAgregar += adicionalDos;
            insumosAgregar += adicionalTres;
            insumosAgregar += adicionalCuatro;

            insumosAgregar += maderaUno;

            fabrica.AgregarInsumosAStock(insumosAgregar);

            Console.WriteLine("-----------------------------------------------------------------------");
            Console.WriteLine("-------Insumos agregados con éxito-------------------------------------");
            Console.WriteLine("-----------------------------------------------------------------------");

            Console.WriteLine("--Se itera de nuevo el stock de insumos----------------------------");
            foreach (Insumo i in fabrica.StockInsumos)
            {
                Console.WriteLine(i.Mostrar());
            }

            Console.Write("------------PRESIONE UNA TECLA PARA CONTINUAR--------------------------");
            Console.WriteLine("\n-----------------------------------------------------------------------");
            Console.ReadKey();
            Console.Clear();


            //2- Usuario da de alta un producto para agregar a la linea de producción

            Console.WriteLine("\n-----------------------------------------------------------------------");
            Console.WriteLine("--------Se van a cargar dos nuevos productos---------------------------");
            Console.WriteLine("-----------------------------------------------------------------------");

            Producto      productoTorre   = new Torre(new Madera(ETipoMadera.Mdf, EForma.Tablon, Fabrica.CANTIDAD_MADERA_TORRE_PRINCIPAL), new Tela(EColor.Bordo, ETipoTela.Alfombra, Fabrica.CANTIDAD_TELA_TORRE), Torre.EModeloTorre.Queen, new Madera(ETipoMadera.Pino, EForma.Tubo, Fabrica.CANTIDAD_MADERA_TORRE_COLUMNA), 3);
            Producto      productoEstante = new Estante(new Madera(ETipoMadera.Pino, EForma.Tablon, Fabrica.CANTIDAD_MADERA_ESTANTE), new Tela(EColor.Rosa, ETipoTela.Alfombra, Fabrica.CANTIDAD_TELA_ESTANTE), 5);
            List <Insumo> faltantes       = new List <Insumo>();

            Console.WriteLine("-----------------------------------------------------------------------");
            Console.WriteLine("-----Productos cargados, se procedera a iterar-------------------------");
            Console.WriteLine("-----------------------------------------------------------------------");

            fabrica.AgregarProductoLineaProduccion(productoTorre, out faltantes);
            fabrica.AgregarProductoLineaProduccion(productoEstante, out faltantes);

            foreach (Producto p in fabrica.LineaProduccion)
            {
                Console.WriteLine(p.Mostrar());
            }
            Console.Write("------------PRESIONE UNA TECLA PARA CONTINUAR--------------------------");

            Console.ReadKey();
            Console.Clear();


            Console.WriteLine("-----------------------------------------------------------------------");
            Console.WriteLine("---Se van a ejecutar los procesos de la fábrica en orden---------------");
            Console.Write("------------PRESIONE UNA TECLA PARA CONTINUAR--------------------------");
            Console.ReadKey();


            Console.WriteLine("\n-----------------------------------------------------------------------");


            Console.WriteLine("----------------Lijar Maderas------------------------------------------");

            //3- Ejecutar procesos de linea de Producción

            fabrica.EjecutarProcesoLineaProduccion(EProceso.Lijar);

            foreach (Producto p in fabrica.LineaProduccion)
            {
                Console.WriteLine(p.Mostrar());
            }
            Console.Write("------------PRESIONE UNA TECLA PARA CONTINUAR--------------------------");
            Console.ReadKey();
            Console.Clear();
            Console.WriteLine("\n----------------Barnizar---------------------------------------------");

            fabrica.EjecutarProcesoLineaProduccion(EProceso.Barnizar);

            foreach (Producto p in fabrica.LineaProduccion)
            {
                Console.WriteLine(p.Mostrar());
            }
            Console.Write("------------PRESIONE UNA TECLA PARA CONTINUAR--------------------------");
            Console.ReadKey();
            Console.Clear();
            Console.WriteLine("\n----------------Alfombrar--------------------------------------------");

            fabrica.EjecutarProcesoLineaProduccion(EProceso.Alfombrar);

            foreach (Producto p in fabrica.LineaProduccion)
            {
                Console.WriteLine(p.Mostrar());
            }
            Console.Write("------------PRESIONE UNA TECLA PARA CONTINUAR--------------------------");
            Console.ReadKey();
            Console.Clear();

            Console.WriteLine("\n----------------Agregar Yute-----------------------------------------");
            fabrica.EjecutarProcesoLineaProduccion(EProceso.AgregarYute);

            foreach (Producto p in fabrica.LineaProduccion)
            {
                Console.WriteLine(p.Mostrar());
            }
            Console.Write("------------PRESIONE UNA TECLA PARA CONTINUAR--------------------------");

            Console.ReadKey();
            Console.Clear();
            Console.WriteLine("\n----------------Ensamblar--------------------------------------------");
            fabrica.EjecutarProcesoLineaProduccion(EProceso.Ensamblar);

            foreach (Producto p in fabrica.LineaProduccion)
            {
                Console.WriteLine(p.Mostrar());
            }
            Console.Write("------------PRESIONE UNA TECLA PARA CONTINUAR--------------------------");
            Console.ReadKey();
            Console.Clear();



            // 4 - Mudar productos terminados de la linea de producción al stock de productos terminados

            Console.WriteLine("-------------------------------------------------------------------------");
            Console.WriteLine("--Mudar productos terminados  al stock de productos terminados-----------");
            Console.WriteLine("-------------------------------------------------------------------------");


            fabrica.MudarProductosAStockTerminado();
            Console.WriteLine("-----------------------------------------------------------------------");
            Console.WriteLine("--------Iterar lista de productos terminados de la fabrica-------------");
            Console.WriteLine("-----------------------------------------------------------------------");


            foreach (Producto p in fabrica.StockProductosTerminados)
            {
                Console.WriteLine(p.Mostrar());
            }

            Console.Write("------------PRESIONE UNA TECLA PARA CONTINUAR--------------------------");
            Console.ReadKey();
            Console.Clear();


            // 5 - Guardar datos de fábrica en archivos XML
            Console.WriteLine("\n-----------------------------------------------------------------------");
            Console.WriteLine("----------------Persistir atributos de fábrica en archivos XML---------");
            Console.WriteLine("-----------------------------------------------------------------------");


            try
            {
                serviceXmlFabrica.Path = $"{AppDomain.CurrentDomain.BaseDirectory}Destino\\";
                serviceXmlFabrica.SaveXmlFabrica(fabrica);
                Console.WriteLine("-----------------------------------------------------------------------");
                Console.WriteLine("----------------Datos guardados correctamente -------------------------");
                Console.WriteLine("-----------------------------------------------------------------------");
            }
            catch (SaveFactoryException e)
            {
                Console.WriteLine("-----------------------------------------------------------------------");
                Console.WriteLine("----------------Errores al guardar los datos --------------------------");
                Console.WriteLine("-----------------------------------------------------------------------");
            }
        }
Example #17
0
        static void Main(string[] args)
        {
            #region Materiales

            ceramica1 = new Ceramica(0.5);
            ceramica2 = new Ceramica(1.5);
            ceramica3 = new Ceramica(2.0);
            madera1   = new Madera(3, EMadera.Arce);
            madera2   = new Madera(6, EMadera.Arce);
            madera3   = new Madera(10, EMadera.Cedro);
            madera4   = new Madera(2, EMadera.Arce);
            vidrio1   = new Vidrio(1, EVidrio.Comun);
            vidrio2   = new Vidrio(1, EVidrio.Comun);
            vidrio3   = new Vidrio(2, EVidrio.Empañado);
            vidrio4   = new Vidrio(3, EVidrio.Comun);
            plastico1 = new Plastico(0.5);
            plastico2 = new Plastico(3.5);
            plastico3 = new Plastico(1.0);
            metal1    = new Metal(3, EMetal.Acero_Inoxidable);
            metal2    = new Metal(2, EMetal.Acero_Inoxidable);
            metal3    = new Metal(10, EMetal.Bronze);
            metal4    = new Metal(3, EMetal.Hierro);
            tela1     = new Tela(3);

            maderaFabrica1 = new Madera(10, EMadera.Fresno);
            maderaFabrica2 = new Madera(10, EMadera.Arce);
            maderaFabrica3 = new Madera(10, EMadera.Cedro);
            maderaFabrica4 = new Madera(10, EMadera.Nogal);
            maderaFabrica5 = new Madera(10, EMadera.Pino);
            maderaFabrica6 = new Madera(10, EMadera.Roble);

            vidrioFabrica1 = new Vidrio(10, EVidrio.Comun);
            vidrioFabrica2 = new Vidrio(10, EVidrio.Empañado);
            vidrioFabrica3 = new Vidrio(10, EVidrio.Espejo);
            vidrioFabrica4 = new Vidrio(10, EVidrio.Impreso);
            vidrioFabrica5 = new Vidrio(10, EVidrio.Traslucido);

            metalFabrica1 = new Metal(10, EMetal.Acero_Inoxidable);
            metalFabrica2 = new Metal(10, EMetal.Bronze);
            metalFabrica3 = new Metal(10, EMetal.Hierro);

            ceramicaFabrica1 = new Ceramica(10);
            plasticoFabrica1 = new Plastico(10);
            telaFabrica1     = new Tela(10);

            #endregion
            #region Dimensiones

            d1 = new Dimensiones(140, 45, 34);
            d2 = new Dimensiones(40, 45, 34);
            #endregion
            #region Listas de Materiales

            materiales1 = new List <Material>();
            materiales2 = new List <Material>();

            materiales1.Add(ceramica1);
            materiales1.Add(vidrio1);
            materiales1.Add(plastico1);
            materiales1.Add(metal1);
            materiales1.Add(madera1);

            materiales2.Add(ceramica3);
            materiales2.Add(vidrio4);
            materiales2.Add(plastico1);
            materiales2.Add(metal4);
            #endregion
            #region Colores

            colores1 = new EColor[] { EColor.Natural, EColor.Negro, EColor.Rojo };
            colores2 = new EColor[] { EColor.Marron, EColor.Natural, EColor.Blanco, EColor.Gris_Claro };
            #endregion
            #region Mesas

            modeloM1 = new ModeloMesa(d1, "Mesa Redonda 2m", materiales1, EEspacio.Exterior, colores1);
            modeloM2 = new ModeloMesa(d1, "Mesa Redonda", materiales1, EEspacio.Exterior, colores2);

            modeloM3 = new ModeloMesa(d1, "Mesa Cuadrada", materiales1, EEspacio.Exterior, colores1);
            modeloM4 = new ModeloMesa(d2, "Mesa Redonda", materiales1, EEspacio.Exterior, colores1);
            modeloM5 = new ModeloMesa(d1, "Mesa Redonda", materiales1, EEspacio.Interior, colores1);
            modeloM6 = new ModeloMesa(d1, "Mesa Redonda", materiales1, EEspacio.Exterior, colores3);
            modeloM7 = new ModeloMesa(d1, "Mesa Redonda", materiales2, EEspacio.Exterior, colores1);
            modeloM8 = null;
            #endregion
            #region Estanterias

            modeloE1 = new ModeloEstanteria(d1, "Estanteria Doble 8x", materiales1, EEstanteria.Abierta, colores1, 0);
            modeloE2 = new ModeloEstanteria(d1, "Estanteria Doble", materiales1, EEstanteria.Abierta, colores1);
            modeloE3 = new ModeloEstanteria(d1, "Estanteria Doble", materiales1, EEstanteria.Abierta, colores1, 5);
            modeloE4 = new ModeloEstanteria(d1, "Estanteria Doble", materiales1, EEstanteria.Cerrada, colores1, 0);
            #endregion
            #region Placares

            modeloP1 = new ModeloPlacar(d1, "Placar Vidriado Emet Black", materiales1, colores1);
            modeloP2 = new ModeloPlacar(d1, "Placar", materiales1, colores1, 0);
            modeloP3 = new ModeloPlacar(d1, "Placar", materiales1, colores1, 2);
            #endregion
            #region Sillones
            modeloS1 = new ModeloSillon(d1, "Sillon moderno LL1", materiales1, colores1, 2);
            modeloS2 = new ModeloSillon(d1, "Sillon b", materiales1, colores1, 2);
            modeloS3 = new ModeloSillon(d1, "Sillon doble", materiales1, colores1, 2);
            #endregion

            #region comment

            #endregion
            Fabrica miFabrica = new Fabrica();

            Mueble m1 = new Mueble(modeloM1, new DateTime(2021, 5, 21, 18, 40, 00));
            Mueble m2 = new Mueble(modeloM1, new DateTime(2021, 6, 21, 18, 40, 00));
            Mueble e1 = new Mueble(modeloE1, new DateTime(2021, 7, 21, 18, 40, 00));
            Mueble e2 = new Mueble(modeloE1, new DateTime(2021, 8, 21, 18, 40, 00));
            Mueble p1 = new Mueble(modeloP1, new DateTime(2021, 9, 21, 18, 40, 00));
            Mueble p2 = new Mueble(modeloP1, new DateTime(2021, 10, 21, 18, 40, 00));
            Mueble s1 = new Mueble(modeloS1, new DateTime(2021, 11, 21, 18, 40, 00));
            Mueble s2 = new Mueble(modeloS1, new DateTime(2021, 12, 21, 18, 40, 00));

            miFabrica = miFabrica + maderaFabrica1;
            miFabrica = miFabrica + maderaFabrica2;
            miFabrica = miFabrica + maderaFabrica3;
            miFabrica = miFabrica + maderaFabrica4;
            miFabrica = miFabrica + maderaFabrica5;
            miFabrica = miFabrica + maderaFabrica6;
            miFabrica = miFabrica + metalFabrica1;
            miFabrica = miFabrica + metalFabrica2;
            miFabrica = miFabrica + metalFabrica3;
            miFabrica = miFabrica + vidrioFabrica1;
            miFabrica = miFabrica + vidrioFabrica2;
            miFabrica = miFabrica + vidrioFabrica3;
            miFabrica = miFabrica + vidrioFabrica4;
            miFabrica = miFabrica + vidrioFabrica5;
            miFabrica = miFabrica + ceramicaFabrica1;
            miFabrica = miFabrica + plasticoFabrica1;
            miFabrica = miFabrica + telaFabrica1;


            // Console.WriteLine("-------MATERIALES-----------");
            //Console.WriteLine( miFabrica.MostrarStockMateriales());
            //bool a = miFabrica - ceramica1;
            //a = miFabrica - madera3;
            //a = miFabrica - madera3;
            //a = miFabrica - vidrio2;
            //a = miFabrica - metal2;
            // Console.WriteLine(miFabrica.MostrarStockMateriales());



            //miFabrica += modeloS2; // no lo debe agregar
            //Console.WriteLine("-------MODELOS-----------");
            //Console.WriteLine(miFabrica.MostrarModelosDisponibles());
            //// quito:
            //bool a = miFabrica - modeloS1;
            // a = miFabrica - modeloS1; // no hace nada
            //Console.WriteLine(miFabrica.MostrarModelosDisponibles());
            //miFabrica += modeloS1; // lo vuelvo a agregar
            //Console.WriteLine(miFabrica.MostrarModelosDisponibles());
            // Console.WriteLine("-------MUEBLES-----------");

            miFabrica += modeloM1;
            miFabrica += modeloE1;
            miFabrica += modeloP1;
            miFabrica += modeloS1;

            miFabrica += m1;
            miFabrica.mueblesEnProduccion.Enqueue(m2);
            miFabrica += e1;
            miFabrica.mueblesEnProduccion.Enqueue(e2);
            miFabrica += p1;
            miFabrica.mueblesEnProduccion.Enqueue(p2);
            miFabrica += s1;
            miFabrica.mueblesEnProduccion.Enqueue(s2);

            //Console.WriteLine(miFabrica.MostrarMuebles());
            //bool a = miFabrica - p1;
            //a = miFabrica - p2;
            //a = miFabrica - s1;
            //a = miFabrica - s2;
            //Console.WriteLine("-------MUEBLES-----------");
            //Console.WriteLine(miFabrica.MostrarMuebles());

            //SERIALIZACIÓN Y DESERIALIZACIÓN

            //Console.WriteLine("MATERIALES ANTES DE DESERIALIZACION:");
            //Console.WriteLine(miFabrica.MostrarStockMateriales());
            //Console.ReadLine();

            List <Material> materialesDeFabrica   = new List <Material>();
            List <Modelo>   modelosDeFabrica      = new List <Modelo>();
            List <Mueble>   mueblesDeFabrica      = new List <Mueble>();
            List <Mueble>   queueMueblesDeFabrica = new List <Mueble>();

            //Serializer<Material>.DeserializeListXML(materialesDeFabrica, Globals.pathMateriales);
            //foreach (Material item in materialesDeFabrica)
            //{
            //    miFabrica += item;
            //}
            //Console.WriteLine("MODELOS ANTES DE DESERIALIZACION:");
            //Console.WriteLine(miFabrica.MostrarModelosDisponibles());
            //Console.ReadLine();
            //Serializer<Modelo>.DeserializeListXML(modelosDeFabrica, Globals.pathModelos);
            //foreach (Modelo item in modelosDeFabrica)
            //{
            //    miFabrica += item;
            //}

            //Serializer<Mueble>.DeserializeListXML(mueblesDeFabrica, Globals.pathStockMuebles);
            //foreach (Mueble item in mueblesDeFabrica)
            //{
            //    miFabrica += item;
            //}

            //Serializer<Mueble>.DeserializeListXML(mueblesDeFabrica, Globals.pathQueueMuebles);
            //foreach (Mueble item in mueblesDeFabrica)
            //{
            //    miFabrica.mueblesEnProduccion.Enqueue(item);
            //}

            Console.WriteLine("STOCK MUEBLES LUEGO DE DESERIALIZACION:");
            Console.WriteLine(miFabrica.MostrarMuebles());
            Console.ReadLine();

            Console.WriteLine("QUEUE MUEBLES LUEGO DE DESERIALIZACION:");
            Console.WriteLine(miFabrica.mueblesEnProduccion.Count);
            Console.ReadLine();

            Console.WriteLine("MODELOS LUEGO DE DESERIALIZACION:");
            Console.WriteLine(miFabrica.MostrarModelosDisponibles());
            Console.ReadLine();

            Console.WriteLine("MATERIALES LUEGO DE DESERIALIZACION:");
            Console.WriteLine(miFabrica.MostrarStockMateriales());
            Console.ReadLine();

            //SERIALIZACION:



            Serializer <Material> .nombraArchivo += Fabrica.GetNameForFile <Material>; //Material.GetNameForFile;
            if (Serializer <Material> .SerializeListXML(miFabrica.stockMateriales.Values.ToList(), Globals.pathMateriales))
            {
                Console.Write("GUARDADO CON EXITO");
            }
            else
            {
                Console.Write("NO PUDO GUARDAR");
            }
            Console.Read();


            Serializer <Material> .nombraArchivo -= Fabrica.GetNameForFile <Material>; //Material.GetNameForFile;
            Serializer <Modelo> .nombraArchivo   += Fabrica.GetNameForFile <Modelo>;   // Modelo.GetNameForFile;
            if (Serializer <Modelo> .SerializeListXML(miFabrica.modelosDisponibles.Values.ToList(), Globals.pathModelos))
            {
                Console.Write("GUARDADO CON EXITO");
            }
            else
            {
                Console.Write("NO PUDO GUARDAR");
            }
            Console.Read();

            Serializer <Modelo> .nombraArchivo -= Fabrica.GetNameForFile <Modelo>;
            Serializer <Mueble> .nombraArchivo += Fabrica.GetNameForFile <Mueble>;
            if (Serializer <Mueble> .SerializeListXML(miFabrica.stockMuebles, Globals.pathStockMuebles))
            {
                Console.Write("GUARDADO CON EXITO");
            }
            else
            {
                Console.Write("NO PUDO GUARDAR");
            }
            Console.Read();

            if (Serializer <Mueble> .SerializeListXML(miFabrica.mueblesEnProduccion.ToList(), Globals.pathQueueMuebles))
            {
                Console.Write("GUARDADO CON EXITO");
            }
            else
            {
                Console.Write("NO PUDO GUARDAR");
            }
            Console.Read();
        }
Example #18
0
        /// <summary>
        /// Crea una tabla para el stock de Insumos dando al posibilidad a elegir si es para Telas o Maderas
        /// </summary>
        /// <param name="listaInsumos">Listado de Insumos</param>
        /// <param name="tipoInforme">Tipo de informe a elegir entre Tela o Madera</param>
        /// <param name="standarFont">Fuente estándar</param>
        /// <returns></returns>
        private PdfPTable crearTablaInsumos(List <Insumo> listaInsumos, ETipoInforme tipoInforme, Font standarFont)
        {
            PdfPTable tblInsumo = new PdfPTable(4);

            string campo2;

            if (tipoInforme == ETipoInforme.Madera)
            {
                campo2 = "Forma";
            }
            else
            {
                campo2 = "Color";
            }
            PdfPCell clCampoUno = new PdfPCell(new Phrase("Tipo", standarFont));

            clCampoUno.BorderWidth = 0;
            clCampoUno.BorderWidth = 0.75f;

            PdfPCell clCampoDos = new PdfPCell(new Phrase(campo2, standarFont));

            clCampoDos.BorderWidth = 0;
            clCampoDos.BorderWidth = 0.75f;

            PdfPCell clCantidad = new PdfPCell(new Phrase("Cantidad", standarFont));

            clCantidad.BorderWidth = 0;
            clCantidad.BorderWidth = 0.75f;

            PdfPCell clFechaIngreso = new PdfPCell(new Phrase("Fecha de Ingreso", standarFont));

            clFechaIngreso.BorderWidth = 0;
            clFechaIngreso.BorderWidth = 0.75f;

            tblInsumo.AddCell(clCampoUno);
            tblInsumo.AddCell(clCampoDos);
            tblInsumo.AddCell(clCantidad);
            tblInsumo.AddCell(clFechaIngreso);

            foreach (Insumo insumo in listaInsumos)
            {
                if (tipoInforme == ETipoInforme.Madera && insumo is Madera)
                {
                    Madera madera = (Madera)insumo;

                    clCampoUno                 = new PdfPCell(new Phrase(madera.TipoMadera.ToString(), standarFont));
                    clCampoUno.BorderWidth     = 0;
                    clCampoDos                 = new PdfPCell(new Phrase(madera.Forma.ToString(), standarFont));
                    clCampoDos.BorderWidth     = 0;
                    clCantidad                 = new PdfPCell(new Phrase(madera.Cantidad.ToString(), standarFont));
                    clCantidad.BorderWidth     = 0;
                    clFechaIngreso             = new PdfPCell(new Phrase(madera.FechaIngreso.Date.ToString("MM/dd/yyyy"), standarFont));
                    clFechaIngreso.BorderWidth = 0;

                    tblInsumo.AddCell(clCampoUno);
                    tblInsumo.AddCell(clCampoDos);
                    tblInsumo.AddCell(clCantidad);
                    tblInsumo.AddCell(clFechaIngreso);
                }
                else if (tipoInforme == ETipoInforme.Tela && insumo is Tela)
                {
                    Tela tela = (Tela)insumo;

                    clCampoUno                 = new PdfPCell(new Phrase(tela.TipoTela.ToString(), standarFont));
                    clCampoUno.BorderWidth     = 0;
                    clCampoDos                 = new PdfPCell(new Phrase(tela.Color.ToString(), standarFont));
                    clCampoDos.BorderWidth     = 0;
                    clCantidad                 = new PdfPCell(new Phrase(tela.Cantidad.ToString(), standarFont));
                    clCantidad.BorderWidth     = 0;
                    clFechaIngreso             = new PdfPCell(new Phrase(tela.FechaIngreso.Date.ToString("MM/dd/yyyy"), standarFont));
                    clFechaIngreso.BorderWidth = 0;

                    tblInsumo.AddCell(clCampoUno);
                    tblInsumo.AddCell(clCampoDos);
                    tblInsumo.AddCell(clCantidad);
                    tblInsumo.AddCell(clFechaIngreso);
                }
            }
            return(tblInsumo);
        }
Example #19
0
        public void Initialize()
        {
            #region Materiales

            ceramica1 = new Ceramica(0.5);
            ceramica2 = new Ceramica(0.5);
            ceramica3 = new Ceramica(1.0);
            madera1   = new Madera(3, EMadera.Arce);
            madera2   = new Madera(3, EMadera.Arce);
            madera3   = new Madera(2, EMadera.Cedro);
            madera4   = new Madera(2, EMadera.Arce);
            vidrio1   = new Vidrio(0.6, EVidrio.Comun);
            vidrio2   = new Vidrio(0.6, EVidrio.Comun);
            vidrio3   = new Vidrio(0.6, EVidrio.Empañado);
            vidrio4   = new Vidrio(1.2, EVidrio.Comun);
            plastico1 = new Plastico(0.5);
            plastico2 = new Plastico(0.5);
            plastico3 = new Plastico(1.0);
            metal1    = new Metal(3.2, EMetal.Acero_Inoxidable);
            metal2    = new Metal(3.2, EMetal.Acero_Inoxidable);
            metal3    = new Metal(1.2, EMetal.Bronze);
            metal4    = new Metal(1.2, EMetal.Acero_Inoxidable);
            #endregion
            #region Dimensiones

            d1 = new Dimensiones(140, 45, 34);
            d2 = new Dimensiones(40, 45, 34);
            #endregion
            #region Listas de Materiales

            materiales1 = new List <Material>();
            materiales2 = new List <Material>();

            materiales1.Add(ceramica1);
            materiales1.Add(vidrio1);
            materiales1.Add(plastico1);
            materiales1.Add(metal1);
            materiales1.Add(madera1);

            materiales2.Add(ceramica3);
            materiales2.Add(vidrio4);
            materiales2.Add(plastico1);
            materiales2.Add(metal4);
            #endregion
            #region Colores

            colores1 = new EColor[] { EColor.Natural };
            colores2 = new EColor[] { EColor.Natural };
            colores3 = new EColor[] { EColor.Natural, EColor.Marron };
            colores4 = new EColor[] { EColor.Marron, EColor.Natural };
            colores5 = new EColor[] { };
            #endregion
            #region Mesas

            modeloM1 = new ModeloMesa(d1, "Mesa Redonda", materiales1, EEspacio.Exterior, colores1);
            modeloM2 = new ModeloMesa(d1, "Mesa Redonda", materiales1, EEspacio.Exterior, colores1);

            modeloM3 = new ModeloMesa(d1, "Mesa Cuadrada", materiales1, EEspacio.Exterior, colores1);
            modeloM4 = new ModeloMesa(d2, "Mesa Redonda", materiales1, EEspacio.Exterior, colores1);
            modeloM5 = new ModeloMesa(d1, "Mesa Redonda", materiales1, EEspacio.Interior, colores1);
            modeloM6 = new ModeloMesa(d1, "Mesa Redonda", materiales1, EEspacio.Exterior, colores3);
            modeloM7 = new ModeloMesa(d1, "Mesa Redonda", materiales2, EEspacio.Exterior, colores1);
            modeloM8 = null;
            #endregion
            #region Estanterias

            modeloE1 = new ModeloEstanteria(d1, "Estanteria Doble", materiales1, EEstanteria.Abierta, colores1, 0);
            modeloE2 = new ModeloEstanteria(d1, "Estanteria Doble", materiales1, EEstanteria.Abierta, colores1);
            modeloE3 = new ModeloEstanteria(d1, "Estanteria Doble", materiales1, EEstanteria.Abierta, colores1, 5);
            modeloE4 = new ModeloEstanteria(d1, "Estanteria Doble", materiales1, EEstanteria.Cerrada, colores1, 0);
            #endregion
            #region Placares

            modeloP1 = new ModeloPlacar(d1, "Placar", materiales1, colores1);
            modeloP2 = new ModeloPlacar(d1, "Placar", materiales1, colores1, 0);
            modeloP3 = new ModeloPlacar(d1, "Placar", materiales1, colores1, 2);
            #endregion
            #region Sillones
            modeloS1 = new ModeloSillon(d1, "Sillon a", materiales1, colores1, 2);
            modeloS2 = new ModeloSillon(d1, "Sillon b", materiales1, colores1, 2);
            modeloS3 = new ModeloSillon(d1, "Sillon doble", materiales1, colores1, 3);
            #endregion
            miFabrica  = new Fabrica();
            miFabrica += modeloM1;
            miFabrica += modeloM2;
            miFabrica += modeloM3;
            miFabrica += modeloM4;
            miFabrica += modeloM5;
            miFabrica += modeloM6;
            miFabrica += modeloM7;
            miFabrica += modeloM8;
            miFabrica += modeloE1;
            miFabrica += modeloE2;
            miFabrica += modeloE3;
            miFabrica += modeloE4;
            miFabrica += modeloP1;
            miFabrica += modeloP2;
            miFabrica += modeloP3;
            miFabrica += modeloS1;
            miFabrica += modeloS2;
            miFabrica += modeloS3;
        }