public async Task <ActionResult> Registrar(UsuarioRegistroViewModel usuarioRegistroViewModel)
{
return(StatusCode(401));
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
var user = new IdentityUser
{
UserName = usuarioRegistroViewModel.Email,
Email = usuarioRegistroViewModel.Email,
EmailConfirmed = true,
};
var result = await _userManager.CreateAsync(user, usuarioRegistroViewModel.Senha);
if (result.Succeeded)
{
return(CustomResponse(await GerarJwt(usuarioRegistroViewModel.Email)));
}
foreach (var error in result.Errors)
{
AdicionarErroProcessamento(error.Description);
}
return(CustomResponse());
}
public async Task <bool> AddUsuario(UsuarioRegistroViewModel usuarioRC)
{
UsuarioSet usuario = new UsuarioSet {
Id = usuarioRC.Id,
Nombre = usuarioRC.Nombre,
Apellido = usuarioRC.Apellido,
Documento_Tipo_Documento = usuarioRC.Documento_Tipo_Documento,
Documento_Nro_Documento = usuarioRC.Documento_Nro_Documento,
Telefono = usuarioRC.Telefono,
Estado = "A",
Datos_Adicionales = "Ninguno",
Fecha_Registro = DateTime.Now
};
db.Usuarios.Add(usuario);
try
{
db.Commit();
return(true);
}
catch (Exception)
{
return(false);
}
}
private void Click_GridOrganizador_Tapped(object sender, EventArgs e)
{
var usuario = new UsuarioRegistroViewModel()
{
PrincipalLoja = true
};
App.Nav.Navigation.PushAsync(new Registro_Page(usuario));
}
public async Task <ActionResult> ExternalLoginConfirmation(ExternalLoginConfirmationViewModel model, string returnUrl)
{
if (User.Identity.IsAuthenticated)
{
return(RedirectToAction("Index", "Manage"));
}
if (ModelState.IsValid)
{
// Obtener datos del usuario del proveedor de inicio de sesión externo
var info = await AuthenticationManager.GetExternalLoginInfoAsync();
if (info == null)
{
return(View("ExternalLoginFailure"));
}
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email
};
var usuarioRC = new UsuarioRegistroViewModel
{
Id = user.Id,
Nombre = model.Nombre,
Apellido = model.Apellido,
Telefono = model.Telefono,
Documento_Tipo_Documento = model.TipoDocumento,
Documento_Nro_Documento = model.NroDocumento,
};
var result = await UserManager.CreateAsync(user);
var result2 = await reservasConsultas.AddUsuario(usuarioRC);
if (result.Succeeded && result2)
{
result = await UserManager.AddLoginAsync(user.Id, info.Login);
//registro de datos adicionales
if (result.Succeeded)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
return(RedirectToLocal(returnUrl));
}
}
AddErrors(result);
}
ViewBag.ReturnUrl = returnUrl;
return(View(model));
}
public async Task <UsuarioRespostaLogin> Registro(UsuarioRegistroViewModel parametros)
{
var response = await _httpClient.PostAsync("/api/identidade/nova-conta", ObterConteudo(parametros));
if (!TratarErrosResponse(response))
{
return(new UsuarioRespostaLogin
{
ResponseResult = await DeserializarObjetoResponse <ResponseResult>(response)
});
}
return(await DeserializarObjetoResponse <UsuarioRespostaLogin>(response));
}
public async Task <UsuarioAutenticacaoResponse> Registrar(UsuarioRegistroViewModel usuario)
{
var usuarioContent = ObterConteudo(usuario);
var response = await httpClient.PostAsync("/api/identidade/nova-conta", usuarioContent);
if (!TratarErrosResponse(response))
{
return(new UsuarioAutenticacaoResponse
{
ResponseResult = await DeserializarObjetoResponse <ResponseResult>(response)
});
}
return(await DeserializarObjetoResponse <UsuarioAutenticacaoResponse>(response));
}
public async Task <UsuarioRespostaLoginViewModel> Registro(UsuarioRegistroViewModel usuarioRegistro)
{
var registroContent = ObterConteudo(usuarioRegistro);
var response = await _httpClient.PostAsync(requestUri : "https://localhost:44346/api/identidade/nova-conta", registroContent);
if (!TratarErrosResponse(response))
{
return(new UsuarioRespostaLoginViewModel
{
ResponseResult = await DeserializarObjetoResponse <ResponseResult>(response),
});
}
return(await DeserializarObjetoResponse <UsuarioRespostaLoginViewModel>(response));
}
public async Task <IActionResult> Registro(UsuarioRegistroViewModel parametros)
{
if (!ModelState.IsValid)
{
return(View(parametros));
}
var resposta = await _autenticacaoService.Registro(parametros);
if (ResponsePossuiErros(resposta.ResponseResult))
{
return(View(parametros));
}
await _autenticacaoService.RealizarLogin(resposta);
return(RedirectToAction("Index", "Catalogo"));
}
private async Task <ResponseMessage> RegistrarCliente(UsuarioRegistroViewModel usuarioRegistro)
{
var usuario = await _authenticationService.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 _authenticationService.UserManager.DeleteAsync(usuario);
throw;
}
}
public async Task <IActionResult> Registro(UsuarioRegistroViewModel usuarioRegistro)
{
if (!ModelState.IsValid)
{
return(View(usuarioRegistro));
}
var resposta = await _autenticacaoService.Registro(usuarioRegistro);
if (ResponsePossuiErros(resposta.ResponseResult))
{
return(View(usuarioRegistro));
}
await RealizarLogin(resposta);
return(RedirectToAction("Index", controllerName: "Home"));
}
public static async Task <bool> PostRegistroUsuario(UsuarioRegistroViewModel usuarioRegistroViewModel)
{
HttpClient client = new HttpClient();
string uri = Constantes.WS_REGISTRO;
StringContent content = new StringContent(JsonConvert.SerializeObject(usuarioRegistroViewModel), Encoding.UTF8, "application/json");
var result = await client.PostAsync(uri, content);
string resultString = await result.Content.ReadAsStringAsync();
if (result.IsSuccessStatusCode)
{
return(true);
}
else
{
return(false);
}
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email
};
var usuarioRC = new UsuarioRegistroViewModel
{
Id = user.Id,
Nombre = model.Nombre,
Apellido = model.Apellido,
Telefono = model.Telefono,
Documento_Tipo_Documento = model.TipoDocumento,
Documento_Nro_Documento = model.NroDocumento,
};
var result = await UserManager.CreateAsync(user, model.Password);
var result2 = await reservasConsultas.AddUsuario(usuarioRC);
if (result.Succeeded && result2)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
// Para obtener más información sobre cómo habilitar la confirmación de cuenta y el restablecimiento de contraseña, visite http://go.microsoft.com/fwlink/?LinkID=320771
// Enviar correo electrónico con este vínculo
string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
await UserManager.SendEmailAsync(user.Id, "Confirmar cuenta", "Para confirmar la cuenta, haga clic <a href=\"" + callbackUrl + "\">aquí</a>");
return(RedirectToAction("Index", "Home"));
}
AddErrors(result);
}
// Si llegamos a este punto, es que se ha producido un error y volvemos a mostrar el formulario
return(View(model));
}
protected override void Seed(ReservaDeCanchas.Models.ApplicationDbContext context)
{
var userManager =
new ApplicationUserManager(new UserStore <ApplicationUser>(context));
var roleManager =
new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(context));
// Crear Roles
roleManager.Create(new IdentityRole("Admin"));
var user = new ApplicationUser()
{
UserName = "******",
Email = "*****@*****.**",
};
userManager.Create(user, "123qQ!");
userManager.AddToRole(user.Id, "Admin");
var cliente = new ApplicationUser()
{
UserName = "******",
Email = "*****@*****.**"
};
userManager.Create(cliente, "123qQ!");
var cliente2 = new UsuarioRegistroViewModel
{
Id = cliente.Id,
Nombre = "Prueba",
Apellido = "test",
Telefono = "234234",
Documento_Tipo_Documento = "DNI",
Documento_Nro_Documento = "12345678"
};
var crear = reservasConsultas.AddUsuario(cliente2);
}
public ActionResult RegistrarUsuario(UsuarioRegistroViewModel usuarioRegistro)
{
if (ModelState.IsValid)
{
Usuario usuario = new Usuario()
{
Login = usuarioRegistro.Login,
Email = usuarioRegistro.Email,
Senha = usuarioRegistro.Senha
};
//verifica se o login ou o e-mail já existe no banco de dados
UsuarioRepositorio repositorio = new UsuarioRepositorio();
try
{
if (repositorio.ExisteLoginOuEmailJaCadastrados(usuario))
{
ViewBag.Mensagem = "O login ou e-mail já foram cadastrados. Favor escolhar outro.";
}
else
{
//Não existindo, poderá ser cadastrado no banco de dados.
usuario = repositorio.Inserir(usuario);
ModelState.Clear();
ViewBag.MensagemCadastro = "Conta Criada com Sucesso: " + usuario.ToString();
return(View("Registro"));
}
}
catch (Exception e)
{
ViewBag.Mensagem = "Ocorreu um erro ao criar nova conta: " + e.Message;
return(View("Registro"));
}
}
return(View("Registro"));
}
public async Task <ActionResult> Registrar(UsuarioRegistroViewModel usuarioRegistro)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
var user = new IdentityUser
{
UserName = usuarioRegistro.Email,
Email = usuarioRegistro.Email,
EmailConfirmed = true
};
var result = await _authenticationService.UserManager.CreateAsync(user, usuarioRegistro.Senha);
if (result.Succeeded)
{
var clienteResult = await RegistrarCliente(usuarioRegistro);
if (!clienteResult.ValidationResult.IsValid)
{
await _authenticationService.UserManager.DeleteAsync(user);
return(CustomResponse(clienteResult.ValidationResult));
}
return(CustomResponse(await _authenticationService.GerarJwt(usuarioRegistro.Email)));
}
foreach (var error in result.Errors)
{
AdicionarErroProcessamento(error.Description);
}
return(CustomResponse());
}
public Registro_Page(UsuarioRegistroViewModel usuarioRegistroViewModel)
{
this._usuarioRegistroViewModel = usuarioRegistroViewModel;
#region Layout
l_email = new Label()
{
Text = "E-mail", HorizontalOptions = LayoutOptions.Start
};
l_senha = new Label()
{
Text = "Senha", HorizontalOptions = LayoutOptions.Start
};
l_confirmacaoSenha = new Label()
{
Text = "Confirmação da Senha", HorizontalOptions = LayoutOptions.Start
};
l_nome = new Label()
{
Text = "Nome", HorizontalOptions = LayoutOptions.Start
};
l_sobrenome = new Label()
{
Text = "Sobrenome", HorizontalOptions = LayoutOptions.Start
};
l_razaosocial = new Label()
{
Text = "Razão Social", HorizontalOptions = LayoutOptions.Start
};
l_telefone1 = new Label()
{
Text = "Telefone Principal", HorizontalOptions = LayoutOptions.Start
};
l_telefone2 = new Label()
{
Text = "Telefone Opcional ", HorizontalOptions = LayoutOptions.Start
};
l_documento = new Label()
{
Text = "Documento(CPF ou CNPJ)", HorizontalOptions = LayoutOptions.Start
};
e_email = new Entry()
{
Keyboard = Keyboard.Email
};
e_senha = new Entry()
{
IsPassword = true
};
e_confirmacaoSenha = new Entry()
{
IsPassword = true
};
e_nome = new Entry();;
e_sobrenome = new Entry();
e_razaosocial = new Entry();
e_telefone1 = new Entry()
{
Keyboard = Keyboard.Telephone
};
e_telefone2 = new Entry()
{
Keyboard = Keyboard.Telephone
};
e_documento = new Entry()
{
};
b_registrar = new Button()
{
Text = "Registrar", VerticalOptions = LayoutOptions.End, HorizontalOptions = LayoutOptions.End
};
#endregion
b_registrar.Clicked += B_registrar_Clicked;
sl_principal = new StackLayout()
{
Padding = Util.Constantes.PADDINGDEFAULT,
Children =
{
l_email
, e_email
, l_senha
, e_senha
, l_confirmacaoSenha
, e_confirmacaoSenha
, l_nome
, e_nome
, l_sobrenome
, e_sobrenome
, l_razaosocial
, e_razaosocial
, l_telefone1
, e_telefone1
, l_telefone2
, e_telefone2
, l_documento
, e_documento
, b_registrar
}
};
this.Content = sl_principal;
}
