Ejemplo n.º 1
0
        public void EliminarPalabraClaveTest()
        {
            Repositorio         Repositorio    = new Repositorio();
            ManagerCategoria    Manager        = new ManagerCategoria(Repositorio);
            String              PalabraElminar = "palabra10";
            PalabraClave        palabra1       = new PalabraClave("palabra1");
            PalabraClave        palabra2       = new PalabraClave("palabra2");
            PalabraClave        palabra3       = new PalabraClave("palabra3");
            PalabraClave        palabra4       = new PalabraClave("palabra4");
            PalabraClave        palabra5       = new PalabraClave("palabra5");
            PalabraClave        palabra6       = new PalabraClave("palabra6");
            PalabraClave        palabra7       = new PalabraClave("palabra7");
            PalabraClave        palabra8       = new PalabraClave("palabra8");
            PalabraClave        palabra9       = new PalabraClave("palabra9");
            PalabraClave        palabra10      = new PalabraClave("palabra10");
            List <PalabraClave> ListaPalabras  = new List <PalabraClave>
            {
                palabra1, palabra2, palabra3, palabra4, palabra5, palabra6,
                palabra7, palabra8, palabra9, palabra10
            };
            Categoria UnaCategoria = new Categoria("Cine", ListaPalabras);

            Repositorio.AgregarCategoria(UnaCategoria);
            Manager.EliminarPalabraClave(PalabraElminar);
            Categoria categoriaValidar = Repositorio.GetCategorias().Get(UnaCategoria.Id);

            Assert.AreEqual(9, categoriaValidar.ListaPalabras.Count);
        }
Ejemplo n.º 2
0
        public void Operar()
        {
            var valida = false;

            switch (Extension)
            {
            case "txt":

                CesarCif = new CifradoCesar(PalabraClave, NombreArchivo, RutaAbsolutaArchivo, RutaAbsolutaServer);

                valida = CesarCif.ValidarClave(PalabraClave.ToCharArray());
                if (valida)
                {
                    CesarCif.Cifrar();
                }
                break;

            case "cif":

                CesarDescif = new DescifradoCesar(PalabraClave, NombreArchivo, RutaAbsolutaArchivo, RutaAbsolutaServer);

                valida = CesarDescif.ValidarClave(PalabraClave.ToCharArray());
                if (valida)
                {
                    CesarDescif.Descifrar();
                }
                break;
            }
        }
Ejemplo n.º 3
0
        public void AgregarUnaPalabraClaveCuandoNoHayLugarTest()
        {
            Repositorio         Repositorio   = new Repositorio();
            ManagerCategoria    Manager       = new ManagerCategoria(Repositorio);
            String              nuevaPalabra  = "Cine Mudo";
            PalabraClave        palabra1      = new PalabraClave("palabra1");
            PalabraClave        palabra2      = new PalabraClave("palabra2");
            PalabraClave        palabra3      = new PalabraClave("palabra3");
            PalabraClave        palabra4      = new PalabraClave("palabra4");
            PalabraClave        palabra5      = new PalabraClave("palabra5");
            PalabraClave        palabra6      = new PalabraClave("palabra6");
            PalabraClave        palabra7      = new PalabraClave("palabra7");
            PalabraClave        palabra8      = new PalabraClave("palabra8");
            PalabraClave        palabra9      = new PalabraClave("palabra9");
            PalabraClave        palabra10     = new PalabraClave("palabra10");
            List <PalabraClave> ListaPalabras = new List <PalabraClave>
            {
                palabra1, palabra2, palabra3, palabra4, palabra5, palabra6,
                palabra7, palabra8, palabra9, palabra10
            };
            Categoria UnaCategoria = new Categoria("Cine", ListaPalabras);

            Manager.ValidacionAgregarCategoria(UnaCategoria);
            Manager.ValidacionAgregarUnaPalabraClave(UnaCategoria, nuevaPalabra);
        }
Ejemplo n.º 4
0
 private void btnModificarPalabra_Click(object sender, EventArgs e)
 {
     if (txtPalabraClave.Text != "" && lstPalabrasClave.SelectedIndex != -1)
     {
         ManagerCategoria manager = new ManagerCategoria(Repo);
         if (CategoriaSeleccionada != null)
         {
             try
             {
                 String       Transformar     = lstPalabrasClave.SelectedItem.ToString();
                 PalabraClave palabraAnterior = new PalabraClave(Transformar);
                 manager.ValidacionModificacionDePalabraClave(CategoriaSeleccionada, palabraAnterior.Palabra, txtPalabraClave.Text);
                 CategoriaSeleccionada       = Repo.GetCategorias().Get(CategoriaSeleccionada.Id);
                 lstPalabrasClave.DataSource = null;
                 lstPalabrasClave.DataSource = CategoriaSeleccionada.ListaPalabras;
             }
             catch (ExceptionPalabraClaveRepetida repetida)
             {
                 MessageBox.Show("La palabra clave esta repetida");
             };
         }
         else
         {
             MessageBox.Show("Seleccione una categoria");
         }
     }
     else
     {
         MessageBox.Show("La palabra clave no puede ser vacia o seleccione una palabra para modificar");
     }
 }
Ejemplo n.º 5
0
        public Categoria BusquedaCategorias(String[] palabrasBuscadas)
        {
            Categoria Retorno  = new Categoria();
            var       Contador = 0;

            foreach (String buscada in palabrasBuscadas)
            {
                foreach (Categoria cadaCategoria in this.ListaCategorias.GetAll())
                {
                    PalabraClave palabraABuscar = new PalabraClave(buscada);
                    if (cadaCategoria.ListaPalabras.Any(x => x.Palabra == buscada))
                    {
                        if (Retorno.Id != cadaCategoria.Id)
                        {
                            Contador++;
                            Retorno = cadaCategoria;
                        }
                    }
                }
            }

            if (Contador == 0 || Contador > 1)
            {
                Retorno = new Categoria();
                return(Retorno);
            }
            else
            {
                return(Retorno);
            }
        }
Ejemplo n.º 6
0
        private void btnAgregar_Click_1(object sender, EventArgs e)
        {
            ManagerCategoria manager = new ManagerCategoria(this.Repo);

            if (txtPalabraClave.Text != "")
            {
                try
                {
                    PalabraRepetidaEnCategoriaLocal();
                    manager.ValidarPalabraClaveRepetida(txtPalabraClave.Text);
                    manager.ListaPalabrasClaveLLena(this.unaCategoriaLocal);
                    PalabraClave palabraTemporal = new PalabraClave(txtPalabraClave.Text);
                    unaCategoriaLocal.ListaPalabras.Add(palabraTemporal);
                    ActualizarVincularListBox();
                    txtPalabraClave.Text = "";
                }
                catch (ExceptionListaPalabrasClaveLlena lleno)
                {
                    MessageBox.Show("La lista de palabras clave esta llena");
                    txtPalabraClave.Text = "";
                }
                catch (ExceptionPalabraClaveRepetida repetida)
                {
                    MessageBox.Show("La palabra clave esta repetida");
                    txtPalabraClave.Text = "";
                }
            }
            else
            {
                MessageBox.Show("La palabra clave esta vacia");
            }
        }
Ejemplo n.º 7
0
    public static new Expresion Parsea()
    {
        Expresion resultado;

        resultado = new PalabraClave(pieza);
        SiguientePieza();
        return(resultado);
    }
Ejemplo n.º 8
0
        static void Main(string[] args)
        {
            Console.WriteLine("Ingrese la palabra clave");
            string clave = Console.ReadLine();

            Console.WriteLine("Ingrese la linea");
            string       linea = Console.ReadLine();
            PalabraClave pc    = new PalabraClave(linea, clave);

            Console.WriteLine(pc.Encontrar());
        }
Ejemplo n.º 9
0
 public void AgregarPalabraClave(Categoria unacategoria, String nuevaPalabra)
 {
     foreach (Categoria buscada in this.ListaCategorias.GetAll())
     {
         if (buscada.Id == unacategoria.Id)
         {
             PalabraClave palabra = new PalabraClave(nuevaPalabra);
             buscada.ListaPalabras.Add(palabra);
             this.GetCategorias().Update(buscada);
         }
     }
 }
Ejemplo n.º 10
0
        private void PalabraRepetidaEnCategoriaLocal()
        {
            PalabraClave palabraTemporal = new PalabraClave(txtPalabraClave.Text);

            foreach (PalabraClave palabraBuscar in this.unaCategoriaLocal.ListaPalabras)
            {
                if (palabraBuscar.Palabra == palabraTemporal.Palabra)
                {
                    throw new ExceptionPalabraClaveRepetida("la palabra clave esta repetida");
                }
            }
        }
Ejemplo n.º 11
0
        public void CreacionDeCategoriaValida()
        {
            PalabraClave        palabra1      = new PalabraClave("Cine");
            PalabraClave        palabra2      = new PalabraClave("Carreras");
            PalabraClave        palabra3      = new PalabraClave("Teatro");
            PalabraClave        palabra4      = new PalabraClave("Caballos");
            List <PalabraClave> ListaPalabras = new List <PalabraClave> {
                palabra1, palabra2, palabra3, palabra4
            };
            Categoria UnaCategoria = new Categoria("Entretenimiento", ListaPalabras);

            Assert.IsNotNull(UnaCategoria);
        }
Ejemplo n.º 12
0
        public void EliminarPalabraClave(String palabraEliminar)
        {
            List <Categoria> categorias = Repo.GetCategorias().GetAll();
            PalabraClave     palabra    = new PalabraClave(palabraEliminar);

            foreach (Categoria cadaCategoria in categorias)
            {
                if (cadaCategoria.ListaPalabras.Any(x => x.Palabra == palabraEliminar))
                {
                    Repo.EliminarPalabraClave(palabraEliminar);
                }
            }
        }
Ejemplo n.º 13
0
        public void ValidarPalabraClaveRepetida(String palabraBuscar)
        {
            List <Categoria> categorias = Repo.GetCategorias().GetAll();
            PalabraClave     palabra    = new PalabraClave(palabraBuscar);

            foreach (Categoria cadaCategoria in categorias)
            {
                if (cadaCategoria.ListaPalabras.Any(x => x.Palabra == palabraBuscar))
                {
                    throw new ExceptionPalabraClaveRepetida("El nombre de la palabra clave debe de ser unico");
                }
            }
        }
        public void BusquedaCategoriasTest()
        {
            Repositorio Repo = new Repositorio();

            String[]            array    = { "Cine" };
            PalabraClave        palabra1 = new PalabraClave("Cine");
            PalabraClave        palabra2 = new PalabraClave("Carreras");
            PalabraClave        palabra3 = new PalabraClave("Teatro");
            PalabraClave        palabra4 = new PalabraClave("Caballos");
            List <PalabraClave> Lista    = new List <PalabraClave> {
                palabra1, palabra2, palabra3, palabra4
            };
            Categoria UnaCategoria = new Categoria("Entretenimiento", Lista);

            Repo.AgregarCategoria(UnaCategoria);
            Assert.IsTrue(UnaCategoria.Nombre == Repo.BusquedaCategorias(array).Nombre);
        }
Ejemplo n.º 15
0
        public void ValidacionBusquedaCategoriaMultiplesPalabrasClaveGastoTest()
        {
            Repositorio         unRepositorio    = new Repositorio();
            ManagerGasto        unManager        = new ManagerGasto(unRepositorio);
            PalabraClave        palabraTemporal1 = new PalabraClave("Cines");
            PalabraClave        palabraTemporal2 = new PalabraClave("Carreras");
            PalabraClave        palabraTemporal3 = new PalabraClave("Teatro");
            PalabraClave        palabraTemporal4 = new PalabraClave("Autos");
            List <PalabraClave> Lista            = new List <PalabraClave> {
                palabraTemporal1, palabraTemporal2, palabraTemporal3, palabraTemporal4
            };
            Categoria UnaCategoria     = new Categoria("CategoriaAutos", Lista);
            String    DescripcionGasto = "Autos de Carreras";

            unRepositorio.AgregarCategoria(UnaCategoria);
            Assert.IsTrue(UnaCategoria.Id == unManager.ValidacionBusquedaCategorias(DescripcionGasto)[0].Id);
        }
Ejemplo n.º 16
0
        public void ConstructorConParametrosTest()
        {
            String              Nombre1       = "Entretenimiento";
            String              Nombre2       = "Entretenimiento";
            PalabraClave        palabra1      = new PalabraClave("Cine");
            PalabraClave        palabra2      = new PalabraClave("Carreras");
            PalabraClave        palabra3      = new PalabraClave("Teatro");
            PalabraClave        palabra4      = new PalabraClave("Caballos");
            List <PalabraClave> ListaPalabras = new List <PalabraClave> {
                palabra1, palabra2, palabra3, palabra4
            };
            Categoria Categoria1 = new Categoria(Nombre1, ListaPalabras);
            Categoria Categoria2 = new Categoria(Nombre2);

            Assert.IsNotNull(Categoria1);
            Assert.IsNotNull(Categoria2);
        }
Ejemplo n.º 17
0
        public void AgregarPalabraClaveRepetidaTest()
        {
            Repositorio         Repositorio   = new Repositorio();
            ManagerCategoria    Manager       = new ManagerCategoria(Repositorio);
            String              Repetida      = "Cine";
            PalabraClave        palabra1      = new PalabraClave("Cine");
            PalabraClave        palabra2      = new PalabraClave("Carreras");
            PalabraClave        palabra3      = new PalabraClave("Futbol");
            PalabraClave        palabra4      = new PalabraClave("Teatro");
            PalabraClave        palabra5      = new PalabraClave("Parque");
            List <PalabraClave> ListaPalabras = new List <PalabraClave> {
                palabra1, palabra2, palabra3, palabra4, palabra5
            };
            Categoria UnaCategoria = new Categoria("Balet", ListaPalabras);

            Manager.ValidacionAgregarCategoria(UnaCategoria);
            Manager.ValidacionAgregarUnaPalabraClave(UnaCategoria, Repetida);
        }
Ejemplo n.º 18
0
        public void ModificacionDeUnaPalabraClaveTest()
        {
            Repositorio         Repositorio   = new Repositorio();
            ManagerCategoria    Manager       = new ManagerCategoria(Repositorio);
            PalabraClave        palabra1      = new PalabraClave("Cine");
            PalabraClave        palabra2      = new PalabraClave("Carreras");
            PalabraClave        palabra3      = new PalabraClave("Futbol");
            PalabraClave        palabra4      = new PalabraClave("Teatro");
            PalabraClave        palabra5      = new PalabraClave("Parque");
            List <PalabraClave> ListaPalabras = new List <PalabraClave> {
                palabra1, palabra2, palabra3, palabra4, palabra5
            };
            Categoria UnaCategoria = new Categoria("Cine", ListaPalabras);

            Manager.ValidacionAgregarCategoria(UnaCategoria);
            Manager.ValidacionModificacionDePalabraClave(UnaCategoria, "Parque", "Bar");
            Categoria categoriaValidar = Repositorio.GetCategorias().Get(UnaCategoria.Id);

            Assert.AreEqual(categoriaValidar.ListaPalabras[4].Palabra, "Bar");
        }
        public void AgregarPalabraClaveTest()
        {
            Categoria   UnaCategoria = new Categoria("Entretenimiento");
            Repositorio Repo         = new Repositorio();

            Repo.AgregarCategoria(UnaCategoria);
            Repo.AgregarPalabraClave(UnaCategoria, "Cine");
            PalabraClave palabra       = new PalabraClave("Cine");
            bool         ok            = false;
            Categoria    CategoriaEnDB = Repo.GetCategorias().Get(UnaCategoria.Id);

            foreach (PalabraClave palabras in CategoriaEnDB.ListaPalabras)
            {
                if (palabras.Palabra == palabra.Palabra)
                {
                    ok = true;
                }
            }
            Assert.IsTrue(ok);
        }
Ejemplo n.º 20
0
        public void AgregarUnaPalabraClaveCuandoHayLugarTest()
        {
            Repositorio         Repositorio   = new Repositorio();
            ManagerCategoria    Manager       = new ManagerCategoria(Repositorio);
            String              nuevaPalabra  = "Cine Mudo";
            PalabraClave        palabra1      = new PalabraClave("Cine");
            PalabraClave        palabra2      = new PalabraClave("Carreras");
            PalabraClave        palabra3      = new PalabraClave("Futbol");
            PalabraClave        palabra4      = new PalabraClave("Teatro");
            PalabraClave        palabra5      = new PalabraClave("Parque");
            List <PalabraClave> ListaPalabras = new List <PalabraClave> {
                palabra1, palabra2, palabra3, palabra4, palabra5
            };
            Categoria UnaCategoria = new Categoria("Mudo", ListaPalabras);

            Manager.ValidacionAgregarCategoria(UnaCategoria);
            Manager.ValidacionAgregarUnaPalabraClave(UnaCategoria, nuevaPalabra);
            Categoria palabraDB = Repositorio.GetCategorias().Get(UnaCategoria.Id);

            Assert.IsNotNull(palabraDB.ListaPalabras.Find(x => x.Palabra == nuevaPalabra));
        }
Ejemplo n.º 21
0
        public void ValidacionListaPalabrasLlenaTest()
        {
            Repositorio         Repositorio   = new Repositorio();
            ManagerCategoria    Manager       = new ManagerCategoria(Repositorio);
            PalabraClave        palabra1      = new PalabraClave("palabra1");
            PalabraClave        palabra2      = new PalabraClave("palabra2");
            PalabraClave        palabra3      = new PalabraClave("palabra3");
            PalabraClave        palabra4      = new PalabraClave("palabra4");
            PalabraClave        palabra5      = new PalabraClave("palabra5");
            PalabraClave        palabra6      = new PalabraClave("palabra6");
            PalabraClave        palabra7      = new PalabraClave("palabra7");
            PalabraClave        palabra8      = new PalabraClave("palabra8");
            PalabraClave        palabra9      = new PalabraClave("palabra9");
            PalabraClave        palabra10     = new PalabraClave("palabra10");
            List <PalabraClave> ListaPalabras = new List <PalabraClave>
            {
                palabra1, palabra2, palabra3, palabra4, palabra5, palabra6,
                palabra7, palabra8, palabra9, palabra10
            };
            Categoria UnaCategoria = new Categoria("Cine", ListaPalabras);

            Manager.ListaPalabrasClaveLLena(UnaCategoria);
        }
Ejemplo n.º 22
0
        public void ValidacionPalabraClaveRepetidaTest()
        {
            Repositorio         Repositorio   = new Repositorio();
            ManagerCategoria    Manager       = new ManagerCategoria(Repositorio);
            PalabraClave        palabra1      = new PalabraClave("palabra1");
            PalabraClave        palabra2      = new PalabraClave("palabra2");
            PalabraClave        palabra3      = new PalabraClave("Palabra3");
            PalabraClave        palabra4      = new PalabraClave("palabra4");
            PalabraClave        palabra5      = new PalabraClave("palabra5");
            PalabraClave        palabra6      = new PalabraClave("palabra6");
            PalabraClave        palabra7      = new PalabraClave("palabra7");
            PalabraClave        palabra8      = new PalabraClave("palabra8");
            List <PalabraClave> ListaPalabras = new List <PalabraClave>
            {
                palabra1, palabra2, palabra3, palabra4, palabra5, palabra6,
                palabra7, palabra8
            };
            Categoria UnaCategoria = new Categoria("Entretenimiento", ListaPalabras);
            String    Repetida     = "Palabra3";

            Manager.ValidacionAgregarCategoria(UnaCategoria);
            Manager.ValidarPalabraClaveRepetida(Repetida);
        }
Ejemplo n.º 23
0
 public static Expresion Parsea()
 {
     Expresion resultado;
     if (Pieza == "(")
     {
         SiguientePieza();
         resultado = OperadorO.Parsea();
         if (Pieza == null)
         {
             throw new Exception("Error de sintaxis");
         }
         if (Pieza != ")")
         {
             throw new Exception("Error de sintaxis");
         }
         SiguientePieza();
     }
     else
     {
         resultado = PalabraClave.Parsea();
     }
     return resultado;
 }
Ejemplo n.º 24
0
        public async Task <IActionResult> Create([Bind("CodRegistro,Titulo,Año,RecursoDigital,TokenRecurso,Nota,NombreInstitucion,NombreAutor,ApellidoAutor,CarnetAutor,Observacion,CodCat,CodUsuario,CodAsesor,CodCarrera,CodTipotrabajo,Subir,PalabrasClaves")] TrabajoGraduacion trabajoGraduacion)
        {
            var variable = 0;

            if (ModelState.IsValid)
            {
                if (trabajoGraduacion.Subir != null)
                {
                    string carpeta       = HostEnvironment.WebRootPath;
                    string nombrearchivo = Path.GetFileNameWithoutExtension(trabajoGraduacion.Subir.FileName);
                    string extension     = Path.GetExtension(trabajoGraduacion.Subir.FileName);
                    trabajoGraduacion.RecursoDigital = nombrearchivo = nombrearchivo + DateTime.Now.ToString("yymmssfff") + extension;
                    string path = Path.Combine(carpeta + "/upload/", nombrearchivo);
                    trabajoGraduacion.TokenRecurso = Crypto.Hash(path);

                    using (var hola = new FileStream(path, FileMode.Create))
                    {
                        await trabajoGraduacion.Subir.CopyToAsync(hola);
                    }
                }
                else
                {
                    trabajoGraduacion.RecursoDigital = "default.txt";
                }


                bd_bibliotecaContext _context2 = new bd_bibliotecaContext();
                string[]             valores   = trabajoGraduacion.PalabrasClaves.Split(',');
                foreach (string pa in valores)
                {
                    PalabraClave palabraBD = new PalabraClave();
                    var          Paclave   = _context.PalabraClave.Where(w => w.PalabraClave1 == pa).FirstOrDefault();
                    if (Paclave != null)
                    {
                        trabajoGraduacion.TrabajoPalabraClave.Add(new TrabajoPalabraClave {
                            CodPalabraClave = Paclave.CodPalabraclave
                        });
                    }
                    else
                    {
                        palabraBD.PalabraClave1 = pa;
                        _context2.Add(palabraBD);
                        await _context2.SaveChangesAsync();

                        var Paclave2 = _context.PalabraClave.Where(a => a.PalabraClave1 == pa).FirstOrDefault();
                        if (Paclave2 != null)
                        {
                            trabajoGraduacion.TrabajoPalabraClave.Add(new TrabajoPalabraClave {
                                CodPalabraClave = Paclave2.CodPalabraclave
                            });
                        }
                    }
                }
                if (trabajoGraduacion.CodCat != null)
                {
                    trabajoGraduacion.CodTipotrabajo = 2;
                }
                if (trabajoGraduacion.CodCat == null)
                {
                    trabajoGraduacion.CodTipotrabajo = 1;
                    variable = 1;
                }

                var user = _context.Usuario.Where(t => t.CorreoElectronico == User.Identity.Name).FirstOrDefault();
                trabajoGraduacion.CodUsuario = user.CodUsuario;
                _context.Add(trabajoGraduacion);
                await _context.SaveChangesAsync();

                if (variable == 1)
                {
                    TempData["mensajeTesis"] = "Creado!";
                    return(RedirectToAction("Tesis", "TrabajoGraduacions"));
                }


                TempData["mensajeTra"] = "Creado!";
                return(RedirectToAction("Create", "TrabajoGraduacions"));
            }
            ViewData["CodAsesor"]      = new SelectList(_context.Asesor, "CodAsesor", "Apellido", trabajoGraduacion.CodAsesor);
            ViewData["CodCarrera"]     = new SelectList(_context.Carrera, "CodCarrera", "Carrera1", trabajoGraduacion.CodCarrera);
            ViewData["CodCat"]         = new SelectList(_context.CatTrabajoGraduacion, "CodCat", "Categoria", trabajoGraduacion.CodCat);
            ViewData["CodTipotrabajo"] = new SelectList(_context.TipoTrabajo, "CodTipotrabajo", "Tipo", trabajoGraduacion.CodTipotrabajo);
            ViewData["CodUsuario"]     = new SelectList(_context.Usuario, "CodUsuario", "Apellido", trabajoGraduacion.CodUsuario);
            return(View(trabajoGraduacion));
        }
Ejemplo n.º 25
0
        public void Inicio()
        {
            ObjetoDelegado Mostrar         = new ObjetoDelegado(dibujos.nada);
            StringBuilder  nuevo           = new StringBuilder();
            StringBuilder  PalabraRepetida = new StringBuilder();

            PalabraClave = Console.ReadLine();
            Mostrar();
            nuevo.Append(PalabraClave);
            for (int i = 0; i < PalabraClave.Length; i++)
            {
                if (nuevo[i] != ' ')
                {
                    Console.Write("_" + " ");
                }
                else
                {
                    Console.Write(" ");
                    EspaciosVacios++;
                }
            }
            contador = PalabraClave.Length - EspaciosVacios;
            Console.WriteLine();
            string letra;

            do
            {
                letra = Console.ReadLine();
                for (int x = 0; x < PalabraRepetida.Length; x++)
                {
                    if (PalabraRepetida[x].ToString() == letra)
                    {
                        Console.WriteLine("letra ya ingresada");
                        letra = Console.ReadLine();
                    }
                }
                PalabraRepetida.AppendLine(letra.ToString());
                if (PalabraClave.Contains(letra))
                {
                    Console.Clear();
                    Console.WriteLine("letra correcta");
                    pts += 20;
                    contador--;
                    string gas = letra.ToString();
                    for (int i = 0; i < PalabraClave.Length; i++)
                    {
                        if (nuevo[i] == ' ' || nuevo[i].ToString() != letra)
                        {
                            Console.Write("_" + " ");
                        }
                        else
                        {
                            Console.WriteLine(letra + " ");
                        }
                    }
                }
                else
                {
                    Console.WriteLine("letra incorrecta");
                    contadorLOSER++;
                    if (pts > 0)
                    {
                        pts -= 5;
                    }
                    Console.Clear();
                }
                if (contadorLOSER == 1)
                {
                    Console.ForegroundColor = ConsoleColor.DarkRed;
                    Mostrar = new ObjetoDelegado(dibujos.Cabeza);
                    Mostrar();
                    Console.WriteLine("puntos {0}:", pts);
                }
                if (contadorLOSER == 2)
                {
                    Console.ForegroundColor = ConsoleColor.DarkGreen;
                    Mostrar = new ObjetoDelegado(dibujos.brazo1);
                    Mostrar();
                    Console.WriteLine("puntos {0}:", pts);
                }
                if (contadorLOSER == 3)
                {
                    Console.ForegroundColor = ConsoleColor.Green;
                    Mostrar = new ObjetoDelegado(dibujos.brazo2);
                    Mostrar();
                    Console.WriteLine("puntos {0}:", pts);
                }
                if (contadorLOSER == 4)
                {
                    Console.ForegroundColor = ConsoleColor.Yellow;
                    Mostrar = new ObjetoDelegado(dibujos.tronco);
                    Mostrar();
                    Console.WriteLine("puntos {0}:", pts);
                }
                if (contadorLOSER == 5)
                {
                    Console.ForegroundColor = ConsoleColor.Blue;
                    Mostrar = new ObjetoDelegado(dibujos.pierna1);
                    Mostrar();
                    Console.WriteLine("puntos {0}:", pts);
                }
                if (contadorLOSER == 6)
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Mostrar = new ObjetoDelegado(dibujos.pierna2);
                    Mostrar();
                    Console.WriteLine("puntos {0}:", pts);
                }
            } while (contadorLOSER != 7 && contador != 0);
        }
Ejemplo n.º 26
0
        public void ConstructorSinParametrosTest()
        {
            PalabraClave p = new PalabraClave();

            Assert.IsNotNull(p);
        }
Ejemplo n.º 27
0
        public void ConstructorConParametrosTest()
        {
            PalabraClave p = new PalabraClave("Entretenimiento");

            Assert.IsNotNull(p);
        }
Ejemplo n.º 28
0
        public void toStringTest()
        {
            PalabraClave p = new PalabraClave("Entretenimiento");

            Assert.AreEqual(p.ToString(), "Entretenimiento");
        }
Ejemplo n.º 29
0
        public VM_PCMFichasBase(FichasBase fichasBase)
        {
            Codigo          = fichasBase.IdInterno;
            Pais            = fichasBase.IdPais;
            LineaDeNegocio  = fichasBase.IdLineaNegocio;
            TituloLargo     = FormatText(fichasBase.Titulo);
            TituloCorto     = FormatText(fichasBase.TituloDistribuidora);
            Subtitulo       = FormatText(fichasBase.Subtitulo);
            Coeditorial     = fichasBase.Coeditorial;
            LenguaPrincipal = fichasBase.Idioma;

            // LenguasSecundarias
            foreach (var item in fichasBase.FichasBaseIdiomasSecundarios.OrderBy(x => x.Orden))
            {
                LenguasSecundarias += $"{item.IdIdioma},";
            }
            if (!string.IsNullOrEmpty(LenguasSecundarias))
            {
                LenguasSecundarias = LenguasSecundarias.Substring(0, LenguasSecundarias.Length - 1);
            }

            // Rol
            foreach (var item in fichasBase.RelFichasPersonas.OrderBy(x => x.Orden))
            {
                Rol += $"{item.IdRol},";
            }
            if (!string.IsNullOrEmpty(Rol))
            {
                Rol = Rol.Substring(0, Rol.Length - 1);
            }

            // Persona
            // Autor
            foreach (var item in fichasBase.RelFichasPersonas.OrderBy(x => x.Orden))
            {
                if (item.IdRol == "AUT")
                {
                    Persona += $"{item.IdPersona},";
                }
                //Autor += $"{item.IdPersona},";
                else
                {
                    Persona += $"{item.IdPersona},";
                }
            }
            if (!string.IsNullOrEmpty(Persona))
            {
                Persona = Persona.Substring(0, Persona.Length - 1);
            }
            if (!string.IsNullOrEmpty(Autor))
            {
                Autor = Autor.Substring(0, Autor.Length - 1);
            }

            Edad                  = fichasBase.EdadMinima;
            ZonaGeografica        = fichasBase.IdZonaGeografica;
            Comercializaciones    = fichasBase.IdInternoOrigen;
            TipoMaterialEducativo = fichasBase.IdTipoMaterialEducativo;
            Coleccion             = fichasBase.IdColeccion;
            Serie                 = fichasBase.IdSerie;
            N_Coleccion           = fichasBase.NumeroColeccion;
            N_Serie               = fichasBase.NumeroSerie;
            Genero                = fichasBase.IdGenero;
            DRM                = fichasBase.IdDrm;
            Accesibilidad      = fichasBase.IdAccesibilidad;
            ISBN               = fichasBase.Isbn;
            EAN13              = fichasBase.Ean13;
            Encuadernacion     = fichasBase.TipoEncuadernacion;
            Estado             = fichasBase.IdEstadoSap;
            EjemplaresPorCaja  = fichasBase.NEjemplaresCaja;
            NumeroDePaginas    = fichasBase.NumeroPaginas;
            Alto               = fichasBase.Alto;
            Ancho              = fichasBase.Ancho;
            Grosor             = fichasBase.Grosor;
            Peso               = fichasBase.Peso;
            PrecioSinImpuestos = fichasBase.PrecioSinIvae;
            PrecioConImpuestos = fichasBase.PrecioConIvae;
            Impuestos          = fichasBase.IvaPorCiento;

            // Edicion
            foreach (var item in fichasBase.E2Tiradasedicion.OrderBy(x => x.NumeroEdicion))
            {
                Edicion += $"{item.NumeroEdicion},";
            }
            if (!string.IsNullOrEmpty(Edicion))
            {
                Edicion = Edicion.Substring(0, Edicion.Length - 1);
            }

            // Fecha
            foreach (var item in fichasBase.E2Tiradasedicion.OrderBy(x => x.NumeroEdicion))
            {
                if (item.Fecha.HasValue)
                {
                    Edicion += $"{item.Fecha.Value:ddMMyyyy},";
                }
            }
            if (!string.IsNullOrEmpty(Fecha))
            {
                Fecha = Fecha.Substring(0, Fecha.Length - 1);
            }

            // Tirada
            foreach (var item in fichasBase.E2Tiradasedicion.OrderBy(x => x.NumeroEdicion))
            {
                Tirada += $"{item.Tirada},";
            }
            if (!string.IsNullOrEmpty(Tirada))
            {
                Tirada = Tirada.Substring(0, Tirada.Length - 1);
            }

            // DepositoLegal
            foreach (var item in fichasBase.E2Tiradasedicion.OrderBy(x => x.NumeroEdicion))
            {
                DepositoLegal += $"{item.DepositoLegal},";
            }
            if (!string.IsNullOrEmpty(Tirada))
            {
                DepositoLegal = DepositoLegal.Substring(0, DepositoLegal.Length - 1);
            }

            LineaDeProducto = fichasBase.CodLineaP;

            // Soporte
            foreach (var item in fichasBase.FichasBaseSoportes.OrderBy(x => x.Orden))
            {
                Soporte += $"{item.IdSoporte},";
            }
            if (!string.IsNullOrEmpty(Soporte))
            {
                Soporte = Soporte.Substring(0, Soporte.Length - 1);
            }

            TipoMaterialSAP   = fichasBase.IdTipoMaterialSap;
            GrupoArticulo     = fichasBase.E2GruposArticulo.CodigoGrupo;
            UsoComercial      = fichasBase.IdUsoComercial;
            Campana           = fichasBase.IdCampaña;
            Proyecto          = fichasBase.IdProyecto;
            ProyectoDeGestion = fichasBase.IdProyectoGestion;

            // JerarquiaTotal
            foreach (var item in fichasBase.E2RamasclasifFicha)
            {
                JerarquiaTotal += $"{item.IdClasificacion},";
            }
            if (!string.IsNullOrEmpty(JerarquiaTotal))
            {
                JerarquiaTotal = JerarquiaTotal.Substring(0, JerarquiaTotal.Length - 1);
            }

            // Sinopsis
            foreach (var item in fichasBase.FichasAplicacions)
            {
                Sinopsis += $"{FormatText(item.Sinopsis)},";
            }
            if (!string.IsNullOrEmpty(Sinopsis))
            {
                Sinopsis = Sinopsis.Substring(0, Sinopsis.Length - 1);
            }

            // Resumen
            foreach (var item in fichasBase.FichasAplicacions)
            {
                Resumen += $"{FormatText(item.Resumen)},";
            }
            if (!string.IsNullOrEmpty(Resumen))
            {
                Resumen = Resumen.Substring(0, Resumen.Length - 1);
            }

            // Indice
            foreach (var item in fichasBase.FichasAplicacions)
            {
                Indice += $"{FormatText(item.Indice)},";
            }
            if (!string.IsNullOrEmpty(Indice))
            {
                Indice = Indice.Substring(0, Indice.Length - 1);
            }

            // FraseDescriptivaEspecial_Ninos
            foreach (var item in fichasBase.RelFrasesDescriptivas)
            {
                if (item.IdPublicoObjetivo == 0)
                {
                    FraseDescriptivaEspecial_Ninos += $"{FormatText(item.FraseDescriptiva)},";
                }
            }
            if (!string.IsNullOrEmpty(FraseDescriptivaEspecial_Ninos))
            {
                FraseDescriptivaEspecial_Ninos = FraseDescriptivaEspecial_Ninos.Substring(0, FraseDescriptivaEspecial_Ninos.Length - 1);
            }

            // FraseDescriptivaGeneral
            foreach (var item in fichasBase.RelFrasesDescriptivas)
            {
                if (item.IdPublicoObjetivo == 1)
                {
                    FraseDescriptivaGeneral += $"{FormatText(item.FraseDescriptiva)},";
                }
            }
            if (!string.IsNullOrEmpty(FraseDescriptivaGeneral))
            {
                FraseDescriptivaGeneral = FraseDescriptivaGeneral.Substring(0, FraseDescriptivaGeneral.Length - 1);
            }

            // FraseDescriptivaEspecial_Chavales
            foreach (var item in fichasBase.RelFrasesDescriptivas)
            {
                if (item.IdPublicoObjetivo == 3)
                {
                    FraseDescriptivaEspecial_Chavales += $"{FormatText(item.FraseDescriptiva)},";
                }
            }
            if (!string.IsNullOrEmpty(FraseDescriptivaEspecial_Chavales))
            {
                FraseDescriptivaEspecial_Chavales = FraseDescriptivaEspecial_Chavales.Substring(0, FraseDescriptivaEspecial_Chavales.Length - 1);
            }

            // Premio
            foreach (var item in fichasBase.E2FichasBasePremio.OrderBy(x => x.Anyo))
            {
                Premio += $"{item.IdPremio},";
            }
            if (!string.IsNullOrEmpty(Premio))
            {
                Premio = Premio.Substring(0, Premio.Length - 1);
            }

            // PremioAno
            foreach (var item in fichasBase.E2FichasBasePremio.OrderBy(x => x.Anyo))
            {
                PremioAno += $"{item.Anyo},";
            }
            if (!string.IsNullOrEmpty(PremioAno))
            {
                PremioAno = PremioAno.Substring(0, PremioAno.Length - 1);
            }

            // PremioComentarios
            foreach (var item in fichasBase.E2FichasBasePremio.OrderBy(x => x.Anyo))
            {
                PremioComentarios += $"{FormatText(item.Comentarios)},";
            }
            if (!string.IsNullOrEmpty(PremioComentarios))
            {
                PremioComentarios = PremioComentarios.Substring(0, PremioComentarios.Length - 1);
            }

            // PalabraClave
            foreach (var item in fichasBase.FichasBaseTesauroes)
            {
                if (item.IdTipo == 1)
                {
                    PalabraClave += $"{item.IdArbol},";
                }
            }
            if (!string.IsNullOrEmpty(PalabraClave))
            {
                PalabraClave = PalabraClave.Substring(0, PalabraClave.Length - 1);
            }

            // Valores (Tesauro)
            foreach (var item in fichasBase.FichasBaseTesauroes)
            {
                if (item.IdTipo == 3)
                {
                    Valores += $"{item.IdArbol},";
                }
            }
            if (!string.IsNullOrEmpty(Valores))
            {
                Valores = Valores.Substring(0, Valores.Length - 1);
            }

            // ClasificacionCDU
            foreach (var item in fichasBase.FichasBaseCodigoCdus)
            {
                ClasificacionCDU += $"{item.IdCodigoCdu},";
            }
            if (!string.IsNullOrEmpty(ClasificacionCDU))
            {
                ClasificacionCDU = ClasificacionCDU.Substring(0, ClasificacionCDU.Length - 1);
            }

            // ClasificacionBIC
            foreach (var item in fichasBase.FichasBaseClasificacionEcis)
            {
                ClasificacionBIC += $"{item.IdcLasificacionEci},";
            }
            if (!string.IsNullOrEmpty(ClasificacionBIC))
            {
                ClasificacionBIC = ClasificacionBIC.Substring(0, ClasificacionBIC.Length - 1);
            }

            FechaAltaEnElSistema             = fichasBase.FechaCreacion;
            FechaNecesidadDeInformacion      = fichasBase.FechaNecesidadInformacion;
            FechaCreacionProyectoPS          = fichasBase.FechaCreacionProyectoPs;
            FechaRecepcionDePrototipos       = fichasBase.FechaRecepcionPrototipos;
            FechaPuestaEnMarchaDeFabricacion = fichasBase.FechaPuestaEnMarchaFabricacion;
            FechaFinProcesoInteriores        = fichasBase.FechaFinProcesadoInteriores;
            FechaAltaEnLogistica             = fichasBase.FechaAltaLogistica;
            FechaComercializacion            = fichasBase.FechaDisponibilidadComercial;
            FechaDeCreacion             = fichasBase.FechaCreacion;
            UsuarioDeCreacion           = fichasBase.UsuarioCreacion;
            FechaDeModificacion         = fichasBase.FechaActualizacion;
            UsuarioDeModificacion       = fichasBase.UsuarioActualizacion;
            FechaDePublicacion          = fichasBase.FechaPublicacion;
            UsuarioDePublicacion        = fichasBase.UsuarioPublicacion;
            FechaDeDespublicacion       = fichasBase.FechaRetirada;
            UsuarioDeDespublicacion     = fichasBase.UsuarioRetirada;
            FechaLibroDisponibleEnWeb   = fichasBase.FechaPublicacion;
            FechaLibroDisponibleEnDILVE = fichasBase.FechaCreacionDilve;
            TituloOriginal    = fichasBase.TituloOriginal;
            EditorialOriginal = fichasBase.EditorialOriginal;
            IdiomaOriginal    = fichasBase.IdiomaOriginal;

            // TitulosAfines
            foreach (var item in fichasBase.TitulosAfines.OrderBy(x => x.Orden))
            {
                TitulosAfines += $"{item.IdObraAfin},";
            }
            if (!string.IsNullOrEmpty(TitulosAfines))
            {
                TitulosAfines = TitulosAfines.Substring(0, TitulosAfines.Length - 1);
            }

            // MaterialesAnejos
            foreach (var item in fichasBase.TitulosAnejoes.OrderBy(x => x.Orden))
            {
                MaterialesAnejos += $"{item.IdObraAneja},";
            }
            if (!string.IsNullOrEmpty(MaterialesAnejos))
            {
                MaterialesAnejos = MaterialesAnejos.Substring(0, MaterialesAnejos.Length - 1);
            }

            // MaterialesReferencia
            foreach (var item in fichasBase.TFichasBaseMaterialesReferencias_IdInternoReferencia)
            {
                MaterialesReferencia += $"{item.IdInternoReferencia},";
            }
            if (!string.IsNullOrEmpty(MaterialesReferencia))
            {
                MaterialesReferencia = MaterialesReferencia.Substring(0, MaterialesReferencia.Length - 1);
            }

            // MaterialesAuxiliares
            // MaterialesAuxiliaresTipoDeDocumento
            foreach (var item in fichasBase.Documentoes)
            {
                MaterialesAuxiliares += $"{item.IdDocumento},";
                MaterialesAuxiliaresTipoDeDocumento += $"{item.Tipo},";

                if (item.TipoLink == false)
                {
                    PathMaterialesAuxiliares += $"\\\\sesficazu02.gesm.net\\ecatprepro$\\Documentos_Materiales{item.Path},";
                }
                else
                {
                    PathMaterialesAuxiliares += $"{item.Path},";
                }
            }
            if (!string.IsNullOrEmpty(MaterialesAuxiliares))
            {
                MaterialesAuxiliares = MaterialesAuxiliares.Substring(0, MaterialesAuxiliares.Length - 1);
            }
            if (!string.IsNullOrEmpty(MaterialesAuxiliaresTipoDeDocumento))
            {
                MaterialesAuxiliaresTipoDeDocumento = MaterialesAuxiliaresTipoDeDocumento.Substring(0, MaterialesAuxiliaresTipoDeDocumento.Length - 1);
            }
            if (!string.IsNullOrEmpty(PathMaterialesAuxiliares))
            {
                PathMaterialesAuxiliares = PathMaterialesAuxiliares.Substring(0, PathMaterialesAuxiliares.Length - 1);
            }

            // FechaContrato
            // EstadoContrato
            // DisponibleVentaDerechos
            // Restrictivo
            // MasInformacion
            foreach (var item in fichasBase.TFichasBaseAmbitosCesions)
            {
                FechaContrato           += $"{item.Fecha:ddMMyyyy},";
                EstadoContrato          += $"{item.IdEstado},";
                DisponibleVentaDerechos += $"{Convert.ToInt16(item.DisponibleVentaDerechos)},";
                Restrictivo             += $"{Convert.ToInt16(item.EsRestrictivo)},";
                ComentariosInternos     += $"{item.ComentariosInternos},";
                MasInformacion          += $"{item.MasInformacion},";

                //TerritoriosVenta
                //TerritoriosExcluidos
                foreach (var valor in item.TFichasBaseAmbitosCesionValores)
                {
                    if (!valor.Exclusivo)
                    {
                        TerritoriosVenta += $"{valor.IdAmbitoCesion},";
                    }
                    else
                    {
                        TerritoriosExcluidos += $"{valor.IdAmbitoCesion},";
                    }
                }

                //RestriccionesVenta
                foreach (var valor in item.TFichasBaseAmbitosCesionRestricciones)
                {
                    RestriccionesVenta += $"{valor.IdAmbitoCesionRestriccion},";
                }
            }
            if (!string.IsNullOrEmpty(FechaContrato))
            {
                FechaContrato = FechaContrato.Substring(0, FechaContrato.Length - 1);
            }
            if (!string.IsNullOrEmpty(DisponibleVentaDerechos))
            {
                DisponibleVentaDerechos = DisponibleVentaDerechos.Substring(0, DisponibleVentaDerechos.Length - 1);
            }
            if (!string.IsNullOrEmpty(Restrictivo))
            {
                Restrictivo = Restrictivo.Substring(0, Restrictivo.Length - 1);
            }
            if (!string.IsNullOrEmpty(ComentariosInternos))
            {
                ComentariosInternos = ComentariosInternos.Substring(0, ComentariosInternos.Length - 1);
            }
            if (!string.IsNullOrEmpty(MasInformacion))
            {
                MasInformacion = MasInformacion.Substring(0, MasInformacion.Length - 1);
            }
            if (!string.IsNullOrEmpty(TerritoriosVenta))
            {
                TerritoriosVenta = TerritoriosVenta.Substring(0, TerritoriosVenta.Length - 1);
            }
            if (!string.IsNullOrEmpty(TerritoriosExcluidos))
            {
                TerritoriosExcluidos = TerritoriosExcluidos.Substring(0, TerritoriosExcluidos.Length - 1);
            }
            if (!string.IsNullOrEmpty(RestriccionesVenta))
            {
                RestriccionesVenta = RestriccionesVenta.Substring(0, RestriccionesVenta.Length - 1);
            }
            if (!string.IsNullOrEmpty(EstadoContrato))
            {
                EstadoContrato = EstadoContrato.Substring(0, EstadoContrato.Length - 1);
            }

            // MarcaPublicado
            MarcaPublicado = fichasBase.PublicableWeb;

            // Imagenes
            foreach (var item in fichasBase.TbFichasBaseImagenes)
            {
                // PortadasBajaResolucion
                if (item.IdTipoImagen == 1)
                {
                    PortadasBajaResolucion += $"{item.Fichero},";
                }
                // AltaResolucion
                if (item.IdTipoImagen == 2)
                {
                    AltaResolucion += $"{item.Fichero},";
                }
                // Interiores
                if (item.IdTipoImagen == 3)
                {
                    Interiores += $"{item.Fichero},";
                }
                // Bodegones
                if (item.IdTipoImagen == 5)
                {
                    Bodegones += $"{item.Fichero},";
                }
            }
            if (!string.IsNullOrEmpty(PortadasBajaResolucion))
            {
                PortadasBajaResolucion = PortadasBajaResolucion.Substring(0, PortadasBajaResolucion.Length - 1);
            }
            if (!string.IsNullOrEmpty(AltaResolucion))
            {
                AltaResolucion = AltaResolucion.Substring(0, AltaResolucion.Length - 1);
            }
            if (!string.IsNullOrEmpty(Interiores))
            {
                Interiores = Interiores.Substring(0, Interiores.Length - 1);
            }
            if (!string.IsNullOrEmpty(Bodegones))
            {
                Bodegones = Bodegones.Substring(0, Bodegones.Length - 1);
            }
        }