Exemplo n.º 1
0
        public async Task <IActionResult> Edit(int id, [Bind("Id,Nombre,Direccion,Localidad,Telefono")] Gimnasio gimnasio)
        {
            if (id != gimnasio.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(gimnasio);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!GimnasioExists(gimnasio.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(gimnasio));
        }
        public void TestTexto()
        {
            Gimnasio gim1 = new Gimnasio();

            gim1 += new Alumno(1, "Juan", "Perez", "36598485", Persona.ENacionalidad.Argentino, Gimnasio.EClases.Natacion);
            gim1 += new Alumno(2, "Jorge", "Lopez", "35598485", Persona.ENacionalidad.Argentino, Gimnasio.EClases.Pilates);
            gim1 += new Alumno(3, "Jose", "Fernandez", "34598485", Persona.ENacionalidad.Argentino, Gimnasio.EClases.CrossFit);
            gim1 += new Alumno(4, "Martin", "Asd", "95666333", Persona.ENacionalidad.Extranjero, Gimnasio.EClases.Yoga);
            Instructor i1 = new Instructor(1, "Carlos", "Ramirez", "20000000", Persona.ENacionalidad.Argentino);

            gim1 += i1;
            try
            {
                gim1 += Gimnasio.EClases.Pilates;
                goto End;
            }
            catch (SinInstructorException e)
            {
            }

            try
            {
                gim1 += Gimnasio.EClases.Natacion;
                goto End;
            }
            catch (SinInstructorException e)
            {
            }

            try
            {
                gim1 += Gimnasio.EClases.CrossFit;
                goto End;
            }
            catch (SinInstructorException e)
            {
            }

            try
            {
                gim1 += Gimnasio.EClases.Yoga;
                goto End;
            }
            catch (SinInstructorException e)
            {
            }

End:
            Jornada.Guardar(gim1[0]);
            string aux;

            if (Jornada.Leer(out aux))
            {
                Assert.AreEqual(gim1[0].ToString(), aux);
            }
            else
            {
                Assert.Fail();
            }
        }
        public void GimanasioCorrecto()
        {
            Gimnasio gim = new Gimnasio();

            Assert.IsNotNull(gim.Alumno);
            Assert.IsNotNull(gim.Instructor);
            Assert.IsNotNull(gim.Jornada);

            Alumno a1 = new Alumno(1, "Juan", "Lopez", "12234456",
                                   EntidadesAbstractas.Persona.ENacionalidad.Argentino, Gimnasio.EClases.CrossFit,
                                   Alumno.EEstadoCuenta.MesPrueba);

            Assert.IsNotNull(a1.Apellido);
            Assert.IsNotNull(a1.Nombre);
            Assert.IsNotNull(a1.Nacionalidad);
            Assert.IsNotNull(a1.DNI);

            Instructor i1 = new Instructor(1, "Juan", "Lopez", "12234456",
                                           EntidadesAbstractas.Persona.ENacionalidad.Argentino);

            Assert.IsNotNull(i1.Apellido);
            Assert.IsNotNull(i1.Nombre);
            Assert.IsNotNull(i1.Nacionalidad);
            Assert.IsNotNull(i1.DNI);
        }
Exemplo n.º 4
0
        public void TestAtributosGimnasioNoNull()
        {
            Gimnasio g = new Gimnasio();

            Assert.IsNotNull(g.Alumnos);
            Assert.IsNotNull(g.Instrcutores);
            Assert.IsNotNull(g.Jornadas);
        }
Exemplo n.º 5
0
        public void InstanciaObjetos()
        {
            Gimnasio gim = new Gimnasio();

            Assert.AreNotEqual(null, gim.LsAlumno);
            Assert.AreNotEqual(null, gim.LsInstr);
            Assert.AreNotEqual(null, gim.LsJorn);
        }
Exemplo n.º 6
0
        public void TestNulo()
        {
            //Verfico que las listas no sean nulas en gimnasio
            Gimnasio g1 = new Gimnasio();

            Assert.IsNotNull(g1.Alumnos);
            Assert.IsNotNull(g1.Jornadas);
            Assert.IsNotNull(g1.Instructores);
        }
Exemplo n.º 7
0
        public void TestGimnasio()
        {
            Gimnasio gim1 = new Gimnasio();

            gim1 += new Alumno(1, "Juan", "Perez", "36598485", Persona.ENacionalidad.Argentino, Gimnasio.EClases.Natacion);
            gim1 += new Alumno(2, "Jorge", "Lopez", "35598485", Persona.ENacionalidad.Argentino, Gimnasio.EClases.Pilates);
            gim1 += new Alumno(3, "Jose", "Fernandez", "34598485", Persona.ENacionalidad.Argentino, Gimnasio.EClases.CrossFit);
            gim1 += new Alumno(4, "Martin", "Asd", "95666333", Persona.ENacionalidad.Extranjero, Gimnasio.EClases.Yoga);
            Instructor i1 = new Instructor(1, "Carlos", "Ramirez", "20000000", Persona.ENacionalidad.Argentino);

            gim1 += i1;
            try
            {
                gim1 += Gimnasio.EClases.Pilates;
                Assert.IsTrue(i1.ToString().Contains("Pilates"));
                Assert.IsTrue(gim1.ToString().Contains("NOMBRE COMPLETO: Lopez, Jorge"));
            }
            catch (SinInstructorException e)
            {
                Assert.IsFalse(i1.ToString().Contains("Pilates"));
            }

            try
            {
                gim1 += Gimnasio.EClases.Natacion;
                Assert.IsTrue(i1.ToString().Contains("Natacion"));
                Assert.IsTrue(gim1.ToString().Contains("NOMBRE COMPLETO: Perez, Juan"));
            }
            catch (SinInstructorException e)
            {
                Assert.IsFalse(i1.ToString().Contains("Natacion"));
            }

            try
            {
                gim1 += Gimnasio.EClases.CrossFit;
                Assert.IsTrue(i1.ToString().Contains("CrossFit"));
                Assert.IsTrue(gim1.ToString().Contains("NOMBRE COMPLETO: Fernandez, Jose"));
            }
            catch (SinInstructorException e)
            {
                Assert.IsFalse(i1.ToString().Contains("CrossFit"));
            }

            try
            {
                gim1 += Gimnasio.EClases.Yoga;
                Assert.IsTrue(i1.ToString().Contains("Yoga"));
                Assert.IsTrue(gim1.ToString().Contains("NOMBRE COMPLETO: Asd, Martin"));
            }
            catch (SinInstructorException e)
            {
                Assert.IsFalse(i1.ToString().Contains("Yoga"));
            }
        }
Exemplo n.º 8
0
        public async Task <IActionResult> Create([Bind("Id,Nombre,Direccion,Localidad,Telefono")] Gimnasio gimnasio)
        {
            if (ModelState.IsValid)
            {
                _context.Add(gimnasio);
                await _context.SaveChangesAsync();

                return(RedirectToAction(nameof(Index)));
            }
            return(View(gimnasio));
        }
Exemplo n.º 9
0
        public void Gimnasio_NoNulo()
        {
            Gimnasio gim = new Gimnasio();

            // Es nulo gim?
            Assert.IsNotNull(gim);
            // Es nulo cada atributo?
            Assert.AreNotEqual(null, gim.ToString());
            Assert.AreNotEqual(null, gim.Alumnos);
            Assert.AreNotEqual(null, gim.Instructores);
        }
Exemplo n.º 10
0
        public void GimnasioInstanciaSusAtributosTest()
        {
            Gimnasio gym = new Gimnasio();

            //La lista de alumnos fue instanciada
            Assert.IsNotNull(gym._alumnos);

            //La lista de instructores fue instanciada
            Assert.IsNotNull(gym._instructores);

            //La lista de jornadas fue instanciada
            Assert.IsNotNull(gym._jornadas);
        }
Exemplo n.º 11
0
    void Start()
    {
        companionEvolutivo = GameObject.FindGameObjectWithTag("Companion").GetComponent <CompanionEvolutivo>();

        /*if (GameObject.FindGameObjectWithTag("AmbienteEvolutivo").GetComponent<Gimnasio>() != null)
         * {
         *  gym = GameObject.FindGameObjectWithTag("AmbienteEvolutivo").GetComponent<Gimnasio>();
         * }
         * else {
         *  gym = null;
         * }*/
        gym = null;
    }
Exemplo n.º 12
0
        public void Verifico_No_Null()
        {
            //Verifico si el gimnasio creo la lista de alumnos cuando se inicia.
            Gimnasio gim = new Gimnasio();

            Assert.IsNotNull(gim.Alumnos);
            //Verifico si el instructor fue cargado correctamente en el gimnasio
            Instructor i1 = new Instructor(1, "Juan", "Lopez", "12234456",
                                           EntidadesAbstractas.Persona.ENacionalidad.Argentino);

            gim += i1;
            Assert.IsNotNull(gim.Instructores[0]);
            Assert.AreEqual(i1, gim.Instructores[0]);
        }
Exemplo n.º 13
0
        public FrmPrincipal()
        {
            InitializeComponent();
            gimnasio = new Gimnasio();
            Alumno thomas = new Alumno("thomas", "ciarlo", "Boxeo", "112245654", "2531526246", "21");
            Alumno Eve    = new Alumno("eve", "ibarra", "Funcional", "1123242245654", "13324414", "21");

            thomas.AlumnoPago("Funcional", 700, "dos dias");
            Eve.AlumnoPago("Boxeo", 700, "dos dias");


            gimnasio.alumnos.Add(thomas);
            gimnasio.alumnos.Add(Eve);
        }
Exemplo n.º 14
0
 public void TestMethod2()
 {
     try
     {
         Gimnasio myGim        = new Gimnasio();
         Alumno   miAlumnoNulo = null;
         myGim += miAlumnoNulo;
         Assert.Fail("Sin excepcion para NullReferenceException");
     }
     catch (Exception e)
     {
         Assert.IsInstanceOfType(e, typeof(NullReferenceException));
     }
 }
Exemplo n.º 15
0
 public void TestMethod1()
 {
     try
     {
         Gimnasio gim = new Gimnasio();
         Alumno   a1  = new Alumno(1, "Juan", "Lopez", "12234456",
                                   EntidadesAbstractas.Persona.ENacionalidad.Extranjero, Gimnasio.EClases.CrossFit,
                                   Alumno.EEstadoCuenta.MesPrueba);
         gim += a1;
         Assert.Fail("Sin excepcion para NacionalidadInvalidaException");
     }
     catch (Exception e)
     {
         Assert.IsInstanceOfType(e, typeof(NacionalidadInvalidaException));
     }
 }
Exemplo n.º 16
0
 public void TestMethod1()
 {
     try
     {
         Gimnasio myGim    = new Gimnasio();
         Alumno   miAlumno = new Alumno(4, "Miguel", "Hernandez", "92264456",
                                        EntidadesAbstractas.Persona.ENacionalidad.Argentino, Gimnasio.EClases.Pilates,
                                        Alumno.EEstadoCuenta.AlDia);
         myGim += miAlumno;
         Assert.Fail("Sin excepcion para NacionalidadInvalidaException");
     }
     catch (Exception ex)
     {
         Assert.IsInstanceOfType(ex, typeof(NacionalidadInvalidaException));
     }
 }
Exemplo n.º 17
0
        public void pruebaAlumnoRepetido()
        {
            Gimnasio gimnasio = new Gimnasio();
            Alumno   Alumno1  = new Alumno(5, "Carlos", "Gonzalez", "12236456", EntidadesAbstractas.Persona.ENacionalidad.Argentino, Gimnasio.EClases.CrossFit, Alumno.EEstadoCuenta.AlDia);
            Alumno   Alumno2  = new Alumno(5, "Carlos", "Gonzalez", "12236456", EntidadesAbstractas.Persona.ENacionalidad.Argentino, Gimnasio.EClases.CrossFit, Alumno.EEstadoCuenta.AlDia);

            gimnasio += Alumno1;
            try
            {
                gimnasio += Alumno2;
            }
            catch (Exception e)
            {
                Assert.IsInstanceOfType(e, typeof(AlumnoRepetidoException));
            }
        }
Exemplo n.º 18
0
        public void ValidarSinInstructor()
        {
            try
            {
                Gimnasio gimnasioPrueba;
                gimnasioPrueba = new Gimnasio();

                gimnasioPrueba += Gimnasio.EClases.Natacion;

                Assert.Fail("No hay instructor.");
            }
            catch (Exception ex)
            {
                Assert.IsInstanceOfType(ex, typeof(SinInstructorException));
            }
        }
Exemplo n.º 19
0
 public void TestMethod2()
 {
     try
     {
         Gimnasio gim = new Gimnasio();
         Alumno   a2  = new Alumno(2, "Juana", "Martinez", "12234458",
                                   EntidadesAbstractas.Persona.ENacionalidad.Argentino, Gimnasio.EClases.Natacion,
                                   Alumno.EEstadoCuenta.Deudor);
         Alumno a3 = null;
         gim += a2;
         gim += a3;
         Assert.Fail("Sin excepcion para NullReferenceException");
     }
     catch (Exception e)
     {
         Assert.IsInstanceOfType(e, typeof(NullReferenceException));
     }
 }
        public void MismoAlumno()
        {
            Gimnasio gim = new Gimnasio();
            Alumno   A1  = new Alumno(1, "Juan", "Lopez", "7125468",
                                      EntidadesAbstractas.Persona.ENacionalidad.Argentino, Gimnasio.EClases.CrossFit,
                                      Alumno.EEstadoCuenta.MesPrueba);
            Alumno A2 = new Alumno(2, "Pedro", "Lopez", "7125468",
                                   EntidadesAbstractas.Persona.ENacionalidad.Argentino, Gimnasio.EClases.Natacion,
                                   Alumno.EEstadoCuenta.MesPrueba);

            gim += A1;
            try
            {
                gim += A2;
            }
            catch (Exception e)
            {
                Assert.IsInstanceOfType(e, typeof(AlumnoRepetidoException));
            }
        }
Exemplo n.º 21
0
        public void ValidarAlumnoRepetido()
        {
            try
            {
                Alumno alumnoUno;
                alumnoUno = new Alumno(1, "Santiago", "Ortiz", "40880945", Persona.ENacionalidad.Argentino, Gimnasio.EClases.Pilates, Alumno.EEstadoCuenta.AlDia);

                Alumno alumnoDos;
                alumnoDos = new Alumno(5, "Santiago", "Ortiz", "40880945", Persona.ENacionalidad.Argentino, Gimnasio.EClases.Pilates, Alumno.EEstadoCuenta.AlDia);

                Gimnasio gimnasioPrueba = new Gimnasio();

                gimnasioPrueba += alumnoUno;
                gimnasioPrueba += alumnoDos;

                Assert.Fail("Alumno repetido.");
            }
            catch (Exception ex)
            {
                Assert.IsInstanceOfType(ex, typeof(AlumnoRepetidoException));
            }
        }
Exemplo n.º 22
0
        public void SinInstructor()
        {
            try
            {
                Gimnasio gim = new Gimnasio();

                Instructor ins1 = new Instructor(65, "Agustin", "Prado", "37143078", Persona.ENacionalidad.Argentino);

                gim += ins1;

                // Un instructor tiene 2 clases, así que en alguna debería fallar.
                gim += Gimnasio.EClases.CrossFit;
                gim += Gimnasio.EClases.Natacion;
                gim += Gimnasio.EClases.Pilates;
                gim += Gimnasio.EClases.Yoga;

                Assert.Fail("Sin excepción para la falta de instructores para una clase.");
            }
            catch (Exception e)
            {
                Assert.IsInstanceOfType(e, typeof(SinInstructorException));
            }
        }
Exemplo n.º 23
0
        public void Alumno_Repetido()
        {
            // Repetido por DNI
            try
            {
                Gimnasio gim  = new Gimnasio();
                Alumno   alu1 = new Alumno(65, "Agustin", "Prado", "37143078", Persona.ENacionalidad.Argentino, Gimnasio.EClases.Natacion, Alumno.EEstadoCuenta.AlDia);
                Alumno   alu2 = new Alumno(66, "Santiago", "Prado", "37143078", Persona.ENacionalidad.Argentino, Gimnasio.EClases.CrossFit, Alumno.EEstadoCuenta.AlDia);

                gim += alu1;
                gim += alu2;

                Assert.Fail("Sin excepción para alumno repetido.");
            }
            catch (Exception e)
            {
                Assert.IsInstanceOfType(e, typeof(AlumnoRepetidoException));
            }

            // Repetido por ID
            try
            {
                Gimnasio gim  = new Gimnasio();
                Alumno   alu1 = new Alumno(65, "Agustin", "Prado", "37143078", Persona.ENacionalidad.Argentino, Gimnasio.EClases.Natacion, Alumno.EEstadoCuenta.AlDia);
                Alumno   alu2 = new Alumno(65, "Santiago", "Prado", "40000000", Persona.ENacionalidad.Argentino, Gimnasio.EClases.CrossFit, Alumno.EEstadoCuenta.AlDia);

                gim += alu1;
                gim += alu2;

                Assert.Fail("Sin excepción para alumno repetido.");
            }
            catch (Exception e)
            {
                Assert.IsInstanceOfType(e, typeof(AlumnoRepetidoException));
            }
        }
Exemplo n.º 24
0
 public FrmAltaAlumno(Gimnasio gim)
 {
     InitializeComponent();
     gimnasio = gim;
 }
Exemplo n.º 25
0
        static void Main(string[] args)
        {
            Gimnasio gim = new Gimnasio();
            Alumno   a1  = new Alumno(1, "Juan", "Lopez", "12234456",
                                      EntidadesAbstractas.Persona.ENacionalidad.Argentino, Gimnasio.EClases.CrossFit,
                                      Alumno.EEstadoCuenta.MesPrueba);

            gim += a1;
            try
            {
                Alumno a2 = new Alumno(2, "Juana", "Martinez", "12234458",
                                       EntidadesAbstractas.Persona.ENacionalidad.Extranjero, Gimnasio.EClases.Natacion,
                                       Alumno.EEstadoCuenta.Deudor);
                gim += a2;
            }
            catch (NacionalidadInvalidaException e)
            {
                Console.WriteLine(e.Message);
            }
            try
            {
                Alumno a3 = new Alumno(3, "José", "Gutierrez", "12234456",
                                       EntidadesAbstractas.Persona.ENacionalidad.Argentino, Gimnasio.EClases.CrossFit,
                                       Alumno.EEstadoCuenta.MesPrueba);
                gim += a3;
            }
            catch (AlumnoRepetidoException e)
            {
                Console.WriteLine(e.Message);
            }
            Alumno a4 = new Alumno(4, "Miguel", "Hernandez", "92264456",
                                   EntidadesAbstractas.Persona.ENacionalidad.Extranjero, Gimnasio.EClases.Pilates,
                                   Alumno.EEstadoCuenta.AlDia);

            gim += a4;
            Alumno a5 = new Alumno(5, "Carlos", "Gonzalez", "12236456",
                                   EntidadesAbstractas.Persona.ENacionalidad.Argentino, Gimnasio.EClases.CrossFit,
                                   Alumno.EEstadoCuenta.AlDia);

            gim += a5;
            Alumno a6 = new Alumno(6, "Juan", "Perez", "12234656",
                                   EntidadesAbstractas.Persona.ENacionalidad.Argentino, Gimnasio.EClases.Natacion,
                                   Alumno.EEstadoCuenta.Deudor);

            gim += a6;
            Alumno a7 = new Alumno(7, "Joaquin", "Suarez", "91122456",
                                   EntidadesAbstractas.Persona.ENacionalidad.Extranjero, Gimnasio.EClases.Natacion,
                                   Alumno.EEstadoCuenta.AlDia);

            gim += a7;
            Alumno a8 = new Alumno(8, "Rodrigo", "Smith", "22236456",
                                   EntidadesAbstractas.Persona.ENacionalidad.Argentino, Gimnasio.EClases.Pilates,
                                   Alumno.EEstadoCuenta.AlDia);

            gim += a8;
            Instructor i1 = new Instructor(1, "Juan", "Lopez", "12234456",
                                           EntidadesAbstractas.Persona.ENacionalidad.Argentino);

            gim += i1;
            Instructor i2 = new Instructor(2, "Roberto", "Juarez", "32234456",
                                           EntidadesAbstractas.Persona.ENacionalidad.Argentino);

            gim += i2;
            try
            {
                gim += Gimnasio.EClases.CrossFit;
            }
            catch (SinInstructorException e)
            {
                Console.WriteLine(e.Message);
            }
            try
            {
                gim += Gimnasio.EClases.Natacion;
            }
            catch (SinInstructorException e)
            {
                Console.WriteLine(e.Message);
            }
            try
            {
                gim += Gimnasio.EClases.Pilates;
            }
            catch (SinInstructorException e)
            {
                Console.WriteLine(e.Message);
            }
            try
            {
                gim += Gimnasio.EClases.Yoga;
            }
            catch (SinInstructorException e)
            {
                Console.WriteLine(e.Message);
            }
            Console.WriteLine(gim.ToString());
            Console.ReadKey();
            try
            {
                Gimnasio.Guardar(gim);
                Console.WriteLine("Archivo de Gimnasio guardado");
            }
            catch (ArchivosException e)
            {
                Console.WriteLine(e.Message);
            }
            try
            {
                int jornada = 0;
                Jornada.Guardar(gim[jornada]);
                Console.WriteLine("Archivo de Jornada {0} guardado", jornada);
            }
            catch (ArchivosException e)
            {
                Console.WriteLine(e.Message);
            }
            Console.ReadKey();
        }
Exemplo n.º 26
0
 public FrmListarAlumnos(Gimnasio gim)
 {
     InitializeComponent();
     gimnasio = gim;
     dataAlumnos.DataSource = gim.alumnos;
 }
Exemplo n.º 27
0
        public void TestNulo()
        {
            Alumno a3 = new Alumno(3, "pocho", "pantera", "123", Persona.ENacionalidad.Argentino, Gimnasio.EClases.Pilates, Alumno.EEstadoCuenta.AlDia);

            Assert.AreEqual(123, a3.Dni);
            Assert.AreEqual(Persona.ENacionalidad.Argentino, a3.Nacionalidad);

            Instructor I1 = new Instructor(4, "juan", "instructor", "90000000", Persona.ENacionalidad.Extranjero);

            Assert.IsNotNull(I1);
            Assert.AreEqual(Persona.ENacionalidad.Extranjero, I1.Nacionalidad);
            Assert.AreEqual(90000000, I1.Dni);

            Gimnasio gim = new Gimnasio();

            gim += a3;
            Assert.IsTrue(gim == a3);
            Assert.AreEqual(a3, gim.Alumnos[0]);
            Assert.IsNotNull(gim.Alumnos);
            //devuelve un Exception de tipo AlumnoRepetidoException
            try
            {
                gim += a3;
            }
            catch (Exception e)
            {
                Assert.IsInstanceOfType(e, typeof(AlumnoRepetidoException));
            }

            //Devuelve una Exception de tipo ArgumentOutOfRangeException porque
            //no se agrego al alumno
            try
            {
                Alumno a6 = gim.Alumnos[1];
            }
            catch (Exception e)
            {
                Assert.IsInstanceOfType(e, typeof(ArgumentOutOfRangeException));
            }



            gim += I1;
            Assert.AreEqual(I1, gim.Instructores[0]);
            Assert.IsTrue(gim == I1);
            //Devuelve una Exception de tipo ArgumentOutOfRangeException porque
            //no se agrego al Instructor
            try
            {
                gim += I1;
                Instructor I2 = gim.Instructores[1];
            }
            catch (Exception e)
            {
                Assert.IsInstanceOfType(e, typeof(ArgumentOutOfRangeException));
            }

            Jornada j1 = new Jornada(Gimnasio.EClases.Pilates, I1);

            j1 += a3;
            Assert.IsTrue(j1 == a3);

            Assert.IsTrue(Gimnasio.Guardar(gim));
        }
Exemplo n.º 28
0
 public FrmCobro(Gimnasio gim)
 {
     InitializeComponent();
     gimnasio = gim;
 }
Exemplo n.º 29
0
        public void puebaNullGimnasio()
        {
            Gimnasio gimnasio = new Gimnasio();

            Assert.IsNotNull(gimnasio);
        }