public IActionResult Post([FromBody]
CursoRequest cursoRequest)
{
var curso = new Curso
{
Nome = cursoRequest.Nome
};
contexto.Curso.Add(curso);
contexto.SaveChanges();
var cursoRetorno = contexto.Curso.Where
(x => x.IdCurso == curso.IdCurso)
.FirstOrDefault();
CursoResponse response = new CursoResponse();
if (cursoRetorno != null)
{
response.IdCurso = cursoRetorno.IdCurso;
response.Nome = cursoRetorno.Nome;
}
return(StatusCode(200, response));
}
public void Grabar(CursoDto dto)
{
var request = new CursoRequest
{
NombreCurso = dto.NombreCurso,
NombreProfesor = dto.NombreProfesor,
FechaInicio = dto.FechaInicio,
Id = dto.Id
};
string metodo;
Method verbo;
if (request.Id == 0)
{
metodo = "Curso/Post";
verbo = Method.POST;
}
else
{
metodo = "Curso/Put";
verbo = Method.PUT;
}
var response = _restHelper.Execute <CursoRequest, CursoResponse>(metodo, request, verbo);
if (!response.Exito)
{
throw new InvalidOperationException(response.MensajeError);
}
}
public CursoResponse Post([FromBody] CursoRequest value)
{
var response = new CursoResponse();
try
{
using (var ctx = new ContextoDb())
{
var entidad = new Curso
{
NombreCurso = value.NombreCurso,
NombreProfesor = value.NombreProfesor,
FechaInicio = value.FechaInicio,
};
ctx.Set <Curso>().Add(entidad);
AsignarDto(response, entidad);
response.Exito = ctx.SaveChanges() > 0;
}
}
catch (Exception ex)
{
response.Exito = false;
response.MensajeError = ex.Message;
}
return(response);
}
public async Task <bool> Save(CursoRequest entity)
{
var curso = _mapper.Map <Curso>(entity);
var cursoSaved = await _unitOfWork.cursoReposotory.Save(curso);
return(cursoSaved != null ? true : false);
}
public IActionResult Put(int id, [FromBody] CursoRequest cursoRequest)
{
try
{
var curso = contexto.Curso.Where(x => x.IdCurso == id)
.FirstOrDefault();
if (curso != null)
{
curso.Nome = cursoRequest.Nome;
}
contexto.Entry(curso).State =
Microsoft.EntityFrameworkCore.EntityState.Modified;
contexto.SaveChanges();
}
catch (Exception ex)
{
return(StatusCode(400, ex.InnerException.Message.FirstOrDefault()));
}
var cursoRetorno = contexto.Curso.FirstOrDefault(
x => x.IdCurso == id
);
CursoResponse retorno = new CursoResponse()
{
IdCurso = cursoRetorno.IdCurso,
Nome = cursoRetorno.Nome
};
return(StatusCode(200, retorno));
}
public CursoResponse Put([FromBody] CursoRequest value)
{
var response = new CursoResponse();
try
{
using (var ctx = new ContextoDb())
{
var entidad = ctx.GetCurso(value.Id);
if (entidad == null)
{
throw new InvalidOperationException("Registro no existe");
}
entidad.NombreCurso = value.NombreCurso;
entidad.NombreProfesor = value.NombreProfesor;
entidad.FechaInicio = value.FechaInicio;
ctx.Set <Curso>().Attach(entidad);
ctx.Entry(entidad).State = EntityState.Modified;
AsignarDto(response, entidad);
response.Exito = ctx.SaveChanges() > 0;
}
}
catch (Exception ex)
{
response.Exito = false;
response.MensajeError = ex.Message;
}
return(response);
}
public async Task <IActionResult> Update(int id, [FromBody] CursoRequest curso)
{
try
{
Curso cursoupdt = new Curso()
{
id = id,
descricao = curso.descricao,
dataInicio = Convert.ToDateTime(curso.dataInicio),
dataFim = Convert.ToDateTime(curso.dataFim),
qtdAluno = curso.qtdAluno,
categoriaid = curso.categoria.id
};
if (db.Cursos.Count(x => x.dataInicio <= cursoupdt.dataFim && x.dataFim >= cursoupdt.dataInicio) > 0)
{
return(BadRequest("Existe(m) curso(s) planejados(s) dentro do período informado"));
}
else if (cursoupdt.dataFim < cursoupdt.dataInicio)
{
return(BadRequest("Data inválida"));
}
db.Entry(cursoupdt).State = Microsoft.EntityFrameworkCore.EntityState.Modified;
db.SaveChanges();
return(Ok(cursoupdt));
}
catch
{
return(BadRequest());
}
}
public ResponseBase Atualizar(CursoRequest request)
{
var entidade = _repositorioCurso.ObterPorId(request.Id);
entidade.Atualizar(request.Nome, true);
_repositorioCurso.Editar(entidade);
return(new ResponseBase("Alterado com Sucesso!", entidade.Id));
}
public async Task <bool> Update(int id, CursoRequest entity)
{
var curso = _mapper.Map <Curso>(entity);
curso.Id = id;
var cursoUpdated = await _unitOfWork.cursoReposotory.Update(curso);
return(cursoUpdated != null ? true : false);
}
public async Task <ActionResult> Put(int id, [FromBody] CursoRequest cursoRequest)
{
var cursoUpdated = await _serviceCommand.Update(id, cursoRequest);
if (cursoUpdated)
{
return(Ok());
}
else
{
return(NotFound());
}
}
public async Task <ActionResult> Post([FromBody] CursoRequest cursoRequest)
{
var cursoSaved = await _serviceCommand.Save(cursoRequest);
if (cursoSaved)
{
return(Ok());
}
else
{
return(BadRequest());
}
}
public Curso Incluir(CursoRequest request, string usuarioCadastro)
{
var novoCurso = new Curso(request.Descricao, request.CargaHoraria, request.Valor, usuarioCadastro);
ValidarCurso(novoCurso);
if (Validar)
{
bool cursoExistente = repositorio.VerificaCursoExistente(request.Descricao);
if (!cursoExistente)
{
return(repositorio.Incluir(novoCurso));
}
else
{
AdicionarNotificacao("curso", "Curso já existe.");
}
}
return(null);
}
public ResponseBase Adicionar(CursoRequest request)
{
if (request == null)
{
throw new NotImplementedException();
}
if (request.Id > 0)
{
return(Atualizar(request));
}
var entidade = new Curso(request.Nome, true);
_repositorioCurso.Adicionar(entidade);
_repositorioCurso.SaveChanges();
return(new ResponseBase("Gravado com Sucesso!", entidade.Id));
}
public Curso Alterar(CursoRequest request, string usuarioCadastro)
{
var cursoExistente = repositorio.ObterPorId(request.Id);
if (cursoExistente != null)
{
cursoExistente.AlterarCargaHoraria(request.CargaHoraria);
cursoExistente.AlterarValor(request.Valor);
ValidarCurso(cursoExistente);
if (Validar)
{
return(repositorio.Alterar(cursoExistente));
}
}
else
{
AdicionarNotificacao("curso", Mensagem.Curso);
}
return(null);
}
public ResponseBase Adicionar(CursoRequest request)
{
if (request == null)
{
AddNotification("request", Mensagem.X0_E_OBRIGATORIO.ToFormat("request"));
return(null);
}
var entidade = new Curso(request.Nome, request.ColegioId);
AddNotifications(entidade);
if (IsInvalid())
{
return(null);
}
_repositorioCurso.Adicionar(entidade);
return(new ResponseBase(Mensagem.OPERACAO_REALIZADA_COM_SUCESSO));
}
public ResponseBase Atualizar(CursoRequest request)
{
if (request == null)
{
AddNotification("request", Mensagem.X0_E_OBRIGATORIO.ToFormat("request"));
return(null);
}
var entidade = _repositorioCurso.ObterPorId(request.Id);
entidade.Atualizar(request.Nome, true);
AddNotifications(entidade);
if (IsInvalid())
{
return(null);
}
_repositorioCurso.Editar(entidade);
return(new ResponseBase(Mensagem.OPERACAO_REALIZADA_COM_SUCESSO));
}
public async Task <IActionResult> Create([FromBody] CursoRequest curso)
{
try
{
Curso cursouinst = new Curso()
{
descricao = curso.descricao,
dataInicio = Convert.ToDateTime(curso.dataInicio),
dataFim = Convert.ToDateTime(curso.dataFim),
qtdAluno = curso.qtdAluno,
categoriaid = curso.categoria.id
};
if (db.Cursos.Count(x => x.dataInicio <= cursouinst.dataFim && x.dataFim >= cursouinst.dataInicio) > 0)
{
return(BadRequest("Existe(m) curso(s) planejados(s) dentro do período informado"));
}
else if (cursouinst.dataInicio < DateTime.Now)
{
return(BadRequest("Data inválida"));
}
else if (cursouinst.dataFim < cursouinst.dataInicio)
{
return(BadRequest("Data inválida"));
}
db.Cursos.Add(cursouinst);
db.SaveChanges();
return(Ok(curso));
}
catch (Exception ex)
{
return(BadRequest(ex));
}
}
