public override async Task GrantRefreshToken(OAuthGrantRefreshTokenContext context)
{
try
{
var userManager = context.OwinContext.GetUserManager <ApplicationUserManager>();
using (var usuarioBO = new APIUsuarioBO())
{
APIUsuario usuario = usuarioBO.Consultar(context.Ticket.Properties.Dictionary["userName"]);
if (usuario == null)
{
NewRelic.Api.Agent.NewRelic.IgnoreTransaction();
context.SetError("Mensagem", "Usuário ou senha incorretos");
return;
}
context.Options.AccessTokenExpireTimeSpan = TimeSpan.FromHours(usuario.HorasExpiracaoToken);
ClaimsIdentity oAuthIdentity = await usuarioBO.CriarIdentityAsync(usuario, userManager.UserTokenProvider);
AuthenticationTicket ticket = new AuthenticationTicket(oAuthIdentity, CreateProperties(usuario));
context.Validated(ticket);
}
}
catch (Exception ex)
{
LogUtil.Error(ex);
}
}
public override Task <HttpResponseMessage> ExecuteAsync(HttpControllerContext controllerContext, CancellationToken cancellationToken)
{
try
{
//LogUtil.Debug(string.Format("##Master.ExecuteAsync## SESSION {0}", (this.SessionModel != null) ? this.SessionModel.SessionID : "NA"));
var retorno = base.ExecuteAsync(controllerContext, cancellationToken);
// TODO: O token é atualizado somente em caso de retorno OK dos métodos HTTP. Então, se pesquisarmos um evento, e o mesmo
// não existir, e o token ainda não foi salvo em banco, o token terá um valor nulo.
// Lembrando que todos os métodos HTTP retornam um HttpException em caso de anomalia.
if ((APIUsuarioToken != null) && (retorno.Result.StatusCode == HttpStatusCode.OK))
{
try
{
var dadosSerializados = JsonConvert.SerializeObject(SessionModel.CopyTo(new DadosSessionModel()));
LogUtil.Debug(string.Format("##Master.ExecuteAsync## SESSION_DATA {0}", dadosSerializados));
if ((!APIUsuarioToken.DadosSession.Equals(dadosSerializados)) || (AtualizarToken))
{
LogUtil.Debug(string.Format("##Master.ExecuteAsync.AtualizarSessionData## SESSION_DATA {0}", dadosSerializados));
APIUsuarioToken.DadosSession = dadosSerializados;
APIUsuarioToken.ClienteID = SessionModel.ClienteID;
using (var usuarioBO = new APIUsuarioBO())
{
usuarioBO.AtualizarSessao(APIUsuarioToken, AtualizarToken);
}
}
}
catch (Exception ex)
{
LogUtil.Error(string.Format("##Master.ExecuteAsync.EXCEPTION## SESSION {0}, MSG {1}", (this.SessionModel != null) ? this.SessionModel.SessionID : "NA", ex.Message), ex);
retorno.Result.StatusCode = HttpStatusCode.InternalServerError;
//LogUtil.Error(ex);
}
}
return(retorno);
}
catch (Exception ex)
{
LogUtil.Error(string.Format("##Master.ExecuteAsync.EXCEPTION## SESSION {0}, MSG {1}", (this.SessionModel != null) ? this.SessionModel.SessionID : "NA", ex.Message), ex);
//LogUtil.Error(ex);
throw ex;
}
}
/// <summary>
/// Realiza o processo de refresh do token.
/// </summary>
/// <param name="context">Contexto da aplicação.</param>
public void Receive(AuthenticationTokenReceiveContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
using (var usuario = new APIUsuarioBO())
{
// Define o client info baseado nos headers do contexto.
var clientInfo = string.Empty;
if (context.Request != null && context.Request.Headers != null)
{
clientInfo = !string.IsNullOrEmpty(context.Request.Headers["ClientInfo"]) ? context.Request.Headers["ClientInfo"] : string.Empty;
}
// Consulta o token do usuário, caso o token seja diferente de nulo e o client info não bata com os dados de identificação do token, retorna.
var token = usuario.ConsultarToken(context.Token);
if (token != null && !clientInfo.Equals(token.DadosIndentificacao, StringComparison.InvariantCultureIgnoreCase))
{
return;
}
// Se o token continua nulo, consulta o token utilizando o client info, que contém o nome do usuário.
if (token == null)
{
token = usuario.ConsultarToken(clientInfo, null);
}
else if (clientInfo.Equals(token.DadosIndentificacao, StringComparison.InvariantCultureIgnoreCase))
{
token.Token = null;
}
// Se o objeto token continua null, gera exception, loga e retorna.
if (token == null)
{
//throw new NullReferenceException("Objeto Token é nulo após tentativa de recuperação.");
LogUtil.Debug(string.Format("##RefreshToken.Receive.ERROR## MSG: {0}, CLIENT_INFO {1}, TOKEN {2}", "Objeto Token é nulo após tentativa de recuperação.", clientInfo, context.Token));
return;
}
if (!string.IsNullOrEmpty(token.Token))
{
return;
}
// Se o token não é nulo, atualiza o token no storage e no contexto, e redefine o ticket.
// O processo é o mesmo de criação do token, o token não será gravado em banco neste momento, a variável AtualizarToken da API controller gerencia esse processo na
// próxima requisição.
token.DataExpiracao = DateTime.Now.Add(TimeSpan.FromHours(token.APIUsuario.HorasExpiracaoToken));
usuario.Salvar(token);
var userManager = context.OwinContext.GetUserManager <ApplicationUserManager>();
var oAuthIdentity = usuario.CriarIdentity(token.APIUsuario, userManager.UserTokenProvider);
var ticket = new AuthenticationTicket(oAuthIdentity, ApplicationOAuthProvider.CreateProperties(token.APIUsuario));
ticket.Properties.ExpiresUtc = token.DataExpiracao;
ticket.Properties.IssuedUtc = DateTime.Now;
context.SetTicket(ticket);
}
}
public override async Task GrantResourceOwnerCredentials(OAuthGrantResourceOwnerCredentialsContext context)
{
try
{
var userManager = context.OwinContext.GetUserManager <ApplicationUserManager>();
using (var usuarioBO = new APIUsuarioBO())
{
APIUsuario usuario = usuarioBO.Consultar(context.UserName);
if (usuario == null)
{
NewRelic.Api.Agent.NewRelic.IgnoreTransaction();
context.SetError("Mensagem", "Usuário ou senha incorretos");
return;
}
if (!usuario.Ativo)
{
NewRelic.Api.Agent.NewRelic.IgnoreTransaction();
context.SetError("Mensagem", "Usuário está inativo");
return;
}
switch (usuario.TipoAcessoAsEnum)
{
case enumAPITipoAcesso.webClient:
if (string.IsNullOrEmpty(usuario.DominiosOrigem))
{
NewRelic.Api.Agent.NewRelic.IgnoreTransaction();
context.SetError("Mensagem", "Usuário mal cadastrado");
return;
}
if (usuario.DominiosOrigem != "*")
{
var dominios = usuario.DominiosOrigem.Split(',').Select(t => t.Trim());
if (!dominios.Contains(HttpContext.Current.Request.GetClientReferer()))
{
NewRelic.Api.Agent.NewRelic.IgnoreTransaction();
context.SetError("Mensagem", "O Domínio " + HttpContext.Current.Request.GetClientReferer() + " não permitido para o acesso a API com este usuário");
return;
}
}
if (usuario.Senha != context.Password)
{
NewRelic.Api.Agent.NewRelic.IgnoreTransaction();
context.SetError("Mensagem", "Usuário ou senha incorretos");
return;
}
break;
case enumAPITipoAcesso.webServer:
if (string.IsNullOrEmpty(usuario.IPOrigem))
{
NewRelic.Api.Agent.NewRelic.IgnoreTransaction();
context.SetError("Mensagem", "Usuário mal cadastrado");
return;
}
if (usuario.IPOrigem != "*")
{
// TODO: Tem algum problema, deve ser checado
var ips = usuario.IPOrigem.Split(',').Select(t => t.Trim());
if (!ips.Any(t => HttpContext.Current.Request.GetClientIPAddress().Contains(t)))
{
NewRelic.Api.Agent.NewRelic.IgnoreTransaction();
context.SetError("Mensagem", "Os IPs " + string.Join(", ", HttpContext.Current.Request.GetClientIPAddress().ToArray()) + " não são permitidos para acesso a API com este usuário");
return;
}
}
if (userManager.PasswordHasher.VerifyHashedPassword(usuario.Senha, context.Password) == PasswordVerificationResult.Failed)
{
NewRelic.Api.Agent.NewRelic.IgnoreTransaction();
context.SetError("Mensagem", "Usuário ou senha incorretos");
return;
}
break;
case enumAPITipoAcesso.app:
if (userManager.PasswordHasher.VerifyHashedPassword(usuario.Senha, context.Password) == PasswordVerificationResult.Failed)
{
NewRelic.Api.Agent.NewRelic.IgnoreTransaction();
context.SetError("Mensagem", "Usuário ou senha incorretos");
return;
}
break;
}
var token = new APIUsuarioToken
{
APIUsuario = usuario,
APIUsuarioID = usuario.ID,
DadosIndentificacao = context.Request.Headers["ClientInfo"],
Ativo = true,
DadosSession = JsonConvert.SerializeObject(new DadosSessionModel
{
SessionID = Guid.NewGuid().ToString(),
CanalID = usuario.CanalID,
LojaID = usuario.LojaID,
UsuarioID = usuario.UsuarioID,
SiteID = usuario.SiteID,
}),
DataExpiracao = DateTime.Now.Add(TimeSpan.FromHours(usuario.HorasExpiracaoToken))
};
usuarioBO.Salvar(token, true);
context.Options.AccessTokenExpireTimeSpan = TimeSpan.FromHours(usuario.HorasExpiracaoToken);
ClaimsIdentity oAuthIdentity = await usuarioBO.CriarIdentityAsync(usuario, userManager.UserTokenProvider);
AuthenticationTicket ticket = new AuthenticationTicket(oAuthIdentity, CreateProperties(usuario));
context.Validated(ticket);
}
}
catch (Exception ex)
{
LogUtil.Error(ex);
}
}
protected override bool IsAuthorized(HttpActionContext actionContext)
{
try
{
if ((ConfiguracaoAppUtil.GetAsBool(enumConfiguracaoGeral.httpsHabilitado)) && (actionContext.Request.RequestUri.Scheme != Uri.UriSchemeHttps))
{
actionContext.Response = new HttpResponseMessage(System.Net.HttpStatusCode.Forbidden)
{
ReasonPhrase = "HTTPS Required"
};
}
if (base.IsAuthorized(actionContext))
{
var controller = (MasterApiController)actionContext.ControllerContext.Controller;
IPrincipal principal = actionContext.ControllerContext.RequestContext.Principal;
if ((principal.Identity != null) && (principal.Identity.IsAuthenticated))
{
using (var usuarioBO = new APIUsuarioBO())
{
if (controller.APIUsuarioToken == null)
{
controller.APIUsuarioToken = usuarioBO.ConsultarToken(actionContext.ControllerContext.Request.Headers.Authorization.Parameter);
if (controller.APIUsuarioToken == null)
{
controller.APIUsuarioToken = usuarioBO.ConsultarToken(actionContext.ControllerContext.Request.Headers.GetValues("ClientInfo").FirstOrDefault(), principal.Identity.Name);
if ((controller.APIUsuarioToken == null) || (controller.APIUsuarioToken.Token != null))
{
return(false);
}
controller.APIUsuarioToken.Token = actionContext.ControllerContext.Request.Headers.Authorization.Parameter;
controller.AtualizarToken = true;
}
}
if ((_apiRoles != null) && (_apiRoles.Length > 0) && (controller.APIUsuarioToken.Roles == null))
{
controller.APIUsuarioToken.Roles = usuarioBO.ConsultarPermissoes(controller.APIUsuarioToken.APIUsuario.ID);
}
}
controller.SessionModel = JsonConvert.DeserializeObject <SessionModel>(controller.APIUsuarioToken.DadosSession);
if ((!controller.APIUsuarioToken.APIUsuario.Ativo) || (!controller.APIUsuarioToken.Ativo) || (controller.APIUsuarioToken.DadosIndentificacao != actionContext.ControllerContext.Request.Headers.GetValues("ClientInfo").FirstOrDefault()))
{
return(false);
}
// TODO: Tem algum problema, deve ser checado
switch (controller.APIUsuarioToken.APIUsuario.TipoAcessoAsEnum)
{
case enumAPITipoAcesso.webClient:
if (string.IsNullOrEmpty(controller.APIUsuarioToken.APIUsuario.DominiosOrigem))
{
return(false);
}
if (controller.APIUsuarioToken.APIUsuario.DominiosOrigem != "*")
{
var dominiosWC = controller.APIUsuarioToken.APIUsuario.DominiosOrigem.Split(',').Select(t => t.Trim());
if (!dominiosWC.Contains(HttpContext.Current.Request.GetClientReferer()))
{
return(false);
}
}
break;
case enumAPITipoAcesso.webServer:
if (string.IsNullOrEmpty(controller.APIUsuarioToken.APIUsuario.IPOrigem))
{
return(false);
}
if (controller.APIUsuarioToken.APIUsuario.IPOrigem != "*")
{
var ips = controller.APIUsuarioToken.APIUsuario.IPOrigem.Split(',').Select(t => t.Trim());
if (!ips.Any(t => HttpContext.Current.Request.GetClientIPAddress().Contains(t)))
{
if (HttpContext.Current.Request.UrlReferrer == null)
{
LogUtil.Error("Os IPs " + string.Join(", ", HttpContext.Current.Request.GetClientIPAddress().ToArray()) + " não são permitidos para acesso a API com o usuário " + controller.APIUsuarioToken.APIUsuario.Login);
return(false);
}
else
{
if (string.IsNullOrEmpty(controller.APIUsuarioToken.APIUsuario.DominiosOrigem))
{
LogUtil.Error("Os IPs " + string.Join(", ", HttpContext.Current.Request.GetClientIPAddress().ToArray()) + " não são permitidos para acesso a API com o usuário " + controller.APIUsuarioToken.APIUsuario.Login);
return(false);
}
if (controller.APIUsuarioToken.APIUsuario.DominiosOrigem != "*")
{
var dominiosWS = controller.APIUsuarioToken.APIUsuario.DominiosOrigem.Split(',').Select(t => t.Trim());
if (!dominiosWS.Contains(HttpContext.Current.Request.GetClientReferer()))
{
LogUtil.Error("O Domínio " + HttpContext.Current.Request.GetClientReferer() + " não permitido para o acesso a API com o usuário " + controller.APIUsuarioToken.APIUsuario.Login);
return(false);
}
}
}
}
}
break;
}
if ((_apiRoles != null) && (_apiRoles.Length > 0))
{
if ((!controller.APIUsuarioToken.Roles.Select(t => t.ToLower()).Contains(enumAPIRele.master.Description().ToLower())) && (!_apiRoles.Any(t => controller.APIUsuarioToken.Roles.Any(y => t.Description().ToLower().Split(',').Contains(y.ToLower())))))
{
if (controller.ControllerContext.RouteData.Values.ContainsKey("action"))
{
LogUtil.Error("O Usuario da API " + controller.APIUsuarioToken.APIUsuario.Login + " não tem permissão para o acesso ao metodo " + controller.ControllerContext.RouteData.Values["action"] + " ");
}
else
{
LogUtil.Error("O Usuario da API " + controller.APIUsuarioToken.APIUsuario.Login + " não tem permissão para o acesso.");
}
return(false);
}
}
}
return(true);
}
return(false);
}
catch (Exception ex)
{
LogUtil.Error(ex);
return(false);
}
}
public APIUsuarioUserStore(APIUsuarioBO apiUsuarioBO = null)
{
APIUsuarioBO = apiUsuarioBO;
}