/// <summary> /// Faz login com usuário de teste e mantem a sessão /// </summary> private SessaoInfo receberSessaoUsuarioTeste() { // Se a sessão já estiver carregada, retorna ela if (_sessaoUsuarioTeste != null) { return(_sessaoUsuarioTeste); } // Faz a autenticacao AutenticarUsuarioResponse respostaAutenticarUsuario = (AutenticarUsuarioResponse) _servicoMensageria.ProcessarMensagem( new AutenticarUsuarioRequest() { CodigoUsuario = _consUsuarioTeste, Senha = _consUsuarioTesteSenha, CodigoSistemaCliente = "teste" }); // Se nao autenticou, dispara erro if (respostaAutenticarUsuario.StatusResposta != MensagemResponseStatusEnum.OK) { throw new Exception(respostaAutenticarUsuario.DescricaoResposta); } // Salva no cache _sessaoUsuarioTeste = respostaAutenticarUsuario.Sessao; // Retorna a sessao return(respostaAutenticarUsuario.Sessao); }
private static void testeInterface() { IServicoMensageria servicoMensageria = Ativador.Get <IServicoMensageria>(); AutenticarUsuarioResponse responseAutenticacao = (AutenticarUsuarioResponse) servicoMensageria.ProcessarMensagem( new AutenticarUsuarioRequest() { CodigoUsuario = "Admin", Senha = "123" }); ReceberArvoreComandosInterfaceResponse respostaArvore = (ReceberArvoreComandosInterfaceResponse) servicoMensageria.ProcessarMensagem( new ReceberArvoreComandosInterfaceRequest() { CodigoSessao = responseAutenticacao.Sessao.CodigoSessao, CodigoGrupoComandoInterface = "default" }); ReceberGrupoComandoInterfaceResponse respostaReceber = (ReceberGrupoComandoInterfaceResponse) servicoMensageria.ProcessarMensagem( new ReceberGrupoComandoInterfaceRequest() { CodigoSessao = responseAutenticacao.Sessao.CodigoSessao, CodigoGrupoComandoInterface = "default" }); }
private static void testeUsuario() { IServicoMensageria servicoMensageria = Ativador.Get <IServicoMensageria>(); AutenticarUsuarioResponse responseAutenticacao = (AutenticarUsuarioResponse) servicoMensageria.ProcessarMensagem( new AutenticarUsuarioRequest() { CodigoUsuario = "Admin", Senha = "123" }); ListarUsuariosResponse respostaListarUsuario = (ListarUsuariosResponse) servicoMensageria.ProcessarMensagem( new ListarUsuariosRequest() { }); //ReceberUsuarioResponse respostaUsuario = // (ReceberUsuarioResponse) // servicoMensageria.ProcessarMensagem( // new ReceberUsuarioRequest() // { // CodigoSessao = responseAutenticacao.Sessao.CodigoSessao, // CodigoUsuario = "Usuario1" // }); //ReceberCustodiaResponse respostaCustodia = // (ReceberCustodiaResponse) // servicoMensageria.ProcessarMensagem( // new ReceberCustodiaRequest() // { // CodigoSessao = responseAutenticacao.Sessao.CodigoSessao, // CodigoCustodia = respostaUsuario.Usuario.Complementos.ReceberItem<ContextoOMSInfo>().CodigoCustodia // }); //InicializarUsuarioResponse respostaInicializar = // (InicializarUsuarioResponse) // servicoMensageria.ProcessarMensagem( // new InicializarUsuarioRequest() // { // CodigoSessao = responseAutenticacao.Sessao.CodigoSessao, // CodigoCBLC = "38157", // SincronizarContaCorrente = true, // SincronizarCustodia = true, // SincronizarContaInvestimento = true, // SincronizarContaMargem = true, // InferirCBLCInvestimento = true, // Usuario = // new UsuarioInfo() // { // CodigoUsuario = "Usuario1", // Email = "Usuario1", // Nome = "Usuario1", // Senha = "123" // } // }); }
private void button1_Click(object sender, EventArgs e) { //AutenticarUsuarioResponse lRes = servicoSeguranca.AutenticarUsuario(new AutenticarUsuarioRequest() //{ // Email = this.txtEmail.Text, // Senha = Criptografia.CalculateMD5Hash(this.txtSenha.Text), // IP = Environment.MachineName, // CodigoSistemaCliente = "GTI" //}); AutenticarUsuarioResponse lRes = servicoSeguranca.AutenticarUsuario(new AutenticarUsuarioRequest() { Email = txtEmail.Text, Senha = Criptografia.CalculateMD5Hash(this.txtSenha.Text), IP = Environment.MachineName // CodigoSistemaCliente = "GTI" }); if (lRes.StatusResposta == Gradual.OMS.Library.MensagemResponseStatusEnum.OK) { MessageBox.Show("Usuário autenticado com sucesso"); this.lblCodigoSessao.Text = lRes.Sessao.CodigoSessao; ReceberSessaoRequest lEntradaSessao = new ReceberSessaoRequest(); lEntradaSessao.CodigoSessao = lRes.Sessao.CodigoSessao; lEntradaSessao.CodigoSessaoARetornar = lRes.Sessao.CodigoSessao; ReceberSessaoResponse lRetornoSessao = servicoSeguranca.ReceberSessao(lEntradaSessao); this.propertyGrid1.SelectedObject = lRetornoSessao.Usuario; } else { MessageBox.Show(lRes.DescricaoResposta); } }
public Guid RetornaIdUsuarioLogado() { string usuarioClaims = _httpContextAccessor.HttpContext.User.FindFirst("Usuario").Value; AutenticarUsuarioResponse usuarioResponse = JsonConvert.DeserializeObject <AutenticarUsuarioResponse>(usuarioClaims); return(usuarioResponse.Id); }
public object Autenticar( [FromBody] AutenticarUsuarioRequest request, [FromServices] SigningConfigurations signingConfigurations, [FromServices] TokenConfigurations tokenConfigurations) { bool credenciaisValidas = false; AutenticarUsuarioResponse response = _serviceUsuario.AutenticarUsuario(request); credenciaisValidas = response != null; if (credenciaisValidas) { // e o que fica dentro do token que vou pegar depois ClaimsIdentity identity = new ClaimsIdentity( new GenericIdentity(response.Id.ToString(), "Id"), new[] { new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString("N")), //new Claim(JwtRegisteredClaimNames.UniqueName, response.Usuario) new Claim("Usuario", JsonConvert.SerializeObject(response)) } ); DateTime dataCriacao = DateTime.Now; DateTime dataExpiracao = dataCriacao + TimeSpan.FromSeconds(tokenConfigurations.Seconds); var handler = new JwtSecurityTokenHandler(); // onde cria o token var securityToken = handler.CreateToken(new SecurityTokenDescriptor { Issuer = tokenConfigurations.Issuer, Audience = tokenConfigurations.Audience, SigningCredentials = signingConfigurations.SigningCredentials, Subject = identity, NotBefore = dataCriacao, Expires = dataExpiracao }); var token = handler.WriteToken(securityToken); // retorno para usuario return(new { authenticated = true, created = dataCriacao.ToString("yyyy-MM-dd HH:mm:ss"), expiration = dataExpiracao.ToString("yyyy-MM-dd HH:mm:ss"), accessToken = token, message = "OK", PrimeiroNome = response.PrimeiroNome }); } else { return(new { authenticated = false, _serviceUsuario.Notifications }); } }
public object Autenticar( [FromBody] AutenticarUsuarioRequest request, [FromServices] SigningConfigurations signingConfigurations, [FromServices] TokenConfigurations tokenConfigurations) { bool credenciaisValidas = false; AutenticarUsuarioResponse response = _serviceUsuario.AutenticarUsuario(request); credenciaisValidas = response != null; if (credenciaisValidas) { //claims onde guarda suas informações dentro do toke, par apoder usar novamente //instancia de um Clain ClaimsIdentity identity = new ClaimsIdentity( //guardando o id do usuario new GenericIdentity(response.Id.ToString(), "Id"), new[] { new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString("N")), //new Claim(JwtRegisteredClaimNames.UniqueName, response.Usuario) //cira um jason com as informações do response new Claim("Usuario", JsonConvert.SerializeObject(response)) } ); //controles de data DateTime dataCriacao = DateTime.Now; DateTime dataExpiracao = dataCriacao + TimeSpan.FromSeconds(tokenConfigurations.Seconds); //ciracao do token passando as inforamções var handler = new JwtSecurityTokenHandler(); var securityToken = handler.CreateToken(new SecurityTokenDescriptor { //definindo configurações para criação do token Issuer = tokenConfigurations.Issuer, Audience = tokenConfigurations.Audience, SigningCredentials = signingConfigurations.SigningCredentials, Subject = identity, NotBefore = dataCriacao, Expires = dataExpiracao }); var token = handler.WriteToken(securityToken); return(new { message = "ok", }); } else { //caso invalida, vai notificar. return(new { authenticated = false, _serviceUsuario.Notifications }); } }
//private IServiceBase _serviceBase; public BaseController(IUnitOfWork unitOfWork, IHttpContextAccessor httpContextAccessor) { _unitOfWork = unitOfWork; string usuarioClaims = httpContextAccessor.HttpContext.User.FindFirst("Usuario").Value; _dadosUsuarioAutenticado = JsonConvert.DeserializeObject <AutenticarUsuarioResponse>(usuarioClaims); }
public SegurancaCliente EfetuarLogin(string pUsuario, string pEmail, string pIP, string pCodigoSistemaCliente, string pSenha) { var lRetorno = new SegurancaCliente(); lRetorno.Criticas = new List <Criticas>(); try { var lResponse = new AutenticarUsuarioResponse(); var lRequest = new AutenticarUsuarioRequest() { Email = pUsuario, Senha = Criptografia.CalculateMD5Hash(pSenha), IP = pIP, CodigoSistemaCliente = pCodigoSistemaCliente }; lResponse = gServicoSeguranca.AutenticarUsuario(lRequest); if (lResponse.StatusResposta != MensagemResponseStatusEnum.OK) { var lCritica = new Criticas(); lCritica.DataEvento = DateTime.Now; lCritica.Descricao = lResponse.DescricaoResposta; lRetorno.Criticas.Add(lCritica); lRetorno.StatusAutenticacaoRequisicao = false; lRetorno.TokenClienteAutenticacao = ""; lRetorno.IdClienteGradual = 0; return(lRetorno); } var lRetornoSessao = gServicoSeguranca.ReceberSessao(new ReceberSessaoRequest() { CodigoSessao = lRetorno.TokenClienteAutenticacao, CodigoSessaoARetornar = lRetorno.TokenClienteAutenticacao }); lRetorno.StatusAutenticacaoRequisicao = true; lRetorno.TokenClienteAutenticacao = lResponse.Sessao.CodigoSessao; lRetorno.ClienteAtributo = ClienteContaServico.ConsultarClienteContaLogin(lResponse.Sessao.CodigoUsuario.DBToInt32()); lRetorno.DataAutenticacao = DateTime.Now; lRetorno.Usuario = pUsuario; lRetorno.IP = pIP; lRetorno.IdClienteGradual = lRetorno.ClienteAtributo.ID; //lRetorno.DataUltimoLogin = lRetornoSessao.Usuario return(lRetorno); } catch (Exception ex) { gLogger.Error(ex); } return(lRetorno); }
public object Auntenticar( [FromBody] AutenticarUsuarioRequest request, [FromServices] SigningConfiguracao signingConfiguracao, [FromServices] TokenConfiguracao tokenConfiguracao) { bool credenciaisValidas = false; AutenticarUsuarioResponse response = _serviceUsuario.AutenticarUsuario(request); credenciaisValidas = response != null; if (credenciaisValidas) { ClaimsIdentity identity = new ClaimsIdentity( new GenericIdentity(response.Id.ToString(), "Id"), new[] { new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString("N")), // captura a resposta "Id e nome" da api coloca em objecto e serializa em um Json para se ler depois de pegar o Token. new Claim("Usuario", JsonConvert.SerializeObject(response)) }); // Controle de data de expiracao do Tken DateTime dataCriacao = DateTime.Now; DateTime dataExpiracao = dataCriacao + TimeSpan.FromSeconds(tokenConfiguracao.Seconds); var handler = new JwtSecurityTokenHandler(); var securityToken = handler.CreateToken(new SecurityTokenDescriptor { Issuer = tokenConfiguracao.Issuer, Audience = tokenConfiguracao.Audience, SigningCredentials = signingConfiguracao.SigningCredentials, Subject = identity, NotBefore = dataCriacao, Expires = dataExpiracao }); var token = handler.WriteToken(securityToken); return(new { authenticated = true, created = dataCriacao.ToString("yyyy-MM-dd HH:mm:ss"), expiration = dataExpiracao.ToString("yyyy-MM-dd HH:mm:ss"), accessToken = token, message = "OK", primeiroNome = response.PrimeiroNome }); } // Credenciais Invalidas else { return(new { authenticated = false, _serviceUsuario.Notifications }); } }
public object Autenticar([FromBody] AutenticarUsuarioRequest request, [FromServices] SigningConfigurations signingConfigurations, [FromServices] TokenConfigurations tokenConfigurations) { bool credenciaisValidas = false; AutenticarUsuarioResponse response = _serviceUsuario.AutenticarUsuario(request); credenciaisValidas = response != null; if (credenciaisValidas) { ClaimsIdentity identity = new ClaimsIdentity(new GenericIdentity(response.Id.ToString(), "Id"), new[] { new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString("N")), //new Claim(JwtRegisteredClaimNames.UniqueName, response.Usuario) new Claim("Usuario", JsonConvert.SerializeObject(response)) } ); DateTime dataCriacao = DateTime.Now; DateTime dataExpiracao = dataCriacao + TimeSpan.FromSeconds(tokenConfigurations.Seconds); var handler = new JwtSecurityTokenHandler(); var securityToken = handler.CreateToken(new SecurityTokenDescriptor { Issuer = tokenConfigurations.Issuer, Audience = tokenConfigurations.Audience, SigningCredentials = signingConfigurations.SigningCredentials, Subject = identity, NotBefore = dataCriacao, Expires = dataExpiracao, }); var token = handler.WriteToken(securityToken); return(new { authenticated = true, //created = dataCriacao.ToString("yyyy-MM-dd HH:mm:ss"), //expiration = dataExpiracao.ToString("yyyy-MM-dd HH:mm:ss"), accessToken = token, message = "OK", Email = response.email, Password = response.email }); } else { return(new { authenticated = false, BadRequestObjectResult = BadRequest("Erro ao autenticar usuário.") }); } }
public object Autenticar([FromBody] AutenticarUsuarioRequest request, [FromServices] SigningConfiguration signingConfigurations, [FromServices] TokenConfigurations tokenConfigurations) { bool credenciaisValidas = false; AutenticarUsuarioResponse response = _usuarioService.AutenticarUsuario(request); credenciaisValidas = response != null; if (credenciaisValidas) { ClaimsIdentity identity = new ClaimsIdentity( new GenericIdentity(response.IdUsuario.ToString(), "Id"), new[] { new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString("N")), new Claim("Usuario", JsonConvert.SerializeObject(response)) // 1º param é o nome que recupera no token. 2º param os valores que serão armazenados no token } ); DateTime dataCriacao = DateTime.Now; DateTime dataExpiracao = dataCriacao + TimeSpan.FromSeconds(tokenConfigurations.Seconds); var handler = new JwtSecurityTokenHandler(); var securityToken = handler.CreateToken(new SecurityTokenDescriptor { Issuer = tokenConfigurations.Issuer, Audience = tokenConfigurations.Audience, SigningCredentials = signingConfigurations.SigningCredentials, Subject = identity, NotBefore = dataCriacao, Expires = dataExpiracao }); var token = handler.WriteToken(securityToken); return(new { authenticated = true, created = dataCriacao.ToString("yyyy-MM-dd HH:mm:ss"), expiration = dataExpiracao.ToString("yyyy-MM-dd HH:mm:ss"), accessToken = token, message = "OK", primeiroNomeDoProprietario = response.PrimeiroNome }); } else { return(new { authenticated = false, request.Notifications }); } }
public MensagemResponseBase ProcessarMensagem(MensagemRequestBase parametros) { Type lTipoParametro = parametros.GetType(); if (lTipoParametro == typeof(AutenticarUsuarioRequest)) { AutenticarUsuarioResponse lResposta = new AutenticarUsuarioResponse(); lResposta.StatusResposta = MensagemResponseStatusEnum.OK; lResposta.Sessao = new SessaoInfo(); lResposta.Sessao.CodigoSessao = Guid.NewGuid().ToString(); return(lResposta); } else if (lTipoParametro == typeof(ValidarItemSegurancaRequest)) { ValidarItemSegurancaResponse lResposta = new ValidarItemSegurancaResponse(); lResposta.StatusResposta = MensagemResponseStatusEnum.OK; lResposta.ItensSeguranca = ((ValidarItemSegurancaRequest)parametros).ItensSeguranca; foreach (ItemSegurancaInfo lItem in lResposta.ItensSeguranca) { lItem.Valido = true; } return(lResposta); } else if (lTipoParametro == typeof(ListarUsuariosRequest)) { ListarUsuariosResponse lResposta = new ListarUsuariosResponse(); lResposta.Usuarios = new List <UsuarioInfo>(); lResposta.Usuarios.Add(new UsuarioInfo() { Nome = "Teste", Email = "*****@*****.**", CodigoUsuario = "1" }); return(lResposta); } else { throw new NotImplementedException(string.Format("Mock não implementado para [{0}]", lTipoParametro)); } }
public async Task <IActionResult> Listar() { try { string usuarioClaims = _httpContextAccessor.HttpContext.User.FindFirst("usuario").Value; AutenticarUsuarioResponse usuarioResponse = JsonConvert.DeserializeObject <AutenticarUsuarioResponse>(usuarioClaims); var response = _serviceCanal.Listar(usuarioResponse.Id); return(await ResponseAsync(response, _serviceCanal)); } catch (Exception ex) { return(await ResponseExceptionAsync(ex)); } }
public override async Task GrantResourceOwnerCredentials(OAuthGrantResourceOwnerCredentialsContext context) { try { IServiceUsuario serviceUsuario = _container.Resolve <IServiceUsuario>(); AutenticarUsuarioRequest request = new AutenticarUsuarioRequest(); request.Email = context.UserName; request.Senha = context.Password; AutenticarUsuarioResponse response = serviceUsuario.AutenticarUsuario(request); if (serviceUsuario.IsInvalid()) { if (response == null) { context.SetError("invalid_grant", "Preencha um e-mail válido e uma senha com pelo menos 6 caracteres."); return; } } serviceUsuario.ClearNotifications(); if (response == null) { context.SetError("invalid_grant", "Usuario não encontrado!"); return; } var identity = new ClaimsIdentity(context.Options.AuthenticationType); //Definindo as Claims identity.AddClaim(new Claim("Usuario", JsonConvert.SerializeObject(response))); var principal = new GenericPrincipal(identity, new string[] { }); Thread.CurrentPrincipal = principal; context.Validated(identity); } catch (Exception ex) { context.SetError("invalid_grant", ex.Message); return; } }
public async Task <IActionResult> Adicionar([FromBody] AdicionarPlayListRequest request) { try { string usuarioClaims = _httpContextAccessor.HttpContext.User.FindFirst("usuario").Value; AutenticarUsuarioResponse usuarioResponse = JsonConvert.DeserializeObject <AutenticarUsuarioResponse>(usuarioClaims); var response = _servicePlayList.AdicionarPlayList(request, usuarioResponse.Id); return(await ResponseAsync(response, _servicePlayList)); } catch (Exception ex) { return(await ResponseExceptionAsync(ex)); } }
public async Task <IActionResult> Excluir(Guid idTarefa) { try { string usuarioclaims = _httpContextAccessor.HttpContext.User.FindFirst("Usuario").Value; AutenticarUsuarioResponse usuarioResponse = JsonConvert.DeserializeObject <AutenticarUsuarioResponse>(usuarioclaims); var response = _serviceTarefa.ExcluirTarefa(idTarefa); return(await ResponseAsync(response, _serviceTarefa)); } catch (Exception ex) { return(await ResponseExceptionAsync(ex)); } }
public async Task <IActionResult> ListarSolicitacao(int status) { try { string usuarioClaims = _httpContextAccessor.HttpContext.User.FindFirst("Usuario").Value; AutenticarUsuarioResponse usuarioResponse = JsonConvert.DeserializeObject <AutenticarUsuarioResponse>(usuarioClaims); var response = _serviceSolicitacao.ListarSolicitacaoFornecedor(usuarioResponse.Id, status); return(await ResponseAsync(response, _serviceSolicitacao)); } catch (System.Exception ex) { return(await ResponseExceptionAsync(ex)); } }
public async Task <IActionResult> AlterarGrupo([FromBody] AlterarStatusSolicitacaoRequest request) { try { string usuarioClaims = _httpContextAccessor.HttpContext.User.FindFirst("Usuario").Value; AutenticarUsuarioResponse usuarioResponse = JsonConvert.DeserializeObject <AutenticarUsuarioResponse>(usuarioClaims); var response = _serviceSolicitacao.AlterarStatus(request, usuarioResponse.Id); return(await ResponseAsync(response, _serviceSolicitacao)); } catch (System.Exception ex) { return(BadRequest(ex.Message)); } }
public async Task <IActionResult> Obter(Guid idUsuario) { try { string usuarioClaims = _httpContextAccessor.HttpContext.User.FindFirst("Usuario").Value; AutenticarUsuarioResponse usuarioResponse = JsonConvert.DeserializeObject <AutenticarUsuarioResponse>(usuarioClaims); UsuarioResponse response = _serviceUsuario.Obter(idUsuario); return(await ResponseAsync(response, _serviceUsuario)); } catch (Exception ex) { return(await ResponseExceptionAsync(ex)); } }
public async Task <IActionResult> AdicionarMesa([FromBody] RealizarPedidoRequest request, string FkMesa) { try { string usuarioClaims = _httpContextAccessor.HttpContext.User.FindFirst("Usuario").Value; AutenticarUsuarioResponse usuarioResponse = JsonConvert.DeserializeObject <AutenticarUsuarioResponse>(usuarioClaims); request.FkUsuario = usuarioResponse.Id; request.FkMesa = Guid.Parse(FkMesa); var response = await _mediator.Send(request, CancellationToken.None); return(await ResponseAsync(response)); } catch (System.Exception ex) { return(BadRequest(ex.Message)); } }
public object Autenticar([FromBody] AutenticarUsuarioRequest request, [FromServices] TokenConfigurations tokenConfigurations, [FromServices] SigningConfigurations signingConfigurations) { AutenticarUsuarioResponse response = (AutenticarUsuarioResponse)_serviceUsuario.Autenticar(request); if (!(response is null)) { DateTime dataCriacao = DateTime.Now; DateTime dataExpiracao = dataCriacao + TimeSpan.FromSeconds(tokenConfigurations.Seconds); ClaimsIdentity identity = new ClaimsIdentity( new GenericIdentity(response.Id.ToString(), "Id"), new[] { new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString("N")), new Claim("Usuario", JsonConvert.SerializeObject(response)) } ); var handler = new JwtSecurityTokenHandler(); var securityToken = handler.CreateToken(new SecurityTokenDescriptor { Issuer = tokenConfigurations.Issuer, Audience = tokenConfigurations.Audience, SigningCredentials = signingConfigurations.SigningCredentials, Subject = identity, NotBefore = dataCriacao, Expires = dataExpiracao }); var token = handler.WriteToken(securityToken); _httpContextAcessor.HttpContext.User.AddIdentity(identity); return(new { authenticated = true, created = dataCriacao.ToString("yyyy-MM-dd HH:mm:ss"), expiration = dataExpiracao.ToString("yyyy-MM-dd HH:mm:ss"), accessToken = token, message = "OK", response.Email }); }
public async Task <IActionResult> AlterarGrupo([FromBody] AlterGroupRequest request) { try { string usuarioClaims = _httpContextAccessor.HttpContext.User.FindFirst("Usuario").Value; AutenticarUsuarioResponse usuarioResponse = JsonConvert.DeserializeObject <AutenticarUsuarioResponse>(usuarioClaims); request.IdUser = usuarioResponse.Id; var response = await _mediator.Send(request, CancellationToken.None); return(await ResponseAsync(response)); } catch (System.Exception ex) { return(BadRequest(ex.Message)); } }
public async Task <IActionResult> Adicionar([FromBody] AdicionarCanalRequest request) { try { // String capturada do claim feita no usuario contoller que tem os dados da requisicao. string usuarioClaims = _httpContextAccessor.HttpContext.User.FindFirst("Usuario").Value; AutenticarUsuarioResponse usuarioResponse = JsonConvert.DeserializeObject <AutenticarUsuarioResponse>(usuarioClaims); // Esse autenticaar converte o objeto serializado em um Json podendo usar o nome e id do usuario. var response = _serviceCanal.AdicionarCanal(request, usuarioResponse.Id); return(await ResponseAsync(response, _serviceCanal)); } catch (Exception ex) { return(ResponseException(ex)); } }
private object GerarToken(AutenticarUsuarioResponse response, SigningConfigurations signingConfigurations, TokenConfigurations tokenConfigurations) { if (response.Autenticado == true) { ClaimsIdentity identity = new ClaimsIdentity( new GenericIdentity(response.Id.ToString(), "Id"), new[] { new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString("N")), //new Claim(JwtRegisteredClaimNames.UniqueName, response.Usuario) new Claim("Usuario", JsonConvert.SerializeObject(response)) } ); DateTime dataCriacao = DateTime.Now; DateTime dataExpiracao = dataCriacao + TimeSpan.FromSeconds(tokenConfigurations.Seconds); var handler = new JwtSecurityTokenHandler(); var securityToken = handler.CreateToken(new SecurityTokenDescriptor { Issuer = tokenConfigurations.Issuer, Audience = tokenConfigurations.Audience, SigningCredentials = signingConfigurations.SigningCredentials, Subject = identity, NotBefore = dataCriacao, Expires = dataExpiracao }); var token = handler.WriteToken(securityToken); return(new { authenticated = true, created = dataCriacao.ToString("yyyy-MM-dd HH:mm:ss"), expiration = dataExpiracao.ToString("yyyy-MM-dd HH:mm:ss"), accessToken = token, message = "OK", PrimeiroNome = response.Name }); } else { return(response); } }
public async Task <IActionResult> Adicionar([FromBody] AdicionarVideoRequest request) { try { // String capturada do claim feita no usuario controller que tem os dados da requisicao. string usuarioClaims = _httpContextAccessor.HttpContext.User.FindFirst("Usuario").Value; AutenticarUsuarioResponse usuarioResponse = JsonConvert.DeserializeObject <AutenticarUsuarioResponse>(usuarioClaims); // Esse autenticaar converte o objeto serializado em um Json podendo usar o nome e id do usuario. // variavel para adicionar os campos em uma response var response = _serviceVideo.AdicionarVideo(request, usuarioResponse.Id); // entao retorna as respostas para o end point da api return(await ResponseAsync(response, _serviceVideo)); } catch (Exception ex) { return(ResponseException(ex)); } }
private static void testeOrdens2() { IServicoMensageria servicoMensageria = Ativador.Get <IServicoMensageria>(); AutenticarUsuarioResponse responseAutenticacao = (AutenticarUsuarioResponse) servicoMensageria.ProcessarMensagem( new AutenticarUsuarioRequest() { CodigoUsuario = "Admin", Senha = "123" }); ListarOrdensResponse respostaListarOrdens = (ListarOrdensResponse) servicoMensageria.ProcessarMensagem( new ListarOrdensRequest() { CodigoSessao = responseAutenticacao.Sessao.CodigoSessao }); }
private static void testes() { IServicoMensageria servicoMensageria = Ativador.Get <IServicoMensageria>(); AutenticarUsuarioResponse responseAutenticacao = (AutenticarUsuarioResponse) servicoMensageria.ProcessarMensagem( new AutenticarUsuarioRequest() { CodigoUsuario = "Admin", Senha = "123" }); CallbackEvento callbackEvento = new CallbackEvento(); callbackEvento.Evento += new EventHandler <EventoEventArgs>(callbackEvento_Evento); callbackEvento.Evento2 += new EventHandler <EventArgs>(callbackEvento_Evento2); IServicoMensageriaComCallback servicoMensageriaComCallback = Ativador.Get <IServicoMensageriaComCallback>( callbackEvento, responseAutenticacao.Sessao); servicoMensageriaComCallback.AssinarEvento( new AssinarEventoRequest() { CodigoSessao = responseAutenticacao.Sessao.CodigoSessao, TipoServico = typeof(IServicoEcho).FullName + ", " + typeof(IServicoEcho).Assembly.FullName, NomeEvento = "EventoEcho" }); ExecutarEchoResponse responseEcho = (ExecutarEchoResponse) servicoMensageria.ProcessarMensagem( new ExecutarEchoRequest() { TipoFuncao = ExecutarEchoTipoFuncaoEnum.EcoarMensagem, Mensagem = "teste" }); }
/// <summary> /// Método para gerar o token do usuário. /// </summary> /// <param name="response">Os dados do usuário.</param> /// <returns></returns> public Token GenerateToken(AutenticarUsuarioResponse response) { ClaimsIdentity identity = new ClaimsIdentity( new GenericIdentity(response.PrimeiroNome, "Id"), new[] { new Claim(JwtRegisteredClaimNames.Jti, response.Id.ToString("N")), new Claim("Usuario", JsonConvert.SerializeObject(response)) } ); DateTime dataCriacao = DateTime.Now; DateTime dataExpiracao = dataCriacao + TimeSpan.FromSeconds(_tokenConfigurations.Seconds); var securityKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_tokenConfigurations.Key)); var credentials = new SigningCredentials(securityKey, SecurityAlgorithms.HmacSha256Signature); var handler = new JwtSecurityTokenHandler(); var securityToken = handler.CreateToken(new SecurityTokenDescriptor { Issuer = _tokenConfigurations.Issuer, Audience = _tokenConfigurations.Audience, SigningCredentials = credentials, Subject = identity, NotBefore = dataCriacao, Expires = dataExpiracao }); var token = handler.WriteToken(securityToken); return(new Token() { Authenticated = true, Created = dataCriacao.ToString("yyyy-MM-dd HH:mm:ss"), Expiration = dataExpiracao.ToString("yyyy-MM-dd HH:mm:ss"), AccessToken = token, Message = "OK", PrimeiroNome = response.PrimeiroNome }); }
private void AtualizarUsuarioLogado() { _usuarioLogado = JsonConvert.DeserializeObject <AutenticarUsuarioResponse>(_httpContextAccessor.HttpContext.User.FindFirst("Usuario").Value); }