예제 #1
0
        public async Task <IActionResult> Edit(int id, [Bind("FacultadId,Nombre,Direccion,Telefono,DepartamentoAlumnos,Facebook,Instagram,Twitter,PaginaWeb,Email,RecorridoVirtual")] Facultades facultades)
        {
            if (id != facultades.FacultadId)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(facultades);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!FacultadesExists(facultades.FacultadId))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(facultades));
        }
예제 #2
0
        public async Task <IActionResult> Edit(int id, [Bind("AsignaturaId,ListadoAsignaturasId,AlumnoId,CarreraId,Comision,HorarioEntrada,HorarioSalida,Dias")] Asignaturas asignaturas, string[] Dias)
        {
            if (id != asignaturas.AsignaturaId)
            {
                return(NotFound());
            }
            if (ModelState.IsValid)
            {
                asignaturas.Dias = null;
                for (int i = 0; i < Dias.Length; i++)
                {
                    if (Dias[i] == null)
                    {
                        Dias[i] = "false";
                    }

                    if (Dias[i] != "false")
                    {
                        asignaturas.Dias += Dias[i] + "-";
                    }
                }
                if (asignaturas.Dias.EndsWith("-"))
                {
                    asignaturas.Dias = asignaturas.Dias.Remove(asignaturas.Dias.Length - 1);
                }

                try
                {
                    _context.Update(asignaturas);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!AsignaturasExists(asignaturas.AsignaturaId))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            var alumnos = _context.Alumnos.Select(a => new
            {
                a.AlumnoId,
                nombreCompleto = $"ID {a.AlumnoId} - {a.Nombre} {a.Apellido}"
            });
            var carreras = _context.Carreras.Select(c => new
            {
                c.CarreraId,
                carreraNombreApellido = $"{_context.ListadoCarreras.Where(lc => lc.ListadoCarrerasId == c.ListadoCarrerasId).SingleOrDefault().Nombre} - {_context.Alumnos.Where(a => a.AlumnoId == c.AlumnoId).SingleOrDefault().Nombre} {_context.Alumnos.Where(a => a.AlumnoId == c.AlumnoId).SingleOrDefault().Apellido} - ID {_context.Alumnos.Where(a => a.AlumnoId == c.AlumnoId).SingleOrDefault().AlumnoId}"
            });

            ViewData["AlumnoId"]             = new SelectList(alumnos, "AlumnoId", "nombreCompleto", asignaturas.AlumnoId);
            ViewData["CarreraId"]            = new SelectList(carreras, "CarreraId", "carreraNombreApellido", asignaturas.CarreraId);
            ViewData["ListadoAsignaturasId"] = new SelectList(_context.ListadoAsignaturas, "ListadoAsignaturasId", "Nombre", asignaturas.ListadoAsignaturasId);
            return(View(asignaturas));
        }
예제 #3
0
        public async Task <IActionResult> Edit(int id, [Bind("id,documento,nombres,apellidos,fechaIngreso,semestre,edad,telefonoMovil,estado")] Alumnos alumnos)
        {
            if (id != alumnos.id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(alumnos);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!AlumnosExists(alumnos.id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(alumnos));
        }
        public async Task <IActionResult> Edit(int id, [Bind("ListadoAsignaturasId,ListadoCarrerasId,Codigo,Nombre,Creditos,Horas,Correlativas,Categoria")] ListadoAsignaturas listadoAsignaturas)
        {
            if (id != listadoAsignaturas.ListadoAsignaturasId)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(listadoAsignaturas);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!ListadoAsignaturasExists(listadoAsignaturas.ListadoAsignaturasId))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            ViewData["ListadoCarrerasId"] = new SelectList(_context.ListadoCarreras, "ListadoCarrerasId", "Nombre", listadoAsignaturas.ListadoCarrerasId);
            return(View(listadoAsignaturas));
        }
예제 #5
0
        public async Task <IActionResult> Edit(int id, [Bind("id,sede,letra,numero,estado")] Salones salones)
        {
            if (id != salones.id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(salones);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!SalonesExists(salones.id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(salones));
        }
        public async Task <IActionResult> Edit(int id, [Bind("AlumnoId,Nombre,Apellido,Edad,Dni")] Alumnos alumnos)
        {
            if (id != alumnos.AlumnoId)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(alumnos);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!AlumnosExists(alumnos.AlumnoId))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(alumnos));
        }
예제 #7
0
        public async Task <IActionResult> Edit(int id, [Bind("id,nombreMateria,descripcion,estado")] Materias materias)
        {
            if (id != materias.id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(materias);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!MateriasExists(materias.id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(materias));
        }
예제 #8
0
        public async Task <IActionResult> Edit(int id, [Bind("ListadoCarrerasId,FacultadId,Nombre,Titulo,DuracionEstimadaAnios")] ListadoCarreras listadoCarreras)
        {
            if (id != listadoCarreras.ListadoCarrerasId)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(listadoCarreras);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!ListadoCarrerasExists(listadoCarreras.ListadoCarrerasId))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            ViewData["FacultadId"] = new SelectList(_context.Facultades, "FacultadId", "Nombre", listadoCarreras.FacultadId);
            return(View(listadoCarreras));
        }
예제 #9
0
        public async Task <IActionResult> Edit(int id, [Bind("id,nota,documento,estado")] Notas notas)
        {
            if (id != notas.id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(notas);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!NotasExists(notas.id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(notas));
        }
예제 #10
0
        public async Task <IActionResult> Edit(int id, [Bind("CarreraId,AlumnoId,ListadoCarrerasId")] Carreras carreras)
        {
            if (id != carreras.AlumnoId)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(carreras);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!CarrerasExists(carreras.AlumnoId))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            var alumnos = _context.Alumnos.Select(a => new
            {
                a.AlumnoId,
                nombreCompleto = $"{a.Nombre} {a.Apellido}"
            });

            ViewData["AlumnoId"]          = new SelectList(alumnos, "AlumnoId", "nombreCompleto", carreras.AlumnoId);
            ViewData["ListadoCarrerasId"] = new SelectList(_context.ListadoCarreras, "ListadoCarrerasId", "Nombre", carreras.ListadoCarrerasId);
            return(View(carreras));
        }
        public async Task <IActionResult> Edit(int id, [Bind("NotasId,AsignaturaId,PrimerParcial,PrimerRecuperatorio,SegundoParcial,SegundoRecuperatorio,Final")] Notas notas)
        {
            if (id != notas.NotasId)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(notas);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!NotasExists(notas.NotasId))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            var asignaturas = _context.Asignaturas.Select(asig => new
            {
                asig.AsignaturaId,
                asignaturaNombreApellido = $"ID {asig.AsignaturaId} - {_context.ListadoAsignaturas.Where(la => la.ListadoAsignaturasId == asig.ListadoAsignaturasId).SingleOrDefault().Nombre} - {_context.Alumnos.Where(a => a.AlumnoId == asig.AlumnoId).SingleOrDefault().Nombre} {_context.Alumnos.Where(a => a.AlumnoId == asig.AlumnoId).SingleOrDefault().Apellido} - ID {_context.Alumnos.Where(a => a.AlumnoId == asig.AlumnoId).SingleOrDefault().AlumnoId}"
            });

            ViewData["AsignaturaId"] = new SelectList(asignaturas, "AsignaturaId", "asignaturaNombreApellido", notas.AsignaturaId);
            return(View(notas));
        }