public List <PermisoUsuario> Listar_PermisosUsuario(string S_UserName)
{
var listPermission = new List <PermisoUsuario>();
var oDatabase = DatabaseFactory.CreateDatabase();
var oDbCommand = oDatabase.GetStoredProcCommand("up_Login_PermisosUsuario");
oDatabase.AddInParameter(oDbCommand, "@S_UserName", DbType.String, S_UserName);
using (var oReader = oDatabase.ExecuteReader(oDbCommand))
{
while (oReader.Read())
{
var objPermission = new PermisoUsuario
{
N_IDPermiso = DataConvert.ToInt32(oReader["N_IDPermiso"]),
S_IDGrupo = DataConvert.ToString(oReader["S_IDGrupo"]),
S_GrupoDescripcion = DataConvert.ToString(oReader["S_GrupoDescripcion"]),
S_IDPagina = DataConvert.ToString(oReader["S_IDPagina"]),
S_PaginaDescripcion = DataConvert.ToString(oReader["S_PaginaDescripcion"]),
S_IDAccion = DataConvert.ToString(oReader["S_IDAccion"]),
S_AccionDescripcion = DataConvert.ToString(oReader["S_AccionDescripcion"])
};
listPermission.Add(objPermission);
}
oReader.Close();
}
return(listPermission);
}
public static void actualizarUsuarioPermiso(PermisoUsuario obj)
{
if (obj == null)
{
throw new ArgumentException("El objeto a insertar no puede tener un valor nulo");
}
if (obj.UsuarioPermisoId <= 0)
{
throw new ArgumentException("El objeto a insertar no puede ser menor o igual a 0");
}
if (obj.UsuarioId == 0)
{
throw new ArgumentException("el Codigo de Usuario es 0");
}
if (obj.PermisoId == 0)
{
throw new ArgumentException("el Codigo de Permiso es 0");
}
UsuarioPermisosDSTableAdapters.UsuarioPermisoTableAdapter adapter = new UsuarioPermisosDSTableAdapters.UsuarioPermisoTableAdapter();
adapter.Update(obj.UsuarioId, obj.PermisoId, obj.UsuarioPermisoId);
}
public async Task <IActionResult> Login(Login login, string returnUrl = null)
{
if (!ModelState.IsValid)
{
return(RedirectToAction(nameof(LoginController.Index)));
}
var response = await apiServicio.ObtenerElementoAsync1 <Response>(login,
new Uri(WebApp.BaseAddressSeguridad),
"/api/Adscpassws/Login");
if (!response.IsSuccess)
{
return(RedirectToAction(nameof(LoginController.Index), new { mensaje = response.Message }));
}
var usuario = JsonConvert.DeserializeObject <Adscpassw>(response.Resultado.ToString());
var codificar = new Codificar
{
Entrada = Convert.ToString(DateTime.Now),
};
Guid guidUsuario;
guidUsuario = Guid.NewGuid();
var permisoUsuario = new PermisoUsuario
{
Usuario = usuario.AdpsLogin,
Token = Convert.ToString(guidUsuario),
};
var salvarToken = await apiServicio.InsertarAsync <Response>(permisoUsuario, new Uri(WebApp.BaseAddressSeguridad), "/api/Adscpassws/SalvarToken");
var claims = new[]
{
new Claim(ClaimTypes.Name, usuario.AdpsLogin),
new Claim(ClaimTypes.SerialNumber, Convert.ToString(guidUsuario))
};
var principal = new ClaimsPrincipal(new ClaimsIdentity(claims, CookieAuthenticationDefaults.AuthenticationScheme));
await HttpContext.Authentication.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, principal);
if (string.IsNullOrEmpty(returnUrl))
{
return(RedirectToAction(nameof(HomesController.Index), "Homes"));
}
return(LocalRedirect(returnUrl));
}
/// <summary>
/// Método que válida si el usuario actual tiene permiso para realizar la acción solicitada en el contecto
/// El usuario debe tener los permisos en la base de datos
/// </summary>
/// <param name="context"></param>
/// <param name="requirement"></param>
/// <returns>Si la acción solicitada es o no satisfactoria</returns>
protected override Task HandleRequirementAsync(AuthorizationHandlerContext context, RolesRequirement requirement)
{
try
{
/// <summary>
/// Se obtiene el contexto de datos
/// </summary>
/// <returns></returns>
var recurso = context.Resource as Microsoft.AspNetCore.Mvc.Filters.AuthorizationFilterContext;
var httpContext = recurso.HttpContext;
/// <summary>
/// Se obtiene el path solicitado
/// </summary>
/// <returns></returns>
var request = httpContext.Request;
/// <summary>
/// Se obtiene información del usuario autenticado
/// </summary>
/// <returns></returns>
var claim = context.User.Identities.Where(x => x.NameClaimType == ClaimTypes.Name).FirstOrDefault();
var token = claim.Claims.Where(c => c.Type == ClaimTypes.SerialNumber).FirstOrDefault().Value;
var NombreUsuario = claim.Claims.Where(c => c.Type == ClaimTypes.Name).FirstOrDefault().Value;
var permiso = new PermisoUsuario
{
Contexto = request.Path,
Token = token,
Usuario = NombreUsuario,
};
/// <summary>
/// Se valida que la información del usuario actual tenga permiso para acceder al path solicitado...
/// </summary>
/// <returns></returns>
var respuesta = apiServicio.ObtenerElementoAsync1 <Response>(permiso, new Uri(WebApp.BaseAddress), "api/Adscpassws/TienePermiso");
//respuesta.Result.IsSuccess = true;
if (respuesta.Result.IsSuccess)
{
context.Succeed(requirement);
}
else
{
context.Fail();
}
}
catch (Exception)
{
context.Fail();
return(Task.CompletedTask);
}
return(Task.FromResult(0));
}
public PermisoUsuario Add(PermisoUsuario entity)
{
try
{
return(repository.Add(entity));
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public static void insertUsuarioPermiso(PermisoUsuario obj)
{
if (obj == null)
{
throw new ArgumentException("El objeto UsuarioPermiso no debe ser nulo");
}
int?usuarioPermisoId = 0;
UsuarioPermisosDSTableAdapters.UsuarioPermisoTableAdapter adapter = new UsuarioPermisosDSTableAdapters.UsuarioPermisoTableAdapter();
adapter.Insert(obj.UsuarioId, obj.PermisoId, ref usuarioPermisoId);
}
public static void eliminarUsuarioPermisoByUsuarioIdPermisoId(int usuarioId, int permisoId)
{
UsuarioPermisosDSTableAdapters.UsuarioPermisoTableAdapter adapter = new UsuarioPermisosDSTableAdapters.UsuarioPermisoTableAdapter();
UsuarioPermisosDS.UsuarioPermisoDataTable table = adapter.GetIdByUserPerm(usuarioId, permisoId);
var row = table[0];
PermisoUsuario obj = new PermisoUsuario();
obj.UsuarioPermisoId = row.usuarioPermisoId;
eliminarUsuarioPermisoById(obj.UsuarioPermisoId);
}
public async Task <ActionResult> AbrirSistema(string host)
{
try
{
var a = new Guid();
/// <summary>
/// Se obtiene información del usuario autenticado
/// </summary>
var claim = HttpContext.User.Identities.Where(x => x.NameClaimType == ClaimTypes.Name).FirstOrDefault();
var token = claim.Claims.Where(c => c.Type == ClaimTypes.SerialNumber).FirstOrDefault().Value;
var NombreUsuario = claim.Claims.Where(c => c.Type == ClaimTypes.Name).FirstOrDefault().Value;
var permiso = new PermisoUsuario
{
Token = token,
Usuario = NombreUsuario,
};
/// <summary>
/// Se válida si el usuario tiene el token válido para realizar la acción de abrir el sistema
/// </summary>
var respuesta = apiServicio.ObtenerElementoAsync1 <Response>(permiso, new Uri(WebApp.BaseAddressSeguridad), "api/Adscpassws/TienePermisoTemp");
//respuesta.Result.IsSuccess = true;
if (respuesta.Result.IsSuccess)
{
a = Guid.NewGuid();
var permisoTemp = new PermisoUsuario
{
Token = Convert.ToString(a),
Usuario = NombreUsuario,
};
/// <summary>
/// Se salva un Token temporal en la base de datos por usuario para que al abrir el otro sistema este válide
/// el token fue generado por esta aplicación
/// </summary>
var salvarToken = await apiServicio.InsertarAsync <Response>(permisoTemp, new Uri(WebApp.BaseAddressSeguridad), "api/Adscpassws/SalvarTokenTemp");
return(Redirect(host + "/Login/Login" + "?miembro=" + NombreUsuario + "&token=" + a.ToString()));
}
else
{
return(null);
}
}
catch (Exception)
{
return(RedirectToAction(nameof(LoginController.Index), "Login"));
}
//return Redirect(host+"?miembro=" + NombreUsuario);
}
public static void eliminarUsuarioPermiso(int usuarioId)
{
int usuarioPermisoId = 0;
UsuarioPermisosDSTableAdapters.UsuarioPermisoTableAdapter adapter = new UsuarioPermisosDSTableAdapters.UsuarioPermisoTableAdapter();
UsuarioPermisosDS.UsuarioPermisoDataTable table = adapter.GetUsuarioPermisoIdByUsuarioId(usuarioId);
foreach (var row in table)
{
PermisoUsuario obj = new PermisoUsuario();
usuarioPermisoId = row.usuarioPermisoId;
adapter.Delete(usuarioPermisoId);
}
}
public async Task <Response> TienePermisoTemp([FromBody] PermisoUsuario permiso)
{
try
{
var token = await db.Adscpassw.Where(x => x.AdpsToken == permiso.Token && x.AdpsLogin.ToUpper() == permiso.Usuario.ToUpper()).FirstOrDefaultAsync();
return(new Response {
IsSuccess = true
});
}
catch (Exception)
{
throw;
}
}
public async Task <Response> SalvarToken([FromBody] PermisoUsuario permisoUsuario)
{
try
{
var usuario = db.Adscpassw.Where(x => x.AdpsLogin.ToUpper() == permisoUsuario.Usuario.ToUpper()).FirstOrDefault();
if (usuario == null)
{
return(new Response
{
IsSuccess = false,
Message = Mensaje.RegistroNoEncontrado
});
}
usuario.AdpsToken = permisoUsuario.Token;
db.Adscpassw.Update(usuario);
await db.SaveChangesAsync();
return(new Response
{
IsSuccess = true,
});
}
catch (Exception ex)
{
await GuardarLogService.SaveLogEntry(new LogEntryTranfer
{
ApplicationName = Convert.ToString(Aplicacion.SwSeguridad),
ExceptionTrace = ex,
LogCategoryParametre = Convert.ToString(LogCategoryParameter.Critical),
LogLevelShortName = Convert.ToString(LogLevelParameter.ERR),
Message = ex.Message,
UserName = permisoUsuario.Usuario,
});
return(new Response
{
IsSuccess = false,
Message = ex.Message,
});
throw;
}
}
protected override Task HandleRequirementAsync(AuthorizationHandlerContext context, RolesRequirement requirement)
{
try
{
//Obtención del Context
var recurso = context.Resource as Microsoft.AspNetCore.Mvc.Filters.AuthorizationFilterContext;
var httpContext = recurso.HttpContext;
var request = httpContext.Request;
var claim = context.User.Identities.Where(x => x.NameClaimType == ClaimTypes.Name).FirstOrDefault();
var token = claim.Claims.Where(c => c.Type == ClaimTypes.SerialNumber).FirstOrDefault().Value;
var NombreUsuario = claim.Claims.Where(c => c.Type == ClaimTypes.Name).FirstOrDefault().Value;
var permiso = new PermisoUsuario
{
Contexto = request.Path,
Token = token,
Usuario = NombreUsuario,
};
var respuesta = apiServicio.ObtenerElementoAsync1 <Response>(permiso, new Uri(WebApp.BaseAddressSeguridad), "api/Adscpassws/TienePermiso");
//respuesta.Result.IsSuccess = true;
if (respuesta.Result.IsSuccess)
{
context.Succeed(requirement);
}
else
{
httpContext.Authentication.SignOutAsync("Cookies");
foreach (var cookie in httpContext.Request.Cookies.Keys)
{
httpContext.Response.Cookies.Delete(cookie);
}
context.Fail();
}
}
catch (Exception)
{
context.Fail();
return(Task.CompletedTask);
}
return(Task.FromResult(0));
}
public async Task <Response> TienePermiso([FromBody] PermisoUsuario permiso)
{
try
{
var path = NormalizarPathContexto(permiso.Contexto);
var token = await db.Adscpassw.Where(x => x.AdpsToken == permiso.Token && x.AdpsLogin.ToUpper() == permiso.Usuario.ToUpper()).FirstOrDefaultAsync();
if (token != null)
{
var grupos = await db.Adscmiem.Where(m => m.AdmiEmpleado.ToUpper() == permiso.Usuario.ToUpper()).ToListAsync();
foreach (var item in grupos)
{
var a = await db.Adscexe.Where(x => x.AdexGrupo == item.AdmiGrupo).ToListAsync();
foreach (var s in a)
{
var ds = await db.Adscmenu.Where(x => x.AdmeSistema == s.AdexSistema && x.AdmeAplicacion == s.AdexAplicacion).FirstOrDefaultAsync();
if (ds.AdmeControlador != null)
{
if (path.ToUpper().StartsWith(ds.AdmeControlador.ToUpper()))
{
return(new Response {
IsSuccess = true
});
}
}
}
}
}
return(new Response {
IsSuccess = false
});
}
catch (Exception)
{
throw;
}
}
public JsonResult GuardarPermisos(string id, IList <Usuario> usuarios)
{
var jsonResponse = new JsonResponse();
try
{
var idFormulario = Convert.ToInt32(id);
var permisosUsuario = new List <PermisoUsuario>();
foreach (var user in usuarios)
{
foreach (var permiso in user.Permisos)
{
if (!permiso.Seleccionado)
{
continue;
}
var permisoRol = new PermisoUsuario
{
IdEmpleado = user.IdEmpleado,
IdFormulario = idFormulario,
IdTipoPermiso = permiso.IdTipoPermiso,
};
permisosUsuario.Add(permisoRol);
}
}
PermisoUsuarioBL.Instancia.Guardar(idFormulario, permisosUsuario);
jsonResponse.Success = true;
jsonResponse.Message = "Se Proceso con exito.";
}
catch (Exception ex)
{
jsonResponse.Message = ex.Message;
}
return(Json(jsonResponse, JsonRequestBehavior.AllowGet));
}
public async Task <Response> ExisteToken([FromBody] PermisoUsuario permiso)
{
try
{
var path = NormalizarPathContexto(permiso.Contexto);
var token = await db.Adscpassw.Where(x => x.AdpsToken == permiso.Token && x.AdpsLogin.ToUpper() == permiso.Usuario.ToUpper()).FirstOrDefaultAsync();
if (token != null)
{
return(new Response {
IsSuccess = true
});
}
return(new Response {
IsSuccess = false
});
}
catch (Exception)
{
throw;
}
}
protected void BtnSave_Click(object sender, EventArgs e)
{
panelError.Visible = false;
try
{
int id = Convert.ToInt32(UsuarioID.Value);
string nombre = txtNombre.Text;
string apellido = txtApellido.Text;
string email = txtEmail.Text;
string contraseña = txtContraseña.Text;
string tipoUsuario = "admin";
string estado = "activo";
string estadoActual = "off";
Usuario obj = new Usuario()
{
Nombre = nombre,
Apellido = apellido,
Email = email,
Contraseña = contraseña,
TipoUsuario = tipoUsuario,
Estado = estado,
EstadoActual = estadoActual,
UsuarioId = id
};
string strId = Request.Params["Id"];
//Insertar Nuevo Usuario
if (string.IsNullOrEmpty(strId))
{
int userId = UsuarioBRL.insertarUsuario(obj);
PermisoUsuario usuarioPermiso;
Permiso tempPerm;
//Le inserto los permisos
for (int i = 0; i < checkPermisos.Items.Count; i++)
{
if (checkPermisos.Items[i].Selected)
{
tempPerm = PermisoBRL.getPermisoByDescription(checkPermisos.Items[i].Text);
usuarioPermiso = new PermisoUsuario()
{
UsuarioId = userId,
PermisoId = tempPerm.PermisoID
};
UsuarioPermisoBRL.insertUsuarioPermiso(usuarioPermiso);
}
}
}
//Actualizar Usuario
else
{
string Id = Request.Params["Id"];
int codigoUsuario = Int32.Parse(Id);
UsuarioBRL.actualizarUsuario(nombre, apellido, codigoUsuario);
//Actualizar Permisos
Permiso perm1;
Permiso perm2;
for (int i = 0; i < checkPermisos.Items.Count; i++)
{
if (checkPermisos.Items[i].Selected)
{
perm1 = PermisoBRL.getPermisoByDescription(checkPermisos.Items[i].Text);
if (!UsuarioPermisoBRL.tienePermiso(obj.UsuarioId, perm1.PermisoID))
{
//Agregar
PermisoUsuario admPerm = new PermisoUsuario()
{
UsuarioId = obj.UsuarioId,
PermisoId = perm1.PermisoID
};
UsuarioPermisoBRL.insertUsuarioPermiso(admPerm);
}
}
else
{
perm2 = PermisoBRL.getPermisoByDescription(checkPermisos.Items[i].Text);
if (UsuarioPermisoBRL.tienePermiso(obj.UsuarioId, perm2.PermisoID))
{
//Eliminar
UsuarioPermisoBRL.eliminarUsuarioPermisoByUsuarioIdPermisoId(obj.UsuarioId, perm2.PermisoID);
}
}
}
}
}
catch (Exception ex)
{
panelError.Visible = true;
return;
}
Response.Redirect("~/Administrador/AdminLista.aspx");
}
public void OnActionExecuting(ActionExecutingContext context)
{
try
{
/// <summary>
/// Se obtiene el contexto de datos
/// </summary>
/// <returns></returns>
/// con
var httpContext = context.HttpContext;
/// <summary>
/// Se obtiene el path solicitado
/// </summary>
/// <returns></returns>
var request = httpContext.Request;
/// <summary>
/// Se obtiene información del usuario autenticado
/// </summary>
/// <returns></returns>
var claim = context.HttpContext.User.Identities.Where(x => x.NameClaimType == ClaimTypes.Name).FirstOrDefault();
var token = claim.Claims.Where(c => c.Type == ClaimTypes.SerialNumber).FirstOrDefault().Value;
var NombreUsuario = claim.Claims.Where(c => c.Type == ClaimTypes.Name).FirstOrDefault().Value;
var permiso = new PermisoUsuario
{
Contexto = request.Path,
Token = token,
Usuario = NombreUsuario
};
/// <summary>
/// Se valida que la información del usuario actual tenga permiso para acceder al path solicitado...
/// </summary>
/// <returns></returns>
var respuestaToken = apiServicio.ObtenerElementoAsync <Response>(permiso, new Uri(WebApp.BaseAddressSeguridad), "api/Adscpassws/ExisteToken");
if (!respuestaToken.Result.IsSuccess)
{
context.HttpContext.Authentication.SignOutAsync("Cookies");
foreach (var cookie in context.HttpContext.Request.Cookies.Keys)
{
context.HttpContext.Response.Cookies.Delete(cookie);
}
var result = new ViewResult {
ViewName = "SeccionCerrada"
};
context.Result = result;
}
else
{
var respuesta = apiServicio.ObtenerElementoAsync <Response>(permiso, new Uri(WebApp.BaseAddressSeguridad), "api/Adscpassws/TienePermiso");
if (!respuesta.Result.IsSuccess)
{
var result = new ViewResult {
ViewName = "AccesoDenegado"
};
context.Result = result;
}
else
{
var claimTransfer = claimsTransfer.ObtenerClaimsTransferHttpContext();
if (claimTransfer == null || claimTransfer.IdSucursal == 0 || String.IsNullOrEmpty(claimTransfer.NombreSucursal))
{
var result = new ViewResult {
ViewName = "AccesoDenegadoEmpleadosClaims"
};
context.Result = result;
}
}
}
}
catch (Exception)
{
var result = new RedirectResult(WebApp.BaseAddressWebAppLogin);
context.Result = result;
}
}
/// <summary>
/// Método que es invocado desde la aplicaciín de Login
/// Donde se valida el token temporal que el generado por la aplicación de Login para el usuario actual
/// Si el token temporal es válido se elimina sino lo enviá a la aplicación de Login
/// Si todo es satisfactorio se autentica a la cookie...
/// </summary>
/// <returns></returns>
public async Task <IActionResult> Login()
{
try
{
var claim = HttpContext.User.Identities.Where(x => x.NameClaimType == ClaimTypes.Name).FirstOrDefault();
var token = claim.Claims.Where(c => c.Type == ClaimTypes.SerialNumber).FirstOrDefault().Value;
var NombreUsuario = claim.Claims.Where(c => c.Type == ClaimTypes.Name).FirstOrDefault().Value;
var permiso = new PermisoUsuario
{
Contexto = HttpContext.Request.Path,
Token = token,
Usuario = NombreUsuario,
};
/// <summary>
/// Se valida que la información del usuario actual tenga permiso para acceder al path solicitado...
/// </summary>
/// <returns></returns>
var respuesta = apiServicio.ObtenerElementoAsync1 <Response>(permiso, new Uri(WebApp.BaseAddress), "api/Adscpassws/TienePermiso");
if (!respuesta.Result.IsSuccess)
{
return(Redirect(WebApp.BaseAddressWebAppLogin));
}
if (Request.Query.Count != 2)
{
return(Redirect(WebApp.BaseAddressWebAppLogin));
}
Adscpassw adscpassw = new Adscpassw();
var queryStrings = Request.Query;
var qsList = new List <string>();
foreach (var key in queryStrings.Keys)
{
qsList.Add(queryStrings[key]);
}
var adscpasswSend = new Adscpassw
{
AdpsLogin = qsList[0],
AdpsTokenTemp = qsList[1]
};
adscpassw = await GetAdscPassws(adscpasswSend);
if (adscpassw != null)
{
var response = await EliminarTokenTemp(adscpassw);
if (response.IsSuccess)
{
var responseLog = new EntradaLog
{
ExceptionTrace = null,
LogCategoryParametre = Convert.ToString(LogCategoryParameter.Permission),
LogLevelShortName = Convert.ToString(LogLevelParameter.INFO),
ObjectPrevious = null,
ObjectNext = JsonConvert.SerializeObject(response.Resultado),
};
await apiServicio.SalvarLog <entidades.Utils.Response>(HttpContext, responseLog);
return(RedirectToActionPermanent(nameof(HomeController.Index), "Home"));
}
else
{
return(Redirect(WebApp.BaseAddressWebAppLogin));
}
}
return(Redirect(WebApp.BaseAddressWebAppLogin));
}
catch (Exception ex)
{
var responseLog = new EntradaLog
{
ExceptionTrace = ex.Message,
LogCategoryParametre = Convert.ToString(LogCategoryParameter.Critical),
LogLevelShortName = Convert.ToString(LogLevelParameter.ERR),
ObjectPrevious = null,
ObjectNext = null,
};
await apiServicio.SalvarLog <entidades.Utils.Response>(HttpContext, responseLog);
return(Redirect(WebApp.BaseAddressWebAppLogin));
}
}
public async Task <IActionResult> Login(Login login, string returnUrl = null)
{
if (!ModelState.IsValid)
{
return(RedirectToAction(nameof(LoginController.Index)));
}
var response = await apiServicio.ObtenerElementoAsync1 <Response>(login,
new Uri(WebApp.BaseAddressSeguridad),
"api/Adscpassws/Login");
UsuarioBloqueado(response, login);
if (!response.IsSuccess)
{
return(this.Redireccionar("Login", "Index", $"{Mensaje.Aviso}|{response.Message}|{TiempoMensaje.Tiempo1}"));
}
// var usuario = JsonConvert.DeserializeObject<Adscpassw>(response.Resultado.ToString());
var codificar = new Codificar
{
Entrada = Convert.ToString(DateTime.Now),
};
Guid guidUsuario;
guidUsuario = Guid.NewGuid();
var permisoUsuario = new PermisoUsuario
{
Usuario = login.Usuario,
Token = Convert.ToString(guidUsuario)
};
var salvarToken = await apiServicio.InsertarAsync <Response>(permisoUsuario, new Uri(WebApp.BaseAddressSeguridad), "api/Adscpassws/SalvarToken");
var dependenciaDatosViewModel = await apiServicio.ObtenerElementoAsync1 <DependenciaDatosViewModel>(new IdFiltrosViewModel { NombreUsuario = login.Usuario }, new Uri(WebApp.BaseAddressTH), "api/Dependencias/ObtenerDependenciaDatosViewModelPorUsuarioActual");
var empleado = await apiServicio.ObtenerElementoAsync1 <Empleado>(login.Usuario, new Uri(WebApp.BaseAddressTH), "api/Empleados/EmpleadoSegunNombreUsuario");
var listadoAdscmiems = (await apiServicio.Listar <Adscmiem>(new Uri(WebApp.BaseAddressSeguridad), "api/Adscmiems/ListarAdscmiem")).Where(c => c.AdmiEmpleado == login.Usuario);
var claims = new List <Claim>
{
new Claim(ClaimTypes.Name, login.Usuario),
new Claim(ClaimTypes.SerialNumber, Convert.ToString(guidUsuario))
};
if (dependenciaDatosViewModel != null)
{
if (dependenciaDatosViewModel.IdSucursal > 0)
{
claims.Add(new Claim("IdSucursal", dependenciaDatosViewModel.IdSucursal.ToString()));
}
if (!String.IsNullOrEmpty(dependenciaDatosViewModel.NombreSucursal))
{
claims.Add(new Claim("NombreSucursal", dependenciaDatosViewModel.NombreSucursal));
}
if (dependenciaDatosViewModel.IdDependencia > 0)
{
claims.Add(new Claim("IdDependencia", dependenciaDatosViewModel.IdDependencia.ToString()));
}
if (!String.IsNullOrEmpty(dependenciaDatosViewModel.NombreDependencia))
{
claims.Add(new Claim("NombreDependencia", dependenciaDatosViewModel.NombreDependencia));
}
}
if (empleado != null)
{
if (empleado.IdEmpleado > 0)
{
claims.Add(new Claim("IdEmpleado", empleado.IdEmpleado.ToString()));
}
if (empleado.Persona != null)
{
claims.Add(new Claim("NombreEmpleado", $"{empleado.Persona.Nombres} {empleado.Persona.Apellidos}"));
}
}
foreach (var item in listadoAdscmiems)
{
claims.Add(new Claim("ADMI_Grupo", item.AdmiGrupo));
}
var principal = new ClaimsPrincipal(new ClaimsIdentity(claims, "Cookies"));
await HttpContext.Authentication.SignInAsync("Cookies", principal, new Microsoft.AspNetCore.Http.Authentication.AuthenticationProperties {
IsPersistent = true
});
if (string.IsNullOrEmpty(returnUrl))
{
return(this.Redireccionar("Homes", "Menu", $"{Mensaje.Informacion}|{login.Usuario}:{Mensaje.Bienvenido}|{TiempoMensaje.Tiempo1}"));
}
return(LocalRedirect(returnUrl));
}
public void OnActionExecuting(ActionExecutingContext context)
{
try
{
/// <summary>
/// Se obtiene el contexto de datos
/// </summary>
/// <returns></returns>
/// con
var httpContext = context.HttpContext;
/// <summary>
/// Se obtiene el path solicitado
/// </summary>
/// <returns></returns>
var request = httpContext.Request;
/// <summary>
/// Se obtiene información del usuario autenticado
/// </summary>
/// <returns></returns>
var claim = context.HttpContext.User.Identities.Where(x => x.NameClaimType == ClaimTypes.Name).FirstOrDefault();
var token = claim.Claims.Where(c => c.Type == ClaimTypes.SerialNumber).FirstOrDefault().Value;
var NombreUsuario = claim.Claims.Where(c => c.Type == ClaimTypes.Name).FirstOrDefault().Value;
var permiso = new PermisoUsuario
{
Contexto = request.Path,
Token = token,
Usuario = NombreUsuario,
};
if (request.Path == "/")
{
var result = new RedirectResult(WebApp.BaseAddressWebAppLogin);
}
else
{
ApiServicio a = new ApiServicio();
var respuestaToken = a.ObtenerElementoAsync1 <Response>(permiso, new Uri(WebApp.BaseAddressSeguridad), "api/Adscpassws/ExisteToken");
if (!respuestaToken.Result.IsSuccess)
{
var result = new ViewResult {
ViewName = "SeccionCerrada"
};
context.Result = result;
}
else
{
var respuesta = a.ObtenerElementoAsync1 <Response>(permiso, new Uri(WebApp.BaseAddressSeguridad), "api/Adscpassws/TienePermiso");
//respuesta.Result.IsSuccess = true;
if (!respuesta.Result.IsSuccess)
{
var result = new ViewResult {
ViewName = "AccesoDenegado"
};
context.Result = result;
}
}
}
/// <summary>
/// Se valida que la información del usuario actual tenga permiso para acceder al path solicitado...
/// </summary>
/// <returns></returns>
}
catch (Exception ex)
{
//RedirectToActionResult a = new RedirectToActionResult("Index","Login","");
//context.Result = a;
var result = new RedirectResult(WebApp.BaseAddressWebAppLogin);
context.Result = result;
}
}