예제 #1
0
        public async Task <IActionResult> PostCurso([FromBody] CursoViewModel cursoDetails)
        {
            _logger.LogInformation("Agregando el curso.");

            var curso = Mapper.Map <Curso>(cursoDetails);

            if (!_repository.Cursos.HasNombreUnique(curso))
            {
                ModelState.AddModelError("Nombre", "Nombre no disponible.");
            }

            if (!_repository.Cursos.FitSchedule(curso))
            {
                ModelState.AddModelError("HorasAcademicas", "Sin espacio.");
            }

            if (ModelState.IsValid)
            {
                _repository.Cursos.Add(curso);
                if (await _repository.Complete())
                {
                    return(Created($"api/cursos/{curso.Id}", Mapper.Map <CursoViewModel>(curso)));
                }
            }

            _logger.LogError("No se pudo agregar el curso.");
            return(BadRequest(ModelState));
        }
예제 #2
0
        public async Task <IActionResult> PostColaborador([FromBody] ColaboradorViewModel colaboradorDetails)
        {
            _logger.LogInformation("Agregando al colaborador.");

            var colaborador = Mapper.Map <Colaborador>(colaboradorDetails);

            if (!_repository.Colaboradores.HasDniUnique(colaborador))
            {
                ModelState.AddModelError("Dni", "Dni no disponible.");
            }

            if (ModelState.IsValid)
            {
                _repository.Colaboradores.Add(colaborador);
                if (await _repository.Complete())
                {
                    var user = new ApplicationUser()
                    {
                        UserName      = colaboradorDetails.Email,
                        Email         = colaboradorDetails.Email + "@trilce.edu.pe",
                        ColaboradorId = colaborador.Id
                    };
                    await _userManager.CreateAsync(user, colaboradorDetails.Dni);

                    await _userManager.AddToRoleAsync(user, colaboradorDetails.Rol.Nombre);

                    await _userManager.GeneratePasswordResetTokenAsync(user);

                    return(Created($"api/usuarios/{colaborador.Id}", Mapper.Map <ColaboradorViewModel>(colaborador)));
                }
            }

            _logger.LogError("No se pudo agregar al colaborador.");
            return(BadRequest(ModelState));
        }
예제 #3
0
        public async Task <IActionResult> PostMatricula([FromBody] MatriculaViewModel matriculaDetails)
        {
            _logger.LogInformation("Agregando matrícula.");

            var matricula = Mapper.Map <Matricula>(matriculaDetails);

            matricula.RegistradorId = _userManager.FindByNameAsync(User.Identity.Name).Result.ColaboradorId;

            if (_repository.AniosAcademicos.GetAnioAcademico(DateTime.Now.Year) == null)
            {
                ModelState.AddModelError("noDisponible", "No están disponibles las matrículas.");
            }

            if (_repository.Alumnos.IsMatriculado(_repository.Alumnos.Get(matricula.AlumnoId)))
            {
                ModelState.AddModelError("yaMatriculado", "Ya está matriculado en el periodo.");
            }

            if (ModelState.IsValid)
            {
                _repository.Matriculas.Add(matricula);
                if (await _repository.Complete())
                {
                    return(Created($"api/alumno/{matricula.Id}", Mapper.Map <MatriculaViewModel>(matricula)));
                }
            }

            _logger.LogError("No se pudo agregar el alumno.");
            return(BadRequest(ModelState));
        }
예제 #4
0
        public async Task <IActionResult> PostAnioAcademico([FromBody] AnioAcademicoViewModel anioAcademicoDetails)
        {
            _logger.LogInformation("Agregando el año académico.");

            var anioAcademico = Mapper.Map <AnioAcademico>(anioAcademicoDetails);

            if (!_repository.AniosAcademicos.HasNombreUnique(anioAcademico))
            {
                ModelState.AddModelError("Nombre", "Nombre no disponible.");
            }

            if (ModelState.IsValid)
            {
                _repository.AniosAcademicos.Add(anioAcademico);
                if (await _repository.Complete())
                {
                    return(Created($"api/aniosAcademicos/{anioAcademicoDetails.Id}", Mapper.Map <AnioAcademicoViewModel>(anioAcademico)));
                }
            }
            _logger.LogError("No se pudo agregar el año académico.");
            return(BadRequest(ModelState));
        }
예제 #5
0
        public async Task <IActionResult> PostProfesor([FromBody] ProfesorViewModel profesorDetails)
        {
            _logger.LogInformation("Agregando el profesor.");

            var profesor = Mapper.Map <Profesor>(profesorDetails);

            if (!_repository.Profesores.HasDniUnique(profesor))
            {
                ModelState.AddModelError("Dni", "Dni no disponible.");
            }

            if (ModelState.IsValid)
            {
                _repository.Profesores.Add(profesor);
                if (await _repository.Complete())
                {
                    return(Created($"api/profesores/{profesorDetails.Id}", Mapper.Map <ProfesorViewModel>(profesorDetails)));
                }
            }

            _logger.LogError("No se pudo agregar el profesor.");
            return(BadRequest(ModelState));
        }
예제 #6
0
        public async Task <IActionResult> PostCronograma([FromBody] CronogramaViewModel cronogramaDetails)
        {
            _logger.LogInformation("Agregando el cronograma de matrícula.");

            var cronograma = Mapper.Map <Cronograma>(cronogramaDetails);

            if (!_repository.Cronogramas.HasNombreUnique(cronograma))
            {
                ModelState.AddModelError("Nombre", "Nombre no disponible.");
            }

            if (ModelState.IsValid)
            {
                _repository.Cronogramas.Add(cronograma);
                if (await _repository.Complete())
                {
                    return(Created($"api/cronogramasMatriculas/{cronogramaDetails.AnioAcademicoId}", Mapper.Map <CronogramaViewModel>(cronograma)));
                }
            }

            _logger.LogError("No se pudo agregar el cronograma de matrícula.");
            return(BadRequest(ModelState));
        }
예제 #7
0
        public async Task <IActionResult> PostGrado([FromBody] GradoViewModel gradoDetails)
        {
            _logger.LogInformation("Agregando el grado.");

            var grado = Mapper.Map <Grado>(gradoDetails);

            if (!_repository.Grados.HasNombreUnique(grado))
            {
                ModelState.AddModelError("Nombre", "Nombre no disponible.");
            }

            if (ModelState.IsValid)
            {
                _repository.Grados.Add(grado);
                if (await _repository.Complete())
                {
                    return(Created($"api/grados/{grado.Id}/grados", Mapper.Map <GradoViewModel>(grado)));
                }
            }

            _logger.LogError("No se pudo agregar el grado.");
            return(BadRequest(ModelState));
        }
예제 #8
0
        public async Task <IActionResult> PostAlumno([FromBody] AlumnoViewModel alumnoDetails)
        {
            _logger.LogInformation("Agregando alumno.");

            var alumno = Mapper.Map <Alumno>(alumnoDetails);

            if (!_repository.Alumnos.HasDniUnique(alumno))
            {
                ModelState.AddModelError("Alumno.Dni", "Dni no disponible.");
            }

            if (ModelState.IsValid)
            {
                _repository.Alumnos.Add(alumno);
                if (await _repository.Complete())
                {
                    return(Created($"api/alumno/{alumno.Id}", Mapper.Map <AlumnoViewModel>(alumno)));
                }
            }

            _logger.LogError("No se pudo agregar el alumno.");
            return(BadRequest(ModelState));
        }
예제 #9
0
        public async Task <IActionResult> PostSeccion([FromBody] SeccionViewModel seccionDetails)
        {
            _logger.LogInformation("Agregando la sección.");

            var seccion = Mapper.Map <Seccion>(seccionDetails);

            if (!_repository.Secciones.HasNombreUnique(seccion))
            {
                ModelState.AddModelError("Nombre", "Nombre no disponible.");
            }

            if (ModelState.IsValid)
            {
                _repository.Secciones.Add(seccion);

                if (await _repository.Complete())
                {
                    return(Created($"api/secciones/{seccion.Id}", Mapper.Map <SeccionViewModel>(seccion)));
                }
            }

            _logger.LogError("No se pudo agregar la sección.");
            return(BadRequest(ModelState));
        }