[HttpPut] //Requisição HTTP PUT
public HttpResponseMessage Put(DependenteEdicaoViewModel model)
{
//verificando se a model passou nas regras de validação
if (ModelState.IsValid)
{
try
{
//converter objeto ViewModel em entidade
var dependente = Mapper.Map <Dependente>(model);
business.Atualizar(dependente);
return(Request.CreateResponse(HttpStatusCode.OK,
"Dependente atualizado com sucesso."));
}
catch (Exception e)
{
//retornar status de erro 500 INTERNAL SERVER ERROR
return(Request.CreateResponse
(HttpStatusCode.InternalServerError, e.Message));
}
}
else
{
//retornar status de erro 400 BAD REQUEST
return(Request.CreateResponse(HttpStatusCode.BadRequest,
ValidationUtil.GetErrors(ModelState)));
}
}
public IActionResult Post([FromBody] AgendaCadastroModel model)
{
if (ModelState.IsValid)
{
try
{
var agenda = Mapper.Map <Agenda>(model);
agenda.Usuario = unitOfWork.UsuarioRepository
.Get(u => u.Email.Equals(User.Identity.Name));
//gravando o registro da agenda
unitOfWork.AgendaRepository.Add(agenda);
unitOfWork.SaveChanges();
return(Ok("Agenda cadastrada com sucesso."));
}
catch (Exception e)
{
return(StatusCode(500, e.Message));
}
}
else
{
return(BadRequest(ValidationUtil.GetErrors(ModelState)));
}
}
public IActionResult Post([FromBody] UsuarioCadastroModel model)
{
//verificar se o conteúdo do objeto está correto
//em relação às regras de validação
if (ModelState.IsValid)
{
try
{
//verificar se o email informado não existe na base de dados
if (unitOfWork.UsuarioRepository
.Get(u => u.Email.Equals(model.Email)) == null)
{
var usuario = Mapper.Map <Usuario>(model);
unitOfWork.UsuarioRepository.Add(usuario);
unitOfWork.SaveChanges();
return(Ok("Usuário cadastrado com sucesso."));
}
else
{
return(BadRequest($"O email '{model.Email}' já existe no sistema."));
}
}
catch (Exception e)
{
return(StatusCode(500, e.Message));
}
}
else
{
return(BadRequest(ValidationUtil.GetErrors(ModelState)));
}
}
[HttpPost] //Requisição HTTP POST
public HttpResponseMessage Post(FuncionarioCadastroViewModel model)
{
//verificando se a model passou nas regras de validação
if (ModelState.IsValid)
{
try
{
var funcionario = Mapper.Map <Funcionario>(model);
business.Cadastrar(funcionario);
return(Request.CreateResponse(HttpStatusCode.OK,
"Funcionário cadastrado com sucesso."));
}
catch (Exception e)
{
//retornar status de erro 500 INTERNAL SERVER ERROR
return(Request.CreateResponse
(HttpStatusCode.InternalServerError, e.Message));
}
}
else
{
//retornar status de erro 400 BAD REQUEST
return(Request.CreateResponse(HttpStatusCode.BadRequest,
ValidationUtil.GetErrors(ModelState)));
}
}
[HttpPost] //requisição do tipo POST
public HttpResponseMessage Post(ClienteCadastroModel model)
{
if (ModelState.IsValid)
{
try
{
var cliente = Mapper.Map <Cliente>(model);
ClienteRepository repository = new ClienteRepository();
if (repository.SelectByEmail(cliente.Email) == null)
{
repository.Insert(cliente);
//retornando um status de sucesso!
return(Request.CreateResponse
(HttpStatusCode.OK, "Cliente cadastrado com sucesso."));
}
return(Request.CreateResponse(HttpStatusCode.BadRequest, "Erro. O email informado já existe."));
}
catch (Exception e)
{
//HTTP 500 -> Internal Server Error
return(Request.CreateResponse(HttpStatusCode.InternalServerError, e.Message));
}
}
//HTTP 400 -> BadRequest
return(Request.CreateResponse(HttpStatusCode.BadRequest, ValidationUtil.GetErrors(ModelState)));
}
//Método para responder a requisições JavaScript
public JsonResult CadastrarTurma(TurmaCadastroViewModel model)
{
try
{
//verificar se a model passou nas regras de validação..
if (ModelState.IsValid)
{
Turma turma = Mapper.Map <Turma>(model);
//varrer aluno selecionados
if (model.AlunosSelecionados != null && model.AlunosSelecionados.Length > 0)
{
var alunoBusiness = new AlunoBusiness();
turma.Alunos = new List <Aluno>();
foreach (string idAluno in model.AlunosSelecionados)
{
//adicionar lista
turma.Alunos.Add(alunoBusiness.ConsultarPorId(int.Parse(idAluno)));
}
}
business.CadastrarTurma(turma);
return(Json($"Turma '{turma.Nome}', cadastrado com sucesso."));
}
else
{
Response.StatusCode = 400; //BAD REQUEST
return(Json(ValidationUtil.GetErrors(ModelState)));
}
}
catch (Exception e)
{
Response.StatusCode = 500; //INTERNAL SERVER ERROR
return(Json(e.Message));
}
}
//Método para responder a requisições JavaScript
public JsonResult CadastrarMatricula(MatriculaCadastroViewModel model)
{
try
{
//verificar se a model passou nas regras de validação..
if (ModelState.IsValid)
{
business.CadastrarTurmaAluno(model.IdTurma, model.IdAluno);
return(Json("Aluno matroculado com sucesso."));
}
else
{
Response.StatusCode = 400; //BAD REQUEST
return(Json(ValidationUtil.GetErrors(ModelState)));
}
}
catch (Exception e)
{
Response.StatusCode = 500; //INTERNAL SERVER ERROR
return(Json(e.Message));
}
}
public IActionResult Put([FromBody] AgendaEdicaoModel model)
{
if (ModelState.IsValid)
{
try
{
//obtendo o usuario autenticado
var usuario = unitOfWork.UsuarioRepository
.Get(u => u.Email.Equals(User.Identity.Name));
//verificar se o registro enviado pertence a este usuário
if (unitOfWork.AgendaRepository
.Get(a => a.IdAgenda == model.IdAgenda &&
a.Usuario.IdUsuario == usuario.IdUsuario) != null)
{
var agenda = Mapper.Map <Agenda>(model);
agenda.Usuario = usuario;
unitOfWork.AgendaRepository.Update(agenda);
unitOfWork.SaveChanges();
return(Ok("Agenda atualizada com sucesso."));
}
else
{
return(BadRequest("Registro de Agenda é inválido."));
}
}
catch (Exception e)
{
return(StatusCode(500, e.Message));
}
}
else
{
return(BadRequest(ValidationUtil.GetErrors(ModelState)));
}
}
//Método para responder a requisições JavaScript
public JsonResult CadastrarProfessor(ProfessorCadastroViewModel model)
{
try
{
//verificar se a model passou nas regras de validação..
if (ModelState.IsValid)
{
Professor professor = Mapper.Map <Professor>(model);
business.CadastrarProfessor(professor);
return(Json($"Professor '{professor.Nome}', cadastrado com sucesso."));
}
else
{
Response.StatusCode = 400; //BAD REQUEST
return(Json(ValidationUtil.GetErrors(ModelState)));
}
}
catch (Exception e)
{
Response.StatusCode = 500; //INTERNAL SERVER ERROR
return(Json(e.Message));
}
}
[HttpPut] //requisição do tipo PUT
public HttpResponseMessage Put(ClienteEdicaoModel model)
{
if (ModelState.IsValid)
{
try
{
var cliente = Mapper.Map <Cliente>(model);
ClienteRepository repository = new ClienteRepository();
repository.Update(cliente);
//retornando um status de sucesso!
return(Request.CreateResponse
(HttpStatusCode.OK, "Cliente atualizado com sucesso."));
}
catch (Exception e)
{
//HTTP 500 -> Internal Server Error
return(Request.CreateResponse(HttpStatusCode.InternalServerError, e.Message));
}
}
//HTTP 400 -> BadRequest
return(Request.CreateResponse(HttpStatusCode.BadRequest, ValidationUtil.GetErrors(ModelState)));
}
public object Post([FromBody] LoginModel model,
[FromServices] TokenConfiguration tokenConfiguration,
[FromServices] LoginConfiguration loginConfiguration)
{
if (ModelState.IsValid)
{
//criptografando a senha recebida
model.Senha = Criptografia.GetMD5Hash(model.Senha);
//buscar o usuario pelo login e senha
var usuario = unitOfWork.UsuarioRepository
.Get(u => u.Email.Equals(model.Email) &&
u.Senha.Equals(model.Senha));
if (usuario != null) //se o usuário foi encontrado
{
//criando as credenciais do usuario..
ClaimsIdentity identity = new ClaimsIdentity(
new GenericIdentity(usuario.Email, "Login"),
new[]
{
//registrando que o email representa o USERNAME do usuario..
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString("N")),
new Claim(JwtRegisteredClaimNames.UniqueName, model.Email)
}
);
//gerando o token
var dataCriacao = DateTime.Now;
var dataExpiracao = dataCriacao + TimeSpan.FromSeconds(tokenConfiguration.Seconds);
var handler = new JwtSecurityTokenHandler();
var securityToken = handler.CreateToken(new
SecurityTokenDescriptor
{
Issuer = tokenConfiguration.Issuer,
Audience = tokenConfiguration.Audience,
SigningCredentials = loginConfiguration.SigningCredentials,
Subject = identity,
NotBefore = dataCriacao,
Expires = dataExpiracao
});
var token = handler.WriteToken(securityToken); //CRIADO!!
return(new
{
authenticated = true,
created = dataCriacao.ToString("yyyy-MM-dd HH:mm:ss"),
expiration = dataExpiracao.ToString("yyyy-MM-dd HH:mm:ss"),
accessToken = token,
message = "OK"
});
}
else
{
return(BadRequest(
new
{
authenticated = false,
message = "Acesso negado. Usuário inválido."
}
));
}
}
else
{
return(BadRequest(ValidationUtil.GetErrors(ModelState)));
}
}