public async Task <IActionResult> Registrar(UsuarioRegistro usuarioRegistro)
{
if (!ModelState.IsValid)
{
return(RespostaPersonalizada(ModelState));
}
var user = new IdentityUser
{
UserName = usuarioRegistro.Email,
Email = usuarioRegistro.Email,
EmailConfirmed = true
};
var result = await _userManager.CreateAsync(user, usuarioRegistro.Senha);
if (result.Succeeded)
{
// integração aqui.
var response = await RegistrarCliente(usuarioRegistro);
await _signInManager.SignInAsync(user, false);
var login = await GerarJwt(usuarioRegistro.Email);
return(RespostaPersonalizada(login));
}
foreach (var erro in result.Errors)
{
AdicionarErro(erro.Description);
}
return(RespostaPersonalizada());
}
public async Task <ActionResult> Registrar(UsuarioRegistro usuarioRegistro)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var user = new IdentityUser
{
// O Identity ele difere, você pode tanto ter um nome de usuário que não seja o seu email,
// quanto o nome de usuário que seja o email, então é recomendável usar do usuário como email,
// porque dai o seu usuário não precisa ficar lembrando qual o nome de usuário que ele usou na sua
// aplicação, basta ele lembrar qual que é o email - e ainda você pode contrar se ele é único ou não,
// de uma forma mais simples;
UserName = usuarioRegistro.Email,
Email = usuarioRegistro.Email,
EmailConfirmed = true
};
// a instância do user não requer a senha, a senha será passada a parte (ela será criptografada);
var result = await _userManager.CreateAsync(user, usuarioRegistro.Senha);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, false);
return(Ok(await GerarJwt(usuarioRegistro.Email)));
}
return(BadRequest());
}
public async Task <ActionResult> Registrar(UsuarioRegistro usuarioRegistro)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
var user = new User
{
Id = Guid.NewGuid(),
Nome = usuarioRegistro.Nome,
Responsabilidade = usuarioRegistro.Responsabilidade,
Avatar = usuarioRegistro.Avatar.FromImageToString(),
UserName = usuarioRegistro.Email,
Email = usuarioRegistro.Email,
EmailConfirmed = true
};
var result = await _userManager.CreateAsync(user, usuarioRegistro.Senha);
if (result.Succeeded)
{
return(CustomResponse(await GerarJwt(usuarioRegistro.Email)));
}
result.Errors.ToList().ForEach(error => AdicionarErroProcessamento(error.Description));
return(CustomResponse());
}
public async Task <ActionResult> Register(UsuarioRegistro usuarioRegistro)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState)); // Se ModelState não for válida, passamos a ModelState por parametro para o método CustomResponse do controlador Main para que possa coletar os erros.
}
var user = new IdentityUser
{
UserName = usuarioRegistro.Email,
Email = usuarioRegistro.Email,
EmailConfirmed = true
};
// Criando novo usuário
var result = await _userManager.CreateAsync(user, usuarioRegistro.Senha);
if (result.Succeeded)
{
// Se usuário foi criado com sucesso, geramos um JWT através da chamada do método GerarJwt passando o E-mail do usuário por parâmetro.
return(CustomResponse(await GerarJwt(usuarioRegistro.Email)));
}
else
{
// Senão coleta erros do nosso resultado e os passa por parâmetro para o método AdicionarErroProcessamento
foreach (var error in result.Errors)
{
AdicionarErroProcessamento(error.Description);
}
return(CustomResponse());
}
}
public async Task <ActionResult> Registrar(UsuarioRegistro usuarioRegistro)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
// Usuario do Identity
var user = new IdentityUser
{
UserName = usuarioRegistro.Email,
Email = usuarioRegistro.Email,
EmailConfirmed = true
};
// Criando Usuario
var result = await _userManager.CreateAsync(user, usuarioRegistro.Senha);
// Gera o Token se for sucesso
if (result.Succeeded)
{
// Logando usuario
// await _signInManager.SignInAsync(user, false);
return(CustomResponse(await GerarJWT(usuarioRegistro.Email)));
}
// Verifica se tem erro
foreach (var error in result.Errors)
{
AdicionarErroProcessamento(error.Description);
}
return(CustomResponse());
}
public async Task <UsuarioRespostaLogin> Registro(UsuarioRegistro usuarioRegistro)
{
var registroContent = new StringContent(
content: JsonSerializer.Serialize(usuarioRegistro),
encoding: Encoding.UTF8,
mediaType: "application/json");
var response = await _httpClient.PostAsync(requestUri : "https://localhost:44348/api/identidade/nova-conta", registroContent);
var options = new JsonSerializerOptions
{
PropertyNameCaseInsensitive = true
};
if (!TratarErrosResponse(response))
{
return(new UsuarioRespostaLogin
{
ResponseResult =
JsonSerializer.Deserialize <ResponseResult>(await response.Content.ReadAsStringAsync(), options)
});
}
return(JsonSerializer.Deserialize <UsuarioRespostaLogin>(await response.Content.ReadAsStringAsync(), options));
}
public async Task <IActionResult> Registrar(UsuarioRegistro usuarioRegistro)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var user = new IdentityUser
{
UserName = usuarioRegistro.Email,
Email = usuarioRegistro.Email,
EmailConfirmed = true
};
var result = await _userManager.CreateAsync(user, usuarioRegistro.Senha);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, false);
return(Ok(await GerarJwt(usuarioRegistro.Email)));
}
return(BadRequest());
}
public async Task <ActionResult> Registrar(UsuarioRegistro usuarioRegistro)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
var user = new IdentityUser
{
UserName = usuarioRegistro.Email,
Email = usuarioRegistro.Email,
EmailConfirmed = true
};
var result = await _userManager.CreateAsync(user, usuarioRegistro.Senha);
if (result.Succeeded)
{
return(CustomResponse(await GerarJwt(usuarioRegistro.Email)));
}
foreach (var error in result.Errors)
{
AddError(error.Description);
}
return(CustomResponse());
}
public async Task <HttpResponseMessage> EnviarIdentidade(UsuarioRegistro autenticacao)
{
var result = _httpClient.PostAsync($"/api/identidade/Nova-Identidade", ObterConteudo(autenticacao)).Result;
return(await Task.FromResult(result));
}
public async Task <ActionResult> Register(UsuarioRegistro usuarioRegistro)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
var user = new IdentityUser
{
UserName = usuarioRegistro.Email,
Email = usuarioRegistro.Email,
EmailConfirmed = true
};
var result = await _userManager.CreateAsync(user, usuarioRegistro.Senha);
if (result.Succeeded)
{
var clienteResult = await RegistrarCliente(usuarioRegistro);
if (!clienteResult.ValidationResult.IsValid)
{
await _userManager.DeleteAsync(user);
return(CustomResponse(clienteResult.ValidationResult));
}
return(CustomResponse(await GerarJwt(usuarioRegistro.Email)));
}
foreach (var error in result.Errors)
{
AdicionarErroProcessamento(error.Description);
}
return(CustomResponse());
}
public async Task <ActionResult> Registrar(UsuarioRegistro usuarioRegistro)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
var user = new IdentityUser
{
UserName = usuarioRegistro.Email,
Email = usuarioRegistro.Email,
EmailConfirmed = true,
};
var result = await _userManager.CreateAsync(user, usuarioRegistro.Senha);
if (result.Succeeded)
{
//efetua login
//await _signInManager.SignInAsync(user, false);
return(CustomResponse(await GerarJwt(usuarioRegistro.Email)));
}
//caso exista erros será adicionados os erros(descrição) encontrados
foreach (var erro in result.Errors)
{
AdicionarErroProcessamento(erro.Description);
}
return(CustomResponse());
}
public async Task <UsuarioRespostaLogin> Registro(UsuarioRegistro usuarioRegistro)
{
StringContent registroContent = new StringContent(
JsonSerializer.Serialize(usuarioRegistro), Encoding.UTF8,
"application/json"
);
HttpResponseMessage response = await _httpClient
.PostAsync("https://localhost:5001/api/identidade/nova-conta", registroContent);
JsonSerializerOptions options = new JsonSerializerOptions
{
PropertyNameCaseInsensitive = true
};
if (!TratarErrosResponse(response))
{
return(new UsuarioRespostaLogin
{
ResponseResult = JsonSerializer.Deserialize <ResponseResult>(await response.Content.ReadAsStringAsync(), options)
});
}
return(JsonSerializer.Deserialize <UsuarioRespostaLogin>(await response.Content.ReadAsStringAsync(), options));
}
public async Task <ActionResult> Registrar(UsuarioRegistro usuarioRegistro)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
var user = new IdentityUser
{
UserName = usuarioRegistro.Email,
Email = usuarioRegistro.Email,
EmailConfirmed = true
};
var result = await _userManager.CreateAsync(user, usuarioRegistro.Senha);
if (result.Succeeded)
{
//await _signInManager.SignInAsync(user, isPersistent: false);
return(CustomResponse(await GeraJwt(usuarioRegistro.Email)));
}
foreach (var erro in result.Errors)
{
AdicionarErroProcessamento(erro.Description);
}
return(CustomResponse());
}
public async Task <ActionResult> Atualizar(UsuarioRegistro usuario)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
var user = _userManager.FindByEmailAsync(usuario.Email).Result;
if (user == null || !_userManager.IsEmailConfirmedAsync(user).Result)
{
return(CustomResponse(NotFound().StatusCode));
}
user.UserName = usuario.Nome;
var token = await _userManager.GenerateChangeEmailTokenAsync(user, usuario.Nome);
var result = await _userManager.ChangeEmailAsync(user, usuario.Nome, token);
var resultBloqueio = await _userManager.SetLockoutEnabledAsync(user, usuario.Excluido);
if (result.Succeeded && resultBloqueio.Succeeded)
{
return(CustomResponse());
}
foreach (var error in result.Errors)
{
AdicionarErroProcessamento(error.Description);
}
return(CustomResponse());
}
public ActionResult Registrar(UsuarioRegistro registro)
{
// é async
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
// Criar Usuario.
//var result = Metodo();
//if (result.Succeeded)
//{
// return Ok();
//}
//foreach (var erro in AcceptedAtActionResult.Erros)
//{
// AdicionarErroProcessamento(erro.Description);
//}
//return CustomResponse();
return(BadRequest());
}
public async Task <UsuarioRespostaLogin> Registro(UsuarioRegistro registro)
{
var registroContent = PrepararConteudo(registro);
var response =
await _httpClient.PostAsync($"{Api}nova-conta", registroContent);
return(await TratarResponse(response));
}
private IdentityUser IdentityUserFactoryAutentic(UsuarioRegistro usuarioRegistro)
{
return(new IdentityUser
{
Id = Guid.NewGuid().ToString(),
UserName = usuarioRegistro.Email,
Email = usuarioRegistro.Email,
EmailConfirmed = true
});
}
public Boolean existeUsuario(UsuarioRegistro usuReg)
{
bool existe;
FitocracyDBDataContext fitDB = new FitocracyDBDataContext();
var usuBD = from usu in fitDB.Usuarios
where usu.Email == usuReg.email
select usu;
return(existe = usuBD.Any() ? existe = true : existe = false);
}
public async Task <UsuarioRespostaLogin> Registro(UsuarioRegistro usuarioRegistro)
{
var loginContent = SerializarConteudo(usuarioRegistro);
var endpoint = "/identidade/nova-conta";
var resposta = await _httpClient.PostAsync(endpoint, loginContent);
var response = await TratarRequest(resposta);
return(response);
}
public async Task <UsuarioRespostaLogin> Registro(UsuarioRegistro usuarioRegistro)
{
var registroContent = new StringContent(
JsonSerializer.Serialize(usuarioRegistro),
Encoding.UTF8,
"application/json");
var response = await _httpClient.PostAsync("https://localhost:44351/api/v1/identidade/nova-conta", registroContent);
return(JsonSerializer.Deserialize <UsuarioRespostaLogin>(await response.Content.ReadAsStringAsync()));
}
public JsonResult AddStudent(Usuario studentregd)
{
Console.WriteLine("In registerStudent");
UsuarioRegistroRespuesta stdregreply = new UsuarioRegistroRespuesta();
UsuarioRegistro.getInstance().Add(studentregd);
//stdregreply.Name = studentregd.Name;
//stdregreply.Age = studentregd.Age;
//stdregreply.RegistrationNumber = studentregd.RegistrationNumber;
stdregreply.RegistrationStatus = "Successful";
return(Json(stdregreply));
}
public async Task <IdentityResult> Registro(UsuarioRegistro usuarioRegistro)
{
var user = new IdentityUser
{
UserName = usuarioRegistro.Email,
Email = usuarioRegistro.Email,
EmailConfirmed = true
};
var result = await _userManager.CreateAsync(user, usuarioRegistro.Senha);
return(result);
}
public async Task <IActionResult> Registro(UsuarioRegistro usuarioRegistro)
{
if (!ModelState.IsValid)
{
return(View(usuarioRegistro));
}
if (!Email.Validar(usuarioRegistro.Email))
{
NotificarErro("E-mail inválido");
return(View(usuarioRegistro));
}
var user = new IdentityUser
{
UserName = usuarioRegistro.Email,
Email = usuarioRegistro.Email,
EmailConfirmed = true
};
var result = await _userManager.CreateAsync(user, usuarioRegistro.Senha);
if (!result.Succeeded)
{
foreach (var error in result.Errors)
{
NotificarErro(error.Description);
}
return(View(usuarioRegistro));
}
//Criar Pessoa
Pessoa pessoa = new Pessoa();
pessoa.Nome = usuarioRegistro.Nome;
//pessoa.Id = user.Id;
pessoa.Documento = usuarioRegistro.CPF;
pessoa.Idade = 10;
await _pessoaService.Adicionar(pessoa);
if (!OperacaoValida())
{
return(View(usuarioRegistro));
}
return(RedirectToAction("Identidade", "Catalogo"));
}
public async Task <ResponseResult> Atualiza(UsuarioRegistro usuarioRegistro)
{
var usuario = _mapper.Map <UsuarioDTO>(usuarioRegistro);
var userContent = ObterConteudo(usuario);
var response = await _httpClient.PostAsync("api/usuario/atualiza", userContent);
if (!TratarErrosResponse(response))
{
return(await DeserializarObjetoResponse <ResponseResult>(response));
}
return(RetornoOk());
}
public async Task <UsuarioRespostaLogin> Registro(UsuarioRegistro usuarioRegistro)
{
var registroContent = ObterstringContent(usuarioRegistro);
var response = await _httpClient.PostAsync("/api/identidade/novo-usuario", registroContent);
if (!TratarErrosResponse(response))
{
return(new UsuarioRespostaLogin
{
ResponseResult = await DeserializarObjetoResponse <ResponseResult>(response)
});
}
return(await DeserializarObjetoResponse <UsuarioRespostaLogin>(response));
}
public async Task <UsuarioRespostaLogin> Registro(UsuarioRegistro usuarioRegistro)
{
var registroContent = ObterConteudo(usuarioRegistro);
var response = await _httpClient.PostAsync("nova-conta", registroContent);
if (!TratarErrosResponse(response))
{
return(new UsuarioRespostaLogin
{
ResponseResult = await DeserializarObjetoResponse <ResponseResult>(response)
});
}
return(await DeserializarObjetoResponse <UsuarioRespostaLogin>(response));
}
public async Task <IActionResult> Registro(UsuarioRegistro usuarioRegistro)
{
if (!ModelState.IsValid)
{
return(View(usuarioRegistro));
}
var resposta = await _autenticacaoService.Registro(usuarioRegistro);
//if(false) return View(usuarioRegistro);
await RealizarLogin(resposta);
return(RedirectToAction("Index", controllerName: "Home"));
}
public async Task <ActionResult> Registro(UsuarioRegistro usuarioRegistro)
{
if (!ModelState.IsValid)
{
return(View(usuarioRegistro));
}
var resposta = await _autenticacao.Registro(usuarioRegistro);
if (ResponsePossuiErros(resposta.ResponseResult))
{
return(View(usuarioRegistro));
}
await RealizarLogin(resposta);
return(RedirectToAction("Index", "Home"));
}
public async Task <IActionResult> Registrar(UsuarioRegistro usuarioRegistro)
{
usuarioRegistro.nombre = usuarioRegistro.nombre.ToLower();
if (await _repo.ExisteUsuario(usuarioRegistro.nombre))
{
return(BadRequest("Ya existe nombre de Usuario"));
}
var usuario = _mapper.Map <Usuario>(usuarioRegistro);
var crearUsuario = await _repo.Registro(usuario, usuarioRegistro.password);
var usuarioReturn = _mapper.Map <Usuario>(crearUsuario);
return(CreatedAtRoute("obtenerUsuario", new { Controller = "Usuario", id = crearUsuario.Id }, usuarioReturn));
}
private async Task <ResponseMessage> RegistrarCliete(UsuarioRegistro usuarioRegistro)
{
var usuario = await _userManager.FindByEmailAsync(usuarioRegistro.Email);
var usuarioRegistrado = new UsuarioRegistradoIntegrationEvent(Guid.Parse(usuario.Id), usuarioRegistro.Nome, usuarioRegistro.Email, usuarioRegistro.Cpf);
try
{
return(await _bus.RequestAsync <UsuarioRegistradoIntegrationEvent, ResponseMessage>(usuarioRegistrado));
}
catch
{
await _userManager.DeleteAsync(usuario);
throw;
}
}