public async Task <ActionResult> Registrar(ContaRegistrarViewModel modelo)
{
if (ModelState.IsValid)
{
//mandando pra model
var novoUsuario = new IdentityUser();
novoUsuario.Email = modelo.Email;
novoUsuario.UserName = modelo.UserName;
var resultado = await UserManager.CreateAsync(novoUsuario, modelo.Senha);
if (resultado.Succeeded)
{
Thread thread = new Thread(() => {
var novoUsuario1 = novoUsuario;
Thread.Sleep(15000);
Task <string> .Run(async() => await new EmailSender().SendAsyncNew(novoUsuario1.Email,
"teste 15 sec", "teste 15 sec",
"teste 15 sec")).Wait();
});
await EnviarEmailDeConfirmacaoAsync(novoUsuario);
thread.Start();
//return View("AguardandoConfirmacao");
return(RedirectToAction("Index", "Home"));
}
else
{
AdicionaErros(resultado);
}
}
return(View(modelo));
}
public async Task <ActionResult> Registrar(ContaRegistrarViewModel modelo)
{
//https://imasters.com.br/back-end/c-programacao-assincrona-async-e-await
//detecta se o estado do modelo é valido ou não
if (ModelState.IsValid)
{
//criando de fato o usuario
var novoUsuario = new UsuarioAplicacao();
//associando os campos recebidos do IdentityUser
novoUsuario.Email = modelo.Email;
novoUsuario.UserName = modelo.UserName;
novoUsuario.NomeCompleto = modelo.NomeCompleto; //campo vindo da classe UsuarioAplicacao
var resultado = await UserManager.CreateAsync(novoUsuario, modelo.Senha);
//verifica o resultado da ação
if (resultado.Succeeded)
{
await EnviarEmailDeConfirmacaoAsync(novoUsuario);
return(View("AguardandoConfirmacao")); //Apos incluir, redireciona para home
}
else
{
AdicionaErros(resultado);
}
}
//algo deu errado
return(View(modelo));
}
public async Task <ActionResult> Registrar(ContaRegistrarViewModel model)
{
if (ModelState.IsValid)
{
var newUser = new UserApplication();
newUser.NomeCompleto = model.NomeCompleto;
newUser.Email = model.Email;
newUser.UserName = model.UserName;
var user = UserManager.FindByEmail(model.Email);
var existUser = user != null;
if (existUser)
{
return(RedirectToAction("Index", "Home"));
}
var result = await UserManager.CreateAsync(newUser, model.Senha);
if (result.Succeeded)
{
return(RedirectToAction("Index", "Home"));
}
else
{
AddErrors(result);
}
}
return(View());
}
public async Task <ActionResult> Registrar(ContaRegistrarViewModel modelo)
{
if (ModelState.IsValid)
{
var novoUsuario = new UsuarioAplicacao();
novoUsuario.Email = modelo.Email;
novoUsuario.UserName = modelo.UserName;
novoUsuario.NomeCompleto = modelo.NomeCompleto;
var usuario = await UserManager.FindByEmailAsync(novoUsuario.Email);
var usuarioExiste = usuario != null;
if (usuarioExiste)
{
return(View("AguardandoConfirmacao"));
}
var resultado = await UserManager.CreateAsync(novoUsuario, modelo.Senha);
if (resultado.Succeeded)
{
await EnviarEmailConfirmacao(novoUsuario);
return(View("AguardandoConfirmacao"));
}
else
{
AdicionaErros(resultado);
}
}
return(View(modelo));
}
public async Task <ActionResult> Register(ContaRegistrarViewModel modelo)
{
if (ModelState.IsValid)
{
var newUser = new UserAplication
{
Email = modelo.Email,
UserName = modelo.UserName,
FullName = modelo.FullName
};
var usuario = await UserManager.FindByEmailAsync(modelo.Email);
var usuarioJaExiste = usuario != null;
if (usuarioJaExiste)
{
return(RedirectToAction("Home", "Home"));
}
var resultado = await UserManager.CreateAsync(newUser, modelo.Password);
if (resultado.Succeeded)
{
return(RedirectToAction("Home", "Home"));
}
else
{
AdicionaErros(resultado);
}
}
// Alguma coisa de errado aconteceu!
return(View(modelo));
}
public async Task <ActionResult> Registrar(ContaRegistrarViewModel modelo)
{
if (ModelState.IsValid)
{
var novoUsuario = new UsuarioAplicacao();
novoUsuario.Email = modelo.Email;
novoUsuario.UserName = modelo.UserName;
novoUsuario.NomeCompleto = modelo.NomeCompleto;
var usuario = UserManager.FindByEmailAsync(modelo.Email);
var usuarioJaExiste = usuario != null;
//if (usuarioJaExiste)
//return View("AguardandoConfirmacao");
//return RedirectToAction("Index", "Home");
var resultado = await UserManager.CreateAsync(novoUsuario, modelo.Senha);
if (resultado.Succeeded)
{
await EnviarEmailDeConfirmacaoAsync(novoUsuario);
return(View("AguardandoConfirmacao"));
}
else
{
AdicionaErros(resultado);
}
}
// Alguma coisa de errado aconteceu!
return(View(modelo));
}
public async Task <ActionResult> Registrar(ContaRegistrarViewModel model)
{
if (ModelState.IsValid)
{
var usuario = await UserManager.FindByEmailAsync(model.Email);
if (usuario != null)
{
return(RedirectToAction("AguardandoConfirmacao"));
}
else
{
Conta conta = new Conta()
{
UserName = model.UserName,
Email = model.Email,
NomeCompleto = model.NomeCompleto
};
var result = await UserManager.CreateAsync(conta, model.Senha);
if (result.Succeeded)
{
await EnviarEmailConfirmacao(conta);
return(RedirectToAction("AguardandoConfirmacao"));
}
else
{
AdicionaErros(result);
}
}
}
return(View());
}
public async Task <ActionResult> Registrar(ContaRegistrarViewModel modelo)
{
if (ModelState.IsValid)
{
var novoUsuario = new UsuarioAplicacao();
novoUsuario.Email = modelo.Email;
novoUsuario.UserName = modelo.UserName;
novoUsuario.NomeCompleto = modelo.NomeCompleto;
var user = await UserManager.FindByEmailAsync(modelo.Email);
if (user != null)
{
Console.WriteLine($"E-mail {modelo.Email} já cadastrado. Enviando usuário para tela inicial.");
return(View("AguardandoConfirmacao"));
}
var result = await UserManager.CreateAsync(novoUsuario, modelo.Senha);
if (result.Succeeded)
{
await EnviarEmailDeConfirmacao(novoUsuario);
return(View("AguardandoConfirmacao"));
}
else
{
AdicionaErros(result.Errors);
}
}
return(View(modelo));
}
public IActionResult Registrar(ContaRegistrarViewModel model)
{
if (ModelState.IsValid)
{
//var dbContext = new IdentityDbContext<UsuarioAplicacao>();
return(RedirectToAction("Index", "Home"));
}
return(View(model));
}
public ActionResult Registrar(ContaRegistrarViewModel modelo)
{
if (ModelState.IsValid)
{
// Podemos incluir o usuario
return(RedirectToAction("Index", "Home"));
}
return(View(modelo));
}
public ActionResult Registrar(ContaRegistrarViewModel modelo)
{
if (ModelState.IsValid)
{
var dbContext = new IdentityDbContext <UsuarioAplicacao>();
var userStore = new UserStore <UsuarioAplicacao>(dbContext);
return(RedirectToAction("Index", "Home"));
}
return(View());
}
public async Task <ActionResult> Registrar(ContaRegistrarViewModel modelo)
{
//Verifica se o estado do nosso modelo é valido ou não.
if (ModelState.IsValid)
{
// IdentUser já possui Email, UserName, entre outros, dentro das interfaces. Veja no F12.
// IdentityDbContext usa uma tabela de IdentityUser, somos obrigados a usa-lá. Ele já faz o DbSet.
var novoUsuario = new UsuarioAplicacao();
novoUsuario.Email = modelo.Email;
novoUsuario.UserName = modelo.UserName;
novoUsuario.NomeCompleto = modelo.NomeCompleto;
var usuario = await UserManager.FindByEmailAsync(modelo.Email); //Busca um usuário que já existe.
var usuarioJaExiste = usuario != null; // Diferente de null já foi cadastrado. Não devemos vazar dos dados do usuario
//Redireciona o usuario para não mostrar os dados
if (usuarioJaExiste)
{
return(View("AguardandoConfirmacao"));
}
var resultado = await UserManager.CreateAsync(novoUsuario, modelo.Senha);
// Adiciona e salva no lugar do add e save chanches do Entity.
//CreatedAsync tem tem o IdentityResult, que possui uma propriedade que tem um bool de Succeed, ou não
if (resultado.Succeeded)// Verifica se o resultado do Created teve sucesso
{
// Enviar o email de confirmação
await EnviarEmailDeConfirmacaoAsync(novoUsuario);
return(View("AguardandoConfirmacao"));
}
else
{
// Metodo criado abaixo, para adicinae erros.
//Metodo erros
AdicionaErros(resultado);
}
}
// Alguma coisa de errado aconteceu!
return(View(modelo));
}
public ActionResult Registrar(ContaRegistrarViewModel modelo)
{
if (ModelState.IsValid)
{
var novoUsuario = new UsuarioAplicacao();
novoUsuario.UserName = modelo.UserName;
novoUsuario.Email = modelo.Email;
novoUsuario.NomeCompleto = modelo.NomeCompleto;
UserManager.Create(novoUsuario, modelo.Senha);
RedirectToAction("Index", "Home");
}
//algo errado devolvemos o modelo
return(View(modelo));
}
public async Task <ActionResult> Registrar(ContaRegistrarViewModel modelo)
{
if (ModelState.IsValid)
{
//incluir usuário
//var dbContext = new IdentityDbContext<UsuarioAplicacao>("DefaultConnection");
//var userStorie = new UserStore<UsuarioAplicacao>(dbContext);
//var userManager = new UserManager<UsuarioAplicacao>(userStorie);
var newUser = new UsuarioAplicacao
{
Email = modelo.Email,
UserName = modelo.UserName,
NomeCompleto = modelo.NomeCompleto
};
var usuario = await _userManager.FindByEmailAsync(modelo.Email);
if (usuario != null)
{
return(RedirectToAction("AguardandoConfirmacao"));
}
var result = await UserManger.CreateAsync(newUser, modelo.Senha);
//dbContext.Users.Add(newUser);
//dbContext.SaveChanges();
if (result.Succeeded)
{
await EnviarEmailConfirmacaoAsync(newUser);
return(RedirectToAction("AguardandoConfirmacao"));
}
else
{
AdicionaErros(result);
}
}
return(View(modelo));
}
public async Task <ActionResult> Registrar(ContaRegistrarViewModel modelo)
{
if (ModelState.IsValid)
{
var novoUsuario = new UsuarioAplicacao();
novoUsuario.Email = modelo.Email;
novoUsuario.UserName = modelo.UserName;
novoUsuario.NomeCompleto = modelo.NomeCompleto;
await UserManager.CreateAsync(novoUsuario, modelo.Senha);
// Podemos incluir o usuário
return(RedirectToAction("Index", "Home"));
}
// Alguma coisa de errado aconteceu!
return(View(modelo));
}
public ActionResult Registrar(ContaRegistrarViewModel modelo)
{
if (ModelState.IsValid)
{
var dbContext = new IdentityDbContext <UsuarioAplicacao>();
var novoUsuario = new UsuarioAplicacao();
novoUsuario.Email = modelo.Email;
novoUsuario.UserName = modelo.UserName;
novoUsuario.NomeCompleto = modelo.NomeCompleto;
dbContext.Users.Add(novoUsuario);
dbContext.SaveChanges();
//podemos incluir usuario
return(RedirectToAction("Index", "Home"));
}
//alguma coisa de errado aconteceu
return(View(modelo));
}
public async Task <ActionResult> Registrar(ContaRegistrarViewModel modelo)
{
if (ModelState.IsValid)
{
// Passou tudo para o Owin - Startup.cs
//var dbContext = new IdentityDbContext<UsuarioAplicacao>("DefaultConnection");
//var userStore = new UserStore<UsuarioAplicacao>(dbContext);
//var userManager = new UserManager<UsuarioAplicacao>(userStore);
var novoUsuario = new UsuarioAplicacao();
novoUsuario.Email = modelo.Email;
novoUsuario.UserName = modelo.UserName;
novoUsuario.NomeCompleto = modelo.NomeCompleto;
var usuario = await UserManager.FindByEmailAsync(modelo.Email);
var usuarioJaExiste = usuario != null;
if (usuarioJaExiste)
{
return(View("AguardandoConfirmacao"));
}
var resultado = await UserManager.CreateAsync(novoUsuario, modelo.Senha);
if (resultado.Succeeded)
{
await EnviarEmailConfirmacaoAsync(novoUsuario);
return(View("AguardandoConfirmacao"));
}
else
{
AdicionErros(resultado);
}
}
return(View());
}
public async Task <ActionResult> Registrar(ContaRegistrarViewModel modelo)
{
if (ModelState.IsValid)
{
var novoUsuario = new UsuarioAplicacao();
novoUsuario.Email = modelo.UserName;
novoUsuario.UserName = modelo.UserName;
novoUsuario.NomeCompleto = modelo.NomeCompleto;
var usuario = await UserManager.FindByEmailAsync(modelo.Email);
if (usuario != null)
{
// Para proteger o usuairo, quando oemail ja estier cadastrado então redirecionaremos
// para entrada a fim de não cadastrarmos o mesmo com email duplicado e não iremos
// tambem fornecer aos hacckers a validação desse email cadastrado em nosso sistema.
return(RedirectToAction("AguardandoConfirmacao"));
}
var resultado = await UserManager.CreateAsync(novoUsuario, modelo.Senha);
if (resultado.Succeeded)
{
// enviando email para usuario
await EnviarEmailConfirmacao(novoUsuario);
// incluir usuario
return(RedirectToAction("AguardandoConfirmacao"));
}
else
{
AdicionaErro(resultado);
}
}
// algo errado aconteceu
return(View(modelo));
}
public async Task <ActionResult> RegistrarSemOwin(ContaRegistrarViewModel modelo)
{
if (ModelState.IsValid)
{
var dbContext = new IdentityDbContext <UsuarioAplicacao>("DefaultConnection");
//para desaclopar o Identity do banco de dadaos vammos uam classe the storage
var userStorage = new UserStore <UsuarioAplicacao>(dbContext);
//para de fato usar o identity sem depender da tecnolgia de banco de dataos
//temos que usar o userManager do pacote Identity
/*
* Constataremos que essa interface está no namespace do Identity, somente no Core dele. Sendo assim, vamos utilizá-la em ContaController.
* Sabendo que UserStore não é suficiente para separar o banco de dados e o Identity, precisamos de um objeto que gerencie todos os elementos.
* Portanto, abaixo de userStore, criaremos a variável userManager (termo em inglês para "gerenciamento"). Esse também é o nome da classe que
* instanciaremos. O Visual Studio não oferecerá a opção de autocompletar porque UserManager está em um namespace diferente.
*
* estamos desacoplando a dependência da tecnologia do banco de dados. Aqui sim, começamos a trabalhar com o Identity, de fato.
*/
var userManager = new UserManager <UsuarioAplicacao>(userStorage);
var novoUsuario = new UsuarioAplicacao();
novoUsuario.Email = modelo.Email;
novoUsuario.UserName = modelo.UserName;
novoUsuario.NomeCompleto = modelo.NomeCompleto;
//nao vamos mais preciar usar a tecnoligoa estpeciaficas do dbcontext.
//dbContext.Users.Add(novoUsuario);
//dbContext.SaveChanges();
//podemos incluir o usuario
await userManager.CreateAsync(novoUsuario, modelo.Senha);
return(RedirectToAction("Index", "Home"));
}
//alguma coisa aconteceu de errado.
return(View(modelo));
}
public async Task <ActionResult> Registrar(ContaRegistrarViewModel modelo)
{
if (ModelState.IsValid)
{
var usuarioExistente = await UserManager.FindByEmailAsync(modelo.Email);
var emailJaCadastrado = usuarioExistente != null;
if (emailJaCadastrado)
{
return(RedirectToAction("Index", "Home"));
}
// Registramos o usuário
var usuario = new UsuarioAplicacao
{
Email = modelo.Email,
UserName = modelo.Email,
NomeCompleto = modelo.NomeCompleto
};
var resultado = await UserManager.CreateAsync(usuario, modelo.Senha);
if (resultado.Succeeded)
{
await EnviarEmailConfirmacaoAsync(usuario);
return(View("AguardandoConfirmacao", usuario));
}
else
{
AdicionarErros(resultado);
}
}
// Algo de errado aconteceu. Mostraremos novamente esta view
// com os erros de validação.
return(View(modelo));
}
public async Task <ActionResult> Registrar(ContaRegistrarViewModel model)
{
if (ModelState.IsValid)
{
var novoUsuario = new UsuarioAplicacao
{
Email = model.Email,
UserName = model.UserName,
NomeCompleto = model.NomeCompleto
};
var usuario = await UserManager.FindByEmailAsync(model.Email);
var usuarioJaExiste = usuario != null;
if (usuarioJaExiste)
{
return(View("AguardandoConfirmação"));
}
var result = await UserManager.CreateAsync(novoUsuario, model.Senha);
if (result.Succeeded)
{
await EnviarEmailConfirmacaoAsync(novoUsuario);
return(View("AguardandoConfirmação"));
}
foreach (var erro in result.Errors)
{
ModelState.AddModelError("", erro);
}
}
return(View(model));
}
public async Task <ActionResult> Registrar(ContaRegistrarViewModel modelo)
{
if (ModelState.IsValid)
{
var novoUsuario = new UsuarioAplicacao();
novoUsuario.Email = modelo.Email;
novoUsuario.UserName = modelo.UserName;
novoUsuario.NomeCompleto = modelo.NomeCompleto;
// novoUsuario.PasswordHash = modelo.Senha;
var resultado = await UserManager.CreateAsync(novoUsuario, modelo.Senha);
if (resultado.Succeeded)
{
return(RedirectToAction("Index", "Home"));
}
else
{
AdicionaErros(resultado);
}
}
return(View(modelo));
}
public async Task <ActionResult> Registrar(ContaRegistrarViewModel modelo)
{
if (ModelState.IsValid)
{
var novoUsuario = new UsuarioAplicacao();
novoUsuario.Email = modelo.Email;
novoUsuario.UserName = modelo.UserName;
novoUsuario.NomeCompleto = modelo.NomeCompleto;
var usuario = await this.UserManager.FindByEmailAsync(modelo.Email);
var usuarioJaExiste = usuario != null;
if (usuarioJaExiste)
{
return(View("AguardandoConfirmacao"));
}
var identityResult = await this.UserManager.CreateAsync(novoUsuario, modelo.Senha);
if (identityResult.Succeeded)
{
//send the email confirmation
await this.EnviarEmailDeConfirmacao(novoUsuario);
return(View("AguardandoConfirmacao"));
}
else
{
AdicionaErros(identityResult);
}
}
//alguma coisa aconteceu de errado.
return(View(modelo));
}
public ActionResult Registrar(ContaRegistrarViewModel modelo)
{
return(View());
}
public async Task <ActionResult> Registrar(ContaRegistrarViewModel modelo)
{
if (ModelState.IsValid)
{
//dbCOntext do Identity com EF
//camada imediata é a de Acesso aos Dados (Data Access Layer) no caso é o Entity Framework
//mas poderia ser um SQL, um MongoDB entre outros
//var dbContext = new IdentityDbContext<UsuarioAplicacao>("DefaultConnection");
//classe que gera essa interface entre o Identity e o banco de dados
//tilizada para manipular os usuários dentro do Identity Framework
//var userStore = new UserStore<UsuarioAplicacao>(dbContext);
//(termo em inglês para "gerenciamento") menos específica e desacopla e pertence ao Identity (não ao EntityFramework)
//var userManager = new UserManager<UsuarioAplicacao>(userStore);
// ### AGORA TRABALHANDO COM OWIN ####
if (!ModelState.IsValid)
{
return(View(modelo));
}
var usuario = await UserManager.FindByEmailAsync(modelo.Email);
var novoUsuario = new UsuarioAplicacao();
novoUsuario.Email = modelo.Email;
novoUsuario.UserName = modelo.UserName;
novoUsuario.NomeCompleto = modelo.NomeCompleto;
var UsuarioJaExiste = usuario != null;
if (UsuarioJaExiste)
{
return(View("AguardandoConfirmacao"));
}
var resultado = await UserManager.CreateAsync(novoUsuario, modelo.Senha);
if (resultado.Succeeded)
{
// Enviar o email de confirmação
await EnviarEmailDeConfirmacaoAsync(novoUsuario);
return(View("AguardandoConfirmacao"));
}
else
{
AdicionaErros(resultado);
}
//dbContext.Users.Add(novoUsuario); trabalha com EntityFramework (muito acoplado)
//dbContext.SaveChanges(); trabalha com EntityFramework (muito acoplado)
// Podemos incluir o usuario
}
// Alguma coisa de errado aconteceu!
return(View(modelo));
}
