/// <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);
}
