public async Task <ActionResult <MateriasCubrir> > PostMateriasCubrir(IEnumerable <MateriasCubrir> items)
{
_baseDatos.MateriasCubrir.AddRange(items);
await _baseDatos.SaveChangesAsync();
return(CreatedAtAction(nameof(GetMateriasCubrirs), items));
}
public async Task <ActionResult <Estudiante> > PostEstudiante(Estudiante item)
{
_baseDatos.Estudiantes.Add(item);
await _baseDatos.SaveChangesAsync();
return(CreatedAtAction(nameof(GetEstudiante), new { id = item.id }, item));
}
public async Task <ActionResult <Estudiante> > PostEstudiante(IEnumerable <Estudiante> items)
{
_baseDatos.Estudiantes.AddRange(items);
await _baseDatos.SaveChangesAsync();
return(CreatedAtAction(nameof(GetEstudiantes), items));
}
public async Task <ActionResult <Curso> > PostCurso(Curso item)
{
_baseDatos.Cursos.Add(item);
await _baseDatos.SaveChangesAsync();
return(CreatedAtAction(nameof(GetCurso), new { id = item.id }, item));
}
public async Task <ActionResult <Profesor> > PostProfesor(IEnumerable <Profesor> items)
{
_baseDatos.Profesores.AddRange(items);
await _baseDatos.SaveChangesAsync();
return(CreatedAtAction(nameof(GetProfesores), items));
}
public async Task <ActionResult <Usuario> > PostUsuario(IEnumerable <Usuario> items)
{
_baseDatos.Usuarios.AddRange(items);
await _baseDatos.SaveChangesAsync();
return(CreatedAtAction(nameof(GetUsuarios), items));
}
public async Task <IActionResult> PutPais(int id, Pais pais)
{
if (id != pais.Id)
{
return(BadRequest());
}
_baseDatos.Entry(pais).State = EntityState.Modified;
await _baseDatos.SaveChangesAsync();
return(Ok("sucess"));
}
public async Task <IActionResult> PutCurso(int id, Curso curso)
{
if (id != curso.Id)
{
return(BadRequest());
}
_baseDatos.Entry(curso).State = EntityState.Modified;
await _baseDatos.SaveChangesAsync();
return(Ok("sucess"));
}
public async Task <IActionResult> DeleteCurso(int id)
{
var curso = await _baseDatos.Cursos.FindAsync(id);
if (curso == null)
{
return(NotFound());
}
_baseDatos.Cursos.Remove(curso);
await _baseDatos.SaveChangesAsync();
return(Ok("success"));
}
public async Task <IActionResult> PutUsuario(string id, Usuario usuario)
{
if (id != usuario.UsuarioId)
{
return(BadRequest());
}
_baseDatos.Entry(usuario).State = EntityState.Modified;
await _baseDatos.SaveChangesAsync();
return(Ok("sucess"));
}
public async Task <IActionResult> DeletePais(int id)
{
var pais = await _baseDatos.Paises.FindAsync(id);
if (pais == null)
{
return(NotFound());
}
_baseDatos.Paises.Remove(pais);
await _baseDatos.SaveChangesAsync();
return(Ok("success"));
}
public async Task <IActionResult> DeleteMateria(int id)
{
var materia = await _baseDatos.Materias.FindAsync(id);
if (materia == null)
{
return(NotFound());
}
_baseDatos.Materias.Remove(materia);
await _baseDatos.SaveChangesAsync();
return(Ok("success"));
}
public async Task <IActionResult> DeleteEstudiante(int id)
{
var estudiante = await _baseDatos.Estudiantes.FindAsync(id);
if (estudiante == null)
{
return(NotFound());
}
_baseDatos.Estudiantes.Remove(estudiante);
await _baseDatos.SaveChangesAsync();
return(Ok("success"));
}
public async Task <string> RegistrarAsignatura(Asignatura registroAsignatura)
{
var asignatura = _baseDatos.Asignaturas.FirstOrDefault(q => q.Id == registroAsignatura.Id);
var asignaturaExiste = asignatura != null;
if (asignaturaExiste)
{
return("La asignatura ya existe");
}
var respuestaDomain = _asignaturaDomainServices.RegistrarAsignatura(registroAsignatura);
var vieneConErrorEnElDomain = respuestaDomain != null;
if (vieneConErrorEnElDomain)
{
return(respuestaDomain);
}
_baseDatos.Asignaturas.Add(registroAsignatura);
try
{
await _baseDatos.SaveChangesAsync();
return(null);
}
catch (Exception)
{
return("Oops! hubo un problema al guardar en la base de datos");
}
}
public async Task <string> RegistrarUsuario(Usuario registroUsuario)
{
var usuario = _baseDatos.Usuarios.FirstOrDefault(q => q.UsuarioId == registroUsuario.UsuarioId);
var usuarioExiste = usuario != null;
if (usuarioExiste)
{
return("El usuario ya existe");
}
var respuestaDomain = _usuarioDomainService.RegistrarUsuario(registroUsuario);
var vieneConErrorEnElDomain = respuestaDomain != null;
if (vieneConErrorEnElDomain)
{
return(respuestaDomain);
}
_baseDatos.Usuarios.Add(registroUsuario);
try
{
await _baseDatos.SaveChangesAsync();
return(null);
}
catch (Exception)
{
return("Oops! hubo un problema al guardar en la base de datos");
}
}
public async Task <string> RegistrarDocente(Docente registroDocente)
{
var docente = _baseDatos.Docentes.FirstOrDefault(q => q.Id == registroDocente.Id);
var docenteExiste = docente != null;
if (docenteExiste)
{
return("El docente ya existe");
}
var respuestaDomain = _docenteDomainServices.RegistrarDocente(registroDocente);
var vieneConErrorEnElDomain = respuestaDomain != null;
if (vieneConErrorEnElDomain)
{
return(respuestaDomain);
}
_baseDatos.Docentes.Add(registroDocente);
try
{
await _baseDatos.SaveChangesAsync();
return(null);
}
catch (Exception)
{
return("Oops! hubo un problema al guardar en la base de datos");
}
}
public async Task <string> RegistrarMateria(MateriasCubrir materiaCubrirRequest)
{
var materia = _baseDatos.MateriasCubrir.FirstOrDefault(q => q.Id == materiaCubrirRequest.Id);
var materiaExiste = materia != null;
if (materiaExiste)
{
return("La materia ya existe");
}
var respuestaDomain = _materiaDomainServices.RegistrarMateria(materiaCubrirRequest);
var vieneConErrorEnElDomain = respuestaDomain != null;
if (vieneConErrorEnElDomain)
{
return(respuestaDomain);
}
_baseDatos.MateriasCubrir.Add(materiaCubrirRequest);
try
{
await _baseDatos.SaveChangesAsync();
return(null);
}
catch (Exception)
{
return("Oops! hubo un problema al guardar en la base de datos");
}
}
public async Task <string> RegistrarCurso(Curso cursoRequest)
{
var cursoe = _baseDatos.Cursos.FirstOrDefault(q => q.Id == cursoRequest.Id);
var cursoeExiste = cursoe != null;
if (cursoeExiste)
{
return("El Curso ya existe");
}
var respuestaDomain = _cursoDomainServices.RegistrarCurso(cursoRequest);
var vieneConErrorEnElDomain = respuestaDomain != null;
if (vieneConErrorEnElDomain)
{
return(respuestaDomain);
}
_baseDatos.Cursos.Add(cursoRequest);
try
{
await _baseDatos.SaveChangesAsync();
return(null);
}
catch (Exception)
{
return("Oops! hubo un problema al guardar en la base de datos");
}
}
public async Task <string> RegistrarProfesor(Profesor profesorRequest)
{
var prof = _baseDatos.Cursos.FirstOrDefault(q => q.Id == profesorRequest.Id);
var profExiste = prof != null;
if (profExiste)
{
return("El Profesor ya existe");
}
var respuestaDomain = _profesorDomainServices.RegistrarProfesor(profesorRequest);
var vieneConErrorEnElDomain = respuestaDomain != null;
if (vieneConErrorEnElDomain)
{
return(respuestaDomain);
}
_baseDatos.Profesores.Add(profesorRequest);
try
{
await _baseDatos.SaveChangesAsync();
return(null);
}
catch (Exception)
{
return("Oops! hubo un problema al guardar en la base de datos");
}
}
public async Task <string> RegistrarPais(Pais paisRequest)
{
var pais = _baseDatos.Paises.FirstOrDefault(q => q.Id == paisRequest.Id);
var paisExiste = pais != null;
if (paisExiste)
{
return("El pais ya existe");
}
var respuestaDomain = _paisDomainServices.RegistrarPais(paisRequest);
var vieneConErrorEnElDomain = respuestaDomain != null;
if (vieneConErrorEnElDomain)
{
return(respuestaDomain);
}
_baseDatos.Paises.Add(paisRequest);
try
{
await _baseDatos.SaveChangesAsync();
return(null);
}
catch (Exception)
{
return("Oops! hubo un problema al guardar en la base de datos");
}
}
public async Task <IActionResult> PutDocente(int id, Docente docente)
{
if (id != docente.Id)
{
return(BadRequest());
}
Asignatura asignatura = await _baseDatos.Asignaturas.FirstOrDefaultAsync(q => q.Id == docente.AsignaturaId);
if (asignatura == null)
{
return(NotFound("La asignatura no existe"));
}
_baseDatos.Entry(docente).State = EntityState.Modified;
await _baseDatos.SaveChangesAsync();
return(Ok("success"));
}
public async Task <IActionResult> PutAsignatura(int id, Asignatura asignatura)
{
if (id != asignatura.Id)
{
return(BadRequest());
}
Curso curso = await _baseDatos.Cursos.FirstOrDefaultAsync(q => q.Id == asignatura.CursoId);
if (curso == null)
{
return(NotFound("El curso no existe"));
}
_baseDatos.Entry(asignatura).State = EntityState.Modified;
await _baseDatos.SaveChangesAsync();
return(Ok("success"));
}
public async Task <string> RegistrarEstudiante(Estudiante estudianteRequest)
{
var estudiante = _baseDatos.Estudiantes.FirstOrDefault(q => q.Id == estudianteRequest.Id);
var estudianteExiste = estudiante != null;
if (estudianteExiste)
{
return("El estudiante ya existe");
}
var curso = _baseDatos.Cursos.FirstOrDefault(q => q.Id == estudianteRequest.CursoId);
var noExisteCurso = curso == null;
if (noExisteCurso)
{
return("El curso no existe");
}
var pais = _baseDatos.Paises.FirstOrDefault(q => q.Id == estudianteRequest.PaisId);
var NoExistePais = pais == null;
if (NoExistePais)
{
return("El pais no existe");
}
var respuestaDomain = _estudianteDomainServices.RegistrarEstudiante(estudianteRequest);
var vieneConErrorEnElDomain = respuestaDomain != null;
if (vieneConErrorEnElDomain)
{
return(respuestaDomain);
}
_baseDatos.Estudiantes.Add(estudianteRequest);
try
{
await _baseDatos.SaveChangesAsync();
return(null);
}
catch (Exception)
{
return("Oops! hubo un problema al guardar en la base de datos");
}
}
public async Task <string> RegistrarProfesor(Profesor profesorRequest)
{
var profesor = _baseDatos.Profesores.FirstOrDefault(q => q.Id == profesorRequest.Id);
var profesorExiste = profesor != null;
if (profesorExiste)
{
return("El profesor ya existe");
}
var pais = _baseDatos.Paises.FirstOrDefault(q => q.Id == profesorRequest.PaisId);
var noExistePais = pais == null;
if (noExistePais)
{
return("El pais no existe");
}
var materia = _baseDatos.Materias.FirstOrDefault(q => q.Id == profesorRequest.MateriaId);
var noExisteMateria = materia == null;
if (noExisteMateria)
{
return("La materia no existe");
}
var respuestaDomain = _profesorDomainServices.RegistrarProfesor(profesorRequest);
var vieneConErrorEnElDomain = respuestaDomain != "Successful";
if (vieneConErrorEnElDomain)
{
return(respuestaDomain);
}
_baseDatos.Profesores.Add(profesorRequest);
try
{
await _baseDatos.SaveChangesAsync();
return(null);
}
catch (Exception)
{
return("Oops! hubo un problema al guardar en la base de datos");
}
}