public IResponse Autenticar(IRequest request)
{
if (!(request is null))
{
AutenticarUsuarioRequest autenticarUsuarioRequest = (AutenticarUsuarioRequest)request;
var usuario = new UsuarioBuild()
.AdicionarEmail(autenticarUsuarioRequest.Email)
.AdicionarSenha(autenticarUsuarioRequest.Senha)
.BuildAutenticar();
AddNotifications(usuario);
if (IsValid())
{
usuario = _repository.ObterPor(u => u.Email.ToString() == usuario.Email.ToString() && u.Senha == usuario.Senha);
if (!(usuario is null))
{
if (usuario.Status == StatusUsuario.Ativo)
{
return((AutenticarUsuarioResponse)usuario);
}
else
{
AddNotification("Status", $"Não foi possível efetuar o login. Status do usuário: {usuario.ObterStatusUsuario()}.");
return(null);
}
}
else
{
AddNotification("Usuário", "Nome de usuário e/ou senha incorretos.");
return(null);
}
}
public AutenticarUsuarioResponse AutenticarUsuario(AutenticarUsuarioRequest request)
{
if (request == null)
{
AddNotification("AutentiticarUsuarioRequest", MSG.OBJETO_X0_E_OBRIGATORIO.ToFormat("AutentiticarUsuarioRequest"));
return(null);
}
Email email = new Email(request.Email);
Senha senha = new Senha(request.Senha);
Usuario usuario = new Usuario(email, senha);
AddNotifications(usuario);
if (IsInvalid())
{
return(null);
}
usuario = _repositoryUsuario.Obter(usuario.Email.Endereco, usuario.Senha.Valor);
if (usuario == null)
{
AddNotification("Usuário", MSG.DADOS_NAO_ENCONTRADOS);
return(null);
}
//conversão explicita: (AutentiticarUsuarioResponse)usuario;
return((AutenticarUsuarioResponse)usuario);
}
public AutenticarUsuarioResponse AutenticarUsuario(AutenticarUsuarioRequest request)
{
if (request == null)
{
AddNotification("AutenticarUsuarioRequest", MSG.OBJETO_X0_E_OBRIGATORIO.ToFormat("AutenticarUsuarioRequest"));
return(null);
}
var email = new Email(request.Email);
var usuario = new Usuario(email, request.Senha);
AddNotifications(usuario);
if (IsInvalid())
{
return(null);
}
usuario = _repositoryUsuario.Obter(usuario.Email.Endereco, usuario.Senha);
if (request == null)
{
AddNotification("Usuario", MSG.DADOS_NAO_ENCONTRADOS);
return(null);
}
//var response = new AutenticarUsuarioResponse()
//{
// Id = usuario.Id,
// PrimeiroNome = usuario.Nome.PrimeiroNome
//};
//return response;
//cast direto
return((AutenticarUsuarioResponse)usuario);
}
public AutenticarUsuarioResponse AutenticarUsuario(AutenticarUsuarioRequest request)
{
if (request == null)
{
AddNotification("AutenticarUsuariorequest", "O objeto é obrigatório");
return(null);
}
var email = new Email(request.Email);
var usuario = new Usuario(email, request.Senha);
AddNotifications(usuario);
if (this.IsInvalid())
{
return(null);
}
usuario = _repositoryUsuario.Obter(usuario.Email.Endereco, usuario.Senha);
if (usuario == null)
{
AddNotification("Usuario", "Usuário não encontrado");
return(null);
}
var response = (AutenticarUsuarioResponse)usuario;
return(response);
}
public AutenticarUsuarioResponse AutenticarUsuario(AutenticarUsuarioRequest request)
{
if (request == null)
{
AddNotification("AutenticarUsuarioRequest", MSG.OBJETO_X0_E_OBRIGATORIO.ToFormat("AutenticarUsuarioRequest"));
return(null);
}
var email = new Email(request.Email);
var usuario = new Usuario(email, request.Senha);
AddNotifications(usuario);
if (this.IsInvalid())
{
return(null);
}
usuario = _repositoryUsuario.Obter(usuario.Email.Endereco, usuario.Senha);
if (usuario == null)
{
AddNotification("Usuario", MSG.DADOS_NAO_ENCONTRADOS);
}
return((AutenticarUsuarioResponse)usuario);
}
public object Autenticar(
[FromBody] AutenticarUsuarioRequest request,
[FromServices] SigningConfigurations signingConfigurations,
[FromServices] TokenConfigurations tokenConfigurations
)
{
bool credenciaisValidas = false;
var 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("Usuario", JsonConvert.SerializeObject(response))
});
DateTime CreateDate = DateTime.Now;
DateTime ExpireDate = CreateDate + 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 = CreateDate,
Expires = ExpireDate
});
var token = handler.WriteToken(securityToken);
return(new
{
authenticated = true,
created = CreateDate.ToString("yyyy-MM-dd HH:mm:ss"),
expiration = ExpireDate.ToString("yyyy-MM-dd HH:mm:ss"),
accesToken = token,
message = "OK",
primeiroNomeDoProprietario = response.PrimeiroNome
});
//return GenerateToken(
// credenciais.UserID, signingConfigurations,
// tokenConfigurations, cache);
}
else
{
return(new
{
authenticated = false,
message = "Falha ao autenticar"
});
}
}
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
});
}
}
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 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 IActionResult Post(
[FromServices] IMediator mediator,
[FromBody] AutenticarUsuarioRequest req
)
{
var res = mediator.Send(req);
return(Ok(res));
}
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 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> Autenticar([FromBody] AutenticarUsuarioRequest request)
{
try
{
var response = _serviceUsuario.AutenticarUsuario(request);
if (response != null)
{
var token = _accessManager.GenerateToken(response);
return(await ResponseAsync(token, _serviceUsuario));
}
return(await ResponseAsync(response, _serviceUsuario));
}
catch (Exception e)
{
return(await ResponseExceptionAsync(e));
}
}
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 IActionResult AutenticarUsuario([FromBody] AutenticarUsuarioRequest autenticarUsuarioRequest)
{
try
{
var response = this.usuarioBusiness.AutenticarUsuario(autenticarUsuarioRequest.Email, autenticarUsuarioRequest.Password);
if (response != null)
{
response.Token = this.GerarToken(autenticarUsuarioRequest.Email);
return(base.Ok(response));
}
return(base.NotFound("Nenhum usuário encontrado"));
}
catch (System.Exception e)
{
this.logger.LogInformation($"Erro:{e.Message}");
return(base.BadRequest(e));
}
}
public AutenticarUsuarioResponse AutenticarUsuario(AutenticarUsuarioRequest request)
{
if (request == null)
{
throw new ApplicationException("");
}
var usuario = new Usuario(request.Email, request.Password);
usuario = _repositoryUsuario.Obter(usuario.Email, usuario.Password);
if (usuario == null)
{
throw new ApplicationException("Usuário ou Senha inválidos, tente novamente.");
}
var response = (AutenticarUsuarioResponse)usuario;
return(response);
}
public AutenticarUsuarioResponse AutenticarUsuario(AutenticarUsuarioRequest request)
{
if (request == null)
{
// notification pattern e resources
AddNotification("AutenticarUsuarioRequest", Msg.OBJETO_X0_E_OBRIGATORIO.ToFormat("AutenticarUsuarioRequest"));
return(null);
}
// na entidade foi feita a blindagem de codigo e validação por meio do construtor
var email = new Email(request.Email);
var usuario = new Usuario(email, request.Senha);
AddNotifications(usuario);
if (this.IsInvalid())
{
return(null);
}
usuario = _repositoryUsuario.Obter(usuario.Email.Endereco, usuario.Senha);
if (usuario == null)
{
//notification pattern e resources
AddNotification("Usuario", Msg.DADOS_NAO_ENCONTRADOS);
return(null);
}
// foi feito a conversao explicita
//var response = new AutenticarUsuarioResponse()
//{
// Id = usuario.Id,
// PrimeiroNome = usuario.Nome.PrimeiroNome
//};
//conversao explicita
var response = (AutenticarUsuarioResponse)usuario;
return(response);
}
public AutenticarUsuarioResponse AutenticarUsuario(AutenticarUsuarioRequest request)
{
if (request == null)
{
AddNotification("AutenticarUsuarioRequest", Message.X0_E_OBRIGATORIO.ToFormat("AutenticarUsuarioRequest"));
}
var email = new Email(request.Email);
var usuario = new Usuario(email, request.Senha);
AddNotifications(usuario, email);
if (usuario.IsInvalid())
{
return(null);
}
usuario = _repositoryUsuario.ObterPor(x => x.Email.Endereco == usuario.Email.Endereco && x.Senha == usuario.Senha);
return((AutenticarUsuarioResponse)usuario);
}
public async Task <IActionResult> Autenticar(
[FromBody] AutenticarUsuarioRequest request,
[FromServices] SigningConfigurations signingConfigurations,
[FromServices] TokenConfigurations tokenConfigurations)
{
try
{
var autenticarUsuarioResponse = await _mediator.Send(request, CancellationToken.None);
if (autenticarUsuarioResponse.Autenticado == true)
{
var response = GerarToken(autenticarUsuarioResponse, signingConfigurations, tokenConfigurations);
return(Ok(response));
}
return(Ok(autenticarUsuarioResponse));
}
catch (System.Exception ex)
{
return(NotFound(ex.Message));
}
}
private string ResponderEfetuarLogin()
{
string lRetorno;
string lUsuario, lSenha;
lUsuario = Request.Form["Usuario"];
lSenha = Request.Form["Senha"];
if (string.IsNullOrEmpty(lUsuario))
{
lRetorno = RetornarErroAjax("Campo 'Usuário' é obrigatório");
}
else if (string.IsNullOrEmpty(lSenha))
{
lRetorno = RetornarErroAjax("Campo 'Senha' é obrigatório");
}
else
{
AutenticarUsuarioResponse lResponseAutenticacao = null;
try
{
this.LimparSessionsDoSistema();
AutenticarUsuarioRequest lRequestAuth = new AutenticarUsuarioRequest()
{
Email = lUsuario, // Admin
Senha = Criptografia.CalculateMD5Hash(lSenha), //123
IP = Request.ServerVariables["REMOTE_ADDR"],
CodigoSistemaCliente = "Intranet"
};
IServicoSeguranca lServico = this.ServicoSeguranca;
lResponseAutenticacao = lServico.AutenticarUsuario(lRequestAuth);
if (lResponseAutenticacao.StatusResposta != MensagemResponseStatusEnum.OK)
{
return(RetornarErroAjax(lResponseAutenticacao.DescricaoResposta));
}
this.CodigoSessao = lResponseAutenticacao.Sessao.CodigoSessao;
}
catch (Exception ex)
{
return(RetornarErroAjax(ex.Message));
}
var lRetornoSessao = ServicoSeguranca.ReceberSessao(new ReceberSessaoRequest()
{
CodigoSessao = this.CodigoSessao,
CodigoSessaoARetornar = this.CodigoSessao,
});
this.Session["Usuario"] = new Usuario()
{
Id = lRetornoSessao.Usuario.CodigoUsuario.DBToInt32(),
Nome = lRetornoSessao.Usuario.Nome,
EmailLogin = lUsuario,
EhAdministrador = lResponseAutenticacao != null ? lResponseAutenticacao.Sessao.EhSessaoDeAdministrador : false,
Perfis = lRetornoSessao.Usuario.Perfis
};
lRetorno = base.RetornarSucessoAjax("Intranet/Default.aspx");
}
return(lRetorno);
}
public void btnAutenticar_Click(object sender, EventArgs args)
{
string lUsuario, lSenha;
lUsuario = txtLogin.Text;
lSenha = txtSenha.Text;
string lRetorno = string.Empty;
AutenticarUsuarioRequest lRequestAutenticacao;
AutenticarUsuarioResponse lResponseAutenticacao;
ReceberSessaoRequest lRequestSessao;
ReceberSessaoResponse lResponseSessao;
IServicoSeguranca lServicoSeguranca = this.InstanciarServico <IServicoSeguranca>();
lRequestAutenticacao = new AutenticarUsuarioRequest();
lRequestAutenticacao.Email = lUsuario;
lRequestAutenticacao.Senha = Criptografia.CalculateMD5Hash(lSenha);
lRequestAutenticacao.IP = Request.ServerVariables["REMOTE_ADDR"];
lRequestAutenticacao.CodigoSistemaCliente = "InvXX";
lResponseAutenticacao = lServicoSeguranca.AutenticarUsuario(lRequestAutenticacao);
if (lResponseAutenticacao.StatusResposta != Gradual.OMS.Library.MensagemResponseStatusEnum.OK)
{
//lRetorno = RetornarErroAjax(lResponseAutenticacao.DescricaoResposta);
Response.Write("<script LANGUAGE='JavaScript' >alert('" + lResponseAutenticacao.DescricaoResposta + "')</script>");
return;
}
lRequestSessao = new ReceberSessaoRequest();
lRequestSessao.CodigoSessaoARetornar = lResponseAutenticacao.Sessao.CodigoSessao;
lRequestSessao.CodigoSessao = lResponseAutenticacao.Sessao.CodigoSessao;
Session["CodigoSessao"] = lResponseAutenticacao.Sessao.CodigoSessao;
lResponseSessao = lServicoSeguranca.ReceberSessao(lRequestSessao);
base.UsuarioLogado = new Usuario()
{
CodigoDaSessao = lResponseAutenticacao.Sessao.CodigoSessao
,
IdDoUsuario = lResponseSessao.Usuario.Complementos.ReceberItem <ContextoOMSInfo>().CodigoCBLC
,
Nome = lResponseSessao.Usuario.Nome
,
TipoAcesso = (TipoAcesso)Enum.Parse(typeof(TipoAcesso), lResponseSessao.Usuario.CodigoTipoAcesso.ToString())
,
CodAssessor = lResponseSessao.Usuario.CodigoAssessor
,
IdLogin = int.Parse(lResponseSessao.Sessao.CodigoUsuario)
};
base.UsuarioLogado.IdDoUsuario = lResponseSessao.Sessao.CodigoUsuario;
base.UsuarioLogado.CodBovespa = base.UsuarioLogado.IdDoUsuario;
if (this.UsuarioLogado.CodBovespaTipoInt == 31940)
{
this.UsuarioLogado.CodBmf = 31217;
}
DisporServico(lServicoSeguranca);
Response.Redirect("default.aspx?guid=" + lResponseSessao.Sessao.CodigoSessao);
}
public AutenticarUsuarioResponse AutenticarUsuario(AutenticarUsuarioRequest request)
{
throw new System.NotImplementedException();
}
