public ActionResult Cadastrar(CadastroUsuarioViewModel cadastroUsuarioViewModel)
{
if (!ModelState.IsValid)
{
return(View(cadastroUsuarioViewModel));
}
if (db.Usuarios.Count(u => u.Login == cadastroUsuarioViewModel.Login) > 0)
{
ModelState.AddModelError("Login", "Esse login já está em uso");
return(View(cadastroUsuarioViewModel));
}
Usuario novoUsuario = new Usuario
{
Nome = cadastroUsuarioViewModel.Nome,
Login = cadastroUsuarioViewModel.Login,
Senha = Hash.GeraHash(cadastroUsuarioViewModel.Senha)
};
db.Usuarios.Add(novoUsuario);
db.SaveChanges();
TempData["Mensagem"] = "Cadastro ralizado com sucesso. Efetue login";
return(RedirectToAction("Index", "Home"));
}
public ActionResult Cadastro(CadastroUsuarioViewModel model)
{
//Se os dados forem inválidos.
if (!ModelState.IsValid)
{
return(View(model));
}
if (db.Usuarios.Count(x => x.Login == model.Login) > 0)
{
ModelState.AddModelError("Login", "O nome de login já existe, por gentileza, escolha outro nome.");
return(View(model));
}
Usuarios user = new Usuarios
{
Nome = model.Nome,
Login = model.Login,
Senha = Hash.GerarHash(model.Senha)
};
db.Usuarios.Add(user);
db.SaveChanges();
TempData["Mensagem"] = "O cadastro do usuário foi realizado com sucesso, efetue o login para continuar.";
return(RedirectToAction("Login", "Autenticacao"));
}
public ActionResult Cadastrar(CadastroUsuarioViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(View(viewModel));
}
if (db.Usuarios.Count(u => u.Login == viewModel.Login) > 0)
{
ModelState.AddModelError("Login", "Esse Login já está em uso.");
return(View(viewModel));
}
Usuario usuario = new Usuario()
{
Nome = viewModel.Nome,
Login = viewModel.Login,
Senha = Hash.GerarHash(viewModel.Senha)
};
db.Usuarios.Add(usuario);
db.SaveChanges();
TempData["Message"] = "Cadastro realizado com sucesso. Efetue login.";
return(RedirectToAction("Login"));
}
public async Task <IActionResult> Cadastro(CadastroUsuarioViewModel model)
{
if (ModelState.IsValid)
{
Usuario usuario = model.ConverterParaUsuario();
IdentityResult result = await _usuarioService.Salvar(usuario, model.Senha);
if (result.Succeeded)
{
await _usuarioService.AdicionarPermissao(usuario, "Administrador");
await _usuarioService.Login(usuario, false);
return(RedirectToAction("Index", "Home"));
}
else
{
foreach (var erro in result.Errors)
{
ModelState.AddModelError("", erro.Description.ToString());
}
return(View("Cadastro"));
}
}
else
{
return(View("Cadastro"));
}
}
public ActionResult Cadastrar(CadastroUsuarioViewModel viewModel)
{
//SE AS CREDENCIAS NÃO FOREM VÁLIDAS, RETORNA PARA DE CADASTRO
if (!ModelState.IsValid)
{
return(View(viewModel));
}
//VALIDAÇÃO DE LOGIN EXISTENTE
if (db.Usuarios.Count(u => u.Login == viewModel.Login) > 0)
{
ModelState.AddModelError("Login", "Esse login já está em uso");
return(View(viewModel));
}
//CEIAÇÃO DE USUÁRIO
Usuario novoUsuario = new Usuario()
{
Nome = viewModel.Nome,
Login = viewModel.Login,
Senha = Hash.GerarHash(viewModel.Senha)
};
db.Usuarios.Add(novoUsuario);
db.SaveChanges();
TempData["Mensagem"] = "Cadastro realizado com sucesso. Efeute seu login.";
return(RedirectToAction("Login"));
}
public IActionResult POST([FromBody] CadastroUsuarioViewModel model,
[FromServices] IUsuarioRepository usuarioRepository,
[FromServices] ICriptografia criptografia)
{
if (ModelState.IsValid)
{
try
{
if (usuarioRepository.Get(model.Login) == null)
{
var usuario = new Usuario
{
Nome = model.Nome,
Login = model.Login,
DataCriacao = DateTime.Now,
Senha = criptografia.GETMD5(model.Senha)
};
usuarioRepository.Create(usuario);
return(StatusCode(200, "Usuário cadastrado com sucesso"));
}
return(StatusCode(400, "O login informado já encontra-se cadastrado."));
}
catch (Exception erro)
{
return(StatusCode(500, erro.Message));
}
}
else
{
return(StatusCode(400, ModelStateValidation.GetErrors(ModelState)));
}
}
public async Task <IActionResult> CadastroAjax(CadastroUsuarioViewModel usuarioVm)
{
try
{
if (!ModelState.IsValid)
{
return(Json(usuarioVm));
}
var usuarioIsExistente = await _accRepository.GetUserByEmail(usuarioVm.UserName);
if (usuarioIsExistente != null)
{
throw new InvalidArgumentException("Desculpe Já existente um úsuario cadastrado com o mesmo e-mail!");
}
var usuarioCadastrado = await _accRepository.CadastrarUsuario(usuarioVm, PerfilUsuarioEnum.Comun);
await _signInManager.SignInAsync(usuarioCadastrado, isPersistent : false);
return(Json("sucesso"));
}
catch (Exception e)
{
return(Json(ResponseMensage.GetMensage(StatusMensageEnum.warning, e.Message)));
}
}
public ActionResult Cadastrar(CadastroUsuarioViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(View(viewModel));
}
if (ctx.Usuarios.Count(x => x.Login == viewModel.Login) > 0)
{
ModelState.AddModelError("Login", "Esse login já esta em uso");
return(View(viewModel));
}
Usuario novoUsuario = new Usuario
{
Nome = viewModel.Nome,
Login = viewModel.Login,
Senha = Hash.GerarHash(viewModel.Senha)
};
ctx.Usuarios.Add(novoUsuario);
ctx.SaveChanges();
TempData["Mensagem"] = "Cadastro realizado com sucesso. Efetue login.";
return(RedirectToAction("Login"));
}
public ActionResult Cadastrar(CadastroUsuarioViewModel viewmodel)
{
// galera essa primeira logica é pra ver se os dados que usuario
// digitou são validos, caso não for ele vai retornar para a view para o usuario corrigir
if (!ModelState.IsValid)
{
return(View(viewmodel));
}
if (db.Usuarios.Count(u => u.Login.Equals(viewmodel.Login)) > 0)
{
ModelState.AddModelError("Login", "Esse login já está em uso");
return(View(viewmodel));
}
// Logica para criar um novo usuario com os dados vinda da model
Usuario novoUsuario = new Usuario
{
Nome = viewmodel.Nome,
Login = viewmodel.Login,
Senha = Hash.GerarHash(viewmodel.Senha) // magica da criptografia guys
};
// add e salva
db.Usuarios.Add(novoUsuario);
db.SaveChanges();
TempData["Mensagem"] = "Cadastro realizado com sucesso. Efetue login.";
// tudo ok, usuario está sendo direcionado para tela de Login
return(RedirectToAction("Login"));
}
public async Task <Usuario> CadastrarUsuario(
CadastroUsuarioViewModel cadastroUsuarioVm,
string roleName
)
{
try
{
var user = new Usuario
{
UserName = cadastroUsuarioVm.UserName,
Nome = cadastroUsuarioVm.Nome,
Sobrenome = cadastroUsuarioVm.Sobrenome,
Cpf = cadastroUsuarioVm.Cpf,
PerfilUsuario = roleName
};
var result = await _userManager.CreateAsync(user, cadastroUsuarioVm.Password);
if (!result.Succeeded)
{
throw new CreatedException("Erro ao tentar cadastrar um novo usuario");
}
await this.SetRoleForUsuario(user, roleName);
return(user);
}
catch (Exception e)
{
throw new CreatedException(e.Message);
}
}
public ActionResult Cadastrar(CadastroUsuarioViewModel viewmodel)
{
if (!ModelState.IsValid)
{
return View(viewmodel);
}
if (db.Usuarios.Count(u => u.Login == viewmodel.Login) > 0)
{
ModelState.AddModelError("Login", "Esse login já está em uso");
return View(viewmodel);
}
Usuario novoUsuario = new Usuario
{
Nome = viewmodel.Nome,
Sobrenome = viewmodel.Sobrenome,
Login = viewmodel.Login,
Senha = Hash.GerarHash(viewmodel.Senha),
Email = viewmodel.Email,
CPF = viewmodel.CPF.ToString()
};
db.Usuarios.Add(novoUsuario);
db.SaveChanges();
TempData["Mensagem"] = "Cadastro realizado com sucesso. Efetue login.";
return RedirectToAction("Login");
}
public ActionResult Cadastrar(CadastroUsuarioViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(View(viewModel));
}
if (db.Usuarios.Count(u => u.Login == viewModel.Login) > 0)
{
ModelState.AddModelError("Login", "Esse login já existe");
return(View(viewModel));
}
Usuario novoUsuario = new Usuario
{
Nome = viewModel.Nome,
Login = viewModel.Login,
Senha = hash.GerarHash(viewModel.Senha)
};
db.Usuarios.Add(novoUsuario);
db.SaveChanges();
return(RedirectToAction("index", "home"));
}
public async Task <IActionResult> Cadastro(CadastroUsuarioViewModel model)
{
if (ModelState.IsValid)
{
Usuario usuario = model.ConverterParaUsuario();
IdentityResult result = await _usuarioService.Salvar(usuario, model.Senha);
if (result.Succeeded)
{
//await _usuarioService.AdicionarPermissao(usuario, "Administrador");
await EnviarEmailConfirmacaoCadastroAsync(usuario);
//await _usuarioService.Login(usuario, false);
//return RedirectToAction("Index", "Home");
AddMensagemSucesso("Seu cadastro foi realizado. Verifique seu e-mail para confirmar seu cadastro");
return(RedirectToAction(nameof(Cadastro)));
}
else
{
foreach (var erro in result.Errors)
{
ModelState.AddModelError("", erro.Description.ToString());
}
return(View("Cadastro"));
}
}
else
{
return(View("Cadastro"));
}
}
public ActionResult Cadastrar(CadastroUsuarioViewModel viewmodel)
{
//Checa se os dados digitados são validos e cumprem os requisitos desejados
if (!ModelState.IsValid)
{ //Se não forem, retorna para a viewmodel
return(View(viewmodel));
}
//Contando se dentro do banco já existe algum login igual ao que está se cadastrando
if (db.Conexao.Count(u => u.Login == viewmodel.Login) > 0)
{
//Vincula esse modelo de erro ao 'Login'
ModelState.AddModelError("Login", "Já existe um usuário com este login");
return(View(viewmodel));
}
//Instancia novo usuario
Usuario novoUsuario = new Usuario
{
//Usuario receberá os dados pela viewmodel
Nome = viewmodel.Nome,
Login = viewmodel.Login,
//Recebendo metodo de encriptação criado
Senha = Hash.GerarHash(viewmodel.Senha)
};
//Adiciona o novo usuario para o banco de dados
db.Conexao.Add(novoUsuario);
//Salva as mudanças
db.SaveChanges();
//Redireciona para a Action Index do controlador Home
return(RedirectToAction("Index", "Home"));
}
public ActionResult Cadastrar(CadastroUsuarioViewModel recebeCadastroViewModel)
{
if (!ModelState.IsValid)
{
return(View(recebeCadastroViewModel));
}
//se o login for o mesmo
if (db.Usuarios.Count(u => u.Login == recebeCadastroViewModel.Login) > 0)
{
ModelState.AddModelError("Login", "Esse login já existe!");
return(View(recebeCadastroViewModel));
}
Usuario novoUsuario = new Usuario
{
Nome = recebeCadastroViewModel.Nome,
Login = recebeCadastroViewModel.Login,
Senha = EsperaCriativa.Utils.Hash.GeraHash(recebeCadastroViewModel.Senha), //criptografa a senha
Data = DateTime.Now,
Tipo = recebeCadastroViewModel.Tipo
};
db.Usuarios.Add(novoUsuario);
db.SaveChanges();
ViewData["MensagemPosCadastro"] = "Usuário cadastrado com sucesso";
return(RedirectToAction("Index", "Home"));
}
public ActionResult Create(CadastroUsuarioViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(View(viewModel));
}
if (db.Usuario.Count(u => u.Login == viewModel.Login) > 0)
{
ModelState.AddModelError("Login", "Usuário já cadastrado");
return(View(viewModel));
}
Usuario usuario = new Usuario
{
Nome = viewModel.Nome,
Login = viewModel.Login,
Senha = Functions.Criptografia(viewModel.Senha),
Inativo = viewModel.Inativo
};
db.Usuario.Add(usuario);
db.SaveChanges();
TempData["Success"] = "Usuário criado com sucesso";
return(RedirectToAction("Index", "Home"));
}
public ActionResult Cadastrar(CadastroUsuarioViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(View(viewModel));
}
//Valida se já existe um Login igual cadastrado
if (db.Usuarios.Count(u => u.Login == viewModel.Login) > 0)
{
//Qual o campo
ModelState.AddModelError("Login", "Esse login já está em uso!");
return(View(viewModel));
}
//Cria o usuário que será persistido no BD recebendo as informações do ViewModel
Usuario usuario = new Usuario()
{
Nome = viewModel.Nome,
Login = viewModel.Login,
Senha = viewModel.Senha.CriptografarSenha() //Metodo de extesão criado para criptografar a senha
};
db.Usuarios.Add(usuario);
db.SaveChanges();
TempData["Mensagem"] = "Cadastro realizado com sucesso! Efetue o Login.";
return(RedirectToAction("Login", "Autenticacao"));
//return RedirectToAction("Index", "Home"); /* redireciona para: View, Controller*/
}
public CadastroUsuario()
{
_viewmodel = new CadastroUsuarioViewModel();
InitializeComponent();
DataContext = _viewmodel;
_viewmodel.AtribuirSenhas = AtribuirSenhas;
_viewmodel.FecharTela = FecharTela;
}
public async Task <IActionResult> CadastrarUsuario(CadastroUsuarioViewModel usuarioVm)
{
try
{
if (!ModelState.IsValid)
{
throw new InvalidModelStateException("Por favor preencha os dados corretamente!");
}
await _accountRepository.CadastrarUsuario(usuarioVm, usuarioVm.Perfil);
return(RedirectToAction(nameof(Index)));
}
catch (Exception)
{
return(View());
}
}
public ActionResult Cadastrar(CadastroUsuarioViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(View(viewModel));
}
Usuarios novoUsuario = new Usuarios()
{
Nome = viewModel.Nome,
Login = viewModel.Login,
Senha = viewModel.Senha
};
db.Usuarios.Add(novoUsuario);
db.SaveChanges();
return(RedirectToAction("Index", "Home"));
}
public async Task <IActionResult> PostSignup([FromBody] CadastroUsuarioViewModel model)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
//var userIdentity = _mapper.Map<AppUser>(model);
var userIdentity = new ApplicationUser {
Email = model.Email, UserName = model.Email
};
var result = await _userManager.CreateAsync(userIdentity, model.Password);
if (!result.Succeeded)
{
var errorsDesc = string.Empty;
foreach (var error in result.Errors)
{
errorsDesc += error.Description;
}
throw new Exception(errorsDesc);
}
//await _appDbContext.SaveChangesAsync();
//await _signInManager.SignInAsync(userIdentity, isPersistent: false);
return(new OkObjectResult("Conta criada com sucesso."));
}
catch (Exception exc)
{
return(BadRequest(new { exception = "Erro ao criar conta. Desc.: " + exc.Message }));
}
}
public ActionResult CadastrarUsuario(CadastroUsuarioViewModel model)
{
if (ModelState.IsValid)
{
try
{
UsuarioRepository rep = new UsuarioRepository();
if (rep.HasEmail(model.Email))
{
ModelState.AddModelError("Email",
"Este email já foi cadastrado, por favor informe outro.");
}
else
{
Usuario u = new Usuario();
u.Nome = model.Nome;
u.Email = model.Email;
u.Senha = Criptografia.EncriptarSenha(model.Senha);
rep.Insert(u);
ViewBag.Mensagem = $"Usuário {u.Nome} cadastrado com sucesso.";
ModelState.Clear();
}
}
catch (Exception e)
{
ViewBag.Mensagem = e.Message;
}
}
return(View("CriarConta"));
}
public async Task <bool> IsValidUser(CadastroUsuarioViewModel cadastroUsuario) => await Service.IsValidUser(Mapper.Map <Usuario>(cadastroUsuario));
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())));
}
