public async Task <ActionResult <Resultado <LoginResponseViewModel> > > Cadastrar(CadastroUsuarioViewModel cadastroUsuario)
{
if (User.Identity.IsAuthenticated)
{
return(Ok(Resultado.Failed()));
}
if (!ModelState.IsValid)
{
return(Ok(Resultado.Failed("Dados incorretos")));
}
if (!await _usuarioService.IsValidUser(cadastroUsuario))
{
return(Ok(Resultado.Failed(_notificador.GetNotifications().Select(x => x.Mensagem).ToArray())));
}
var user = _map.Map <AspNetUser>(cadastroUsuario);
var result = await _userManager.CreateAsync(user, cadastroUsuario.senha);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, false);
return(Ok(Resultado <LoginResponseViewModel> .Successfull(await GenerateJWT(cadastroUsuario.email))));
}
return(Ok(Resultado.Failed(GetRegisterErrors(result.Errors).ToArray())));
}
public async Task <ActionResult <Resultado <LoginResponseViewModel> > > Login(LoginViewModel login)
{
if (User.Identity.IsAuthenticated)
{
return(Ok(Resultado.Failed()));
}
if (!ModelState.IsValid)
{
return(Ok(Resultado.Failed("Dados Incorretos")));
}
var result = await _signInManager.PasswordSignInAsync(login.Email, login.Senha, false, true);
if (result.Succeeded)
{
if (!await _usuarioService.IsActiveUser(login.Email))
{
return(Ok(Resultado.Failed("Usuário inativo, entre em contato com [email protected] para verificar sobre seu acesso")));
}
return(Ok(Resultado <LoginResponseViewModel> .Successfull(await GenerateJWT(login.Email))));
}
if (result.IsLockedOut)
{
return(Ok(Resultado.Failed("Usuário temporáriamente bloqueado por tentativas inválidas")));
}
return(Ok(Resultado.Failed("Usuário ou Senha incorretos")));
}
public async Task <Resultado <ManifestacaoViewModel> > GetById(int id)
{
var manifestation = MapToViewModel(await _service.GetByIdWithDetails(id, _user.GetId()));
return(Notificador.HasNotification()
? Resultado <ManifestacaoViewModel> .Failed(Notificador.GetNotificationsMessages())
: Resultado <ManifestacaoViewModel> .Successfull(manifestation));
}
public async Task <Resultado <QuestionarioRespostaDetailViewModel> > GetAnswersById(int id)
{
var answers = Mapper.Map <QuestionarioRespostaDetailViewModel>(await _service.GetByIdWithAnswers(id));
return(Notificador.HasNotification()
? Resultado <QuestionarioRespostaDetailViewModel> .Failed(Notificador.GetNotificationsMessages())
: Resultado <QuestionarioRespostaDetailViewModel> .Successfull(answers));
}
public async Task <Resultado> Delete(int id)
{
await _service.Delete(id);
return(Notificador.HasNotification()
? Resultado <CursoViewModel> .Failed(Notificador.GetNotificationsMessages())
: Resultado.Successfull());
}
public async Task <Resultado <QuestionarioReportViewModel> > GetQuizForReport(int id)
{
var quiz = Mapper.Map <QuestionarioReportViewModel>(await _service.GetQuizForReport(id));
return(Notificador.HasNotification()
? Resultado <QuestionarioReportViewModel> .Failed(Notificador.GetNotificationsMessages())
: Resultado <QuestionarioReportViewModel> .Successfull(quiz));
}
public async Task <Resultado <List <QuestionarioRespostaViewModel> > > GetAnswersByQuiz(int idQuestionario)
{
var answers = MapToViewModel(await _service.GetAnswersByQuiz(idQuestionario));
return(Notificador.HasNotification()
? Resultado <List <QuestionarioRespostaViewModel> > .Failed(Notificador.GetNotificationsMessages())
: Resultado <List <QuestionarioRespostaViewModel> > .Successfull(answers));
}
public async Task <Resultado> Delete(int id)
{
await _service.Delete(id);
return(Notificador.HasNotification() ?
Resultado.Failed(Notificador.GetNotifications().Select(x => x.Mensagem).ToArray()) :
Resultado.Successfull());
}
public async Task <Resultado> IsUserAbleToAnswer(int idQuestionario, int idUsuario)
{
await _service.IsUserAbleToAnswer(idQuestionario, idUsuario);
return(Notificador.HasNotification()
? Resultado.Failed(Notificador.GetNotificationsMessages())
: Resultado.Successfull());
}
public async Task <ActionResult <Resultado> > Reply(CadastroQuestionarioRespostaViewModel resposta)
{
if (!ModelState.IsValid)
{
return(Ok(Resultado.Failed("Dados inválidos")));
}
var userId = int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value);
return(Ok(await _questionarioRespostaService.Create(resposta, userId)));
}
public async Task <ActionResult <Resultado <CursoViewModel> > > Put(int id, CursoViewModel cursoViewModel)
{
if (id != cursoViewModel.id)
{
return(BadRequest());
}
return(ModelState.IsValid ?
Ok(await _service.Update(cursoViewModel)) :
Ok(Resultado <CursoViewModel> .Failed(ModelState.Values.Select(x => x.Errors).FirstOrDefault().ToString())));
}
public async Task <ActionResult <Resultado <DepartamentoViewModel> > > Put(int id, AtualizacaoDepartamentoViewModel departamentoViewModel)
{
if (id != departamentoViewModel.id)
{
return(BadRequest());
}
return(ModelState.IsValid ?
Ok(await _service.Update(departamentoViewModel)) :
Ok(Resultado <DepartamentoViewModel> .Failed(ModelState.Values.Select(x => x.Errors).ToString())));
}
public async Task <Resultado> Create(CadastroQuestionarioViewModel questionario, int userId)
{
var quiz = Mapper.Map <Questionario>(questionario);
quiz.SetCreator(userId);
await _service.Create(quiz);
return(Notificador.HasNotification()
? Resultado.Failed(Notificador.GetNotificationsMessages())
: Resultado.Successfull());
}
public async Task <Resultado <DepartamentoViewModel> > Update(AtualizacaoDepartamentoViewModel atualizacaoDepartamento)
{
var Departamento = base.Mapper.Map <Departamento>(atualizacaoDepartamento);
await _service.Update(Departamento);
var DepartamentoViewModel = base.MapToViewModel(Departamento);
return(Notificador.HasNotification() ?
Resultado <DepartamentoViewModel> .Failed(Notificador.GetNotifications().Select(x => x.Mensagem).ToArray()) :
Resultado <DepartamentoViewModel> .Successfull(DepartamentoViewModel));
}
public async Task <Resultado <CursoViewModel> > Create(CursoViewModel cursoViewModel)
{
var curso = MapToDomain(cursoViewModel);
await _service.Create(curso);
cursoViewModel = MapToViewModel(curso);
return(Notificador.HasNotification()
? Resultado <CursoViewModel> .Failed(Notificador.GetNotificationsMessages())
: Resultado <CursoViewModel> .Successfull(cursoViewModel));
}
public async Task <Resultado> Create(CadastroQuestionarioRespostaViewModel resposta, int idUsuario)
{
var response = Mapper.Map <QuestionarioResposta>(resposta);
response.SetUser(idUsuario);
await _service.Create(response);
return(Notificador.HasNotification()
? Resultado.Failed(Notificador.GetNotificationsMessages())
: Resultado.Successfull());
}
public async Task <Resultado> Create(CadastroManifestacaoViewModel manifestacao)
{
var manifestation = Mapper.Map <Manifestacao>(manifestacao);
manifestation.SetCreator(_user.GetId());
await _service.Create(manifestation);
return(Notificador.HasNotification()
? Resultado.Failed(Notificador.GetNotificationsMessages())
: Resultado.Successfull());
}
public async Task <Resultado <UsuarioViewModel> > Update(AtualizacaoUsuarioViewModel atualizacaoUsuario)
{
var usuario = base.Mapper.Map <Usuario>(atualizacaoUsuario);
await Service.Update(usuario);
var usuarioViewModel = base.MapToViewModel(usuario);
usuarioViewModel.usuarioPerfil = atualizacaoUsuario.UsuarioPerfil;
return(Notificador.HasNotification()
? Resultado <UsuarioViewModel> .Failed(Notificador.GetNotificationsMessages())
: Resultado <UsuarioViewModel> .Successfull(usuarioViewModel));
}
public async Task <Resultado <InteracaoViewModel> > Reply(CadastroInteracaoViewModel resposta)
{
var reply = Mapper.Map <Interacao>(resposta);
reply.SetCreator(_user.GetId());
await _interationService.Create(reply);
var interaction = Mapper.Map <InteracaoViewModel>(reply);
return(Notificador.HasNotification()
? Resultado <InteracaoViewModel> .Failed(Notificador.GetNotificationsMessages())
: Resultado <InteracaoViewModel> .Successfull(interaction));
}
public async Task <ActionResult <Resultado <UsuarioViewModel> > > Put(int id, AtualizacaoUsuarioViewModel atualizacaoUsuario)
{
if (id != atualizacaoUsuario.id)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(Ok(Resultado <CursoViewModel> .Failed(ModelState.Values.Select(x => x.Errors).ToString())));
}
var result = await _service.Update(atualizacaoUsuario);
if (result.Success)
{
var user = await _userManager.FindByIdAsync(result.Data.id.ToString());
var claims = await _userManager.GetClaimsAsync(user);
if (claims.Count > 0 && atualizacaoUsuario.UsuarioPerfil == UsuarioPerfil.Usuario)
{
await _userManager.RemoveClaimsAsync(user, claims);
}
else if (atualizacaoUsuario.UsuarioPerfil != UsuarioPerfil.Usuario)
{
var claim = new Claim(atualizacaoUsuario.UsuarioPerfil.ToString(),
atualizacaoUsuario.UsuarioPerfil.ToString());
if (claims.Count > 0 && !claims.Select(x => x.Type).Contains(claim.Type))
{
await _userManager.RemoveClaimsAsync(user, claims);
await _userManager.AddClaimAsync(user, claim);
}
else if (claims.Count == 0)
{
await _userManager.AddClaimAsync(user, claim);
}
}
}
return(Ok(result));
}
public async Task <ActionResult <Resultado <CursoViewModel> > > Post(CursoViewModel cursoViewModel) => ModelState.IsValid ? Ok(await _service.Create(cursoViewModel)) : Ok(Resultado <CursoViewModel> .Failed(ModelState.Values.Select(x => x.Errors).FirstOrDefault().ToString()));
public async Task <ActionResult <Resultado <DepartamentoViewModel> > > Post(CadastroDepartamentoViewModel cadastroDepartamentoViewModel) => ModelState.IsValid ? Ok(await _service.Create(cadastroDepartamentoViewModel)) : Ok(Resultado <DepartamentoViewModel> .Failed(ModelState.Values.Select(x => x.Errors).ToString()));