public JsonResult ChangeCliente(string cliente)
{
try
{
if (cliente == null)
{
throw new ArgumentNullException("cliente", "Argument null or empty");
}
if (cliente.Trim() == "")
{
throw new ArgumentException("Argument null or empty", "cliente");
}
HttpCookie AuthCookieClient;
if (Request.Cookies["AuthCookieClient"] != null)
{
AuthCookieClient = Request.Cookies["AuthCookieClient"];
AuthCookieClient[HttpUtility.UrlEncode(SeguridadUtilidades.Encriptar(User.Identity.Name))] = HttpUtility.UrlEncode(SeguridadUtilidades.Encriptar(cliente));
}
else
{
AuthCookieClient = new HttpCookie("AuthCookieClient");
AuthCookieClient[HttpUtility.UrlEncode(SeguridadUtilidades.Encriptar(User.Identity.Name))] = HttpUtility.UrlEncode(SeguridadUtilidades.Encriptar(cliente));
}
AuthCookieClient.Expires = DateTime.Now.AddYears(1);
HttpContext.Response.Cookies.Add(AuthCookieClient);
var identity = new IdentityPersonalizado(HttpContext.User.Identity);
var principal = new PrincipalPersonalizado(identity);
HttpContext.User = principal;
return(JsonExito());
}
catch (Exception e) {
return(JsonError("error al cambiar cliente", e));
}
}
public async Task <ActionResult> Create(SalarioBasico salarioBasico)
{
if (!ModelState.IsValid)
{
return(View(salarioBasico));
}
IdentityPersonalizado ci = (IdentityPersonalizado)HttpContext.User.Identity;
string nombreUsuario = ci.Identity.Name;
var administrador = new Administrador {
Nombre = nombreUsuario
};
administrador = await ProveedorAutenticacion.GetUser(administrador);
salarioBasico.EmpresaId = administrador.EmpresaId;
var response = await ApiServicio.InsertarAsync(salarioBasico,
new Uri(WebApp.BaseAddress),
"api/SalariosBasicos/CreateSalarioBasico");
if (!response.IsSuccess)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
return(RedirectToAction("Index"));
}
public async Task <ActionResult> Create(Agente agente)
{
if (!ModelState.IsValid)
{
ViewBag.SectorId = new SelectList(await obtenerSectoresPorEmpresa(), "SectorId", "NombreSector", agente.SectorId);
return(View(agente));
}
IdentityPersonalizado ci = (IdentityPersonalizado)HttpContext.User.Identity;
string nombreUsuario = ci.Identity.Name;
var administrador = new Administrador {
Nombre = nombreUsuario
};
administrador = await ProveedorAutenticacion.GetUser(administrador);
var codificar = CodificarHelper.SHA512(new Codificar {
Entrada = agente.Nombre
});
agente.Contrasena = codificar.Salida;
agente.EmpresaId = administrador.EmpresaId;
var response = await ApiServicio.InsertarAsync(agente,
new Uri(WebApp.BaseAddress),
"api/Agentes/CreateAgente");
if (!response.IsSuccess)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
return(RedirectToAction("Index", "Agentes"));
}
public async Task <ActionResult> Create(Vendedor vendedor)
{
if (!ModelState.IsValid)
{
return(View(vendedor));
}
IdentityPersonalizado ci = (IdentityPersonalizado)HttpContext.User.Identity;
string nombreUsuario = ci.Identity.Name;
var administrador = new Administrador {
Nombre = nombreUsuario
};
administrador = await ProveedorAutenticacion.GetUser(administrador);
var codificar = CodificarHelper.SHA512(new Codificar {
Entrada = vendedor.Nombre
});
vendedor.Contrasena = codificar.Salida;
vendedor.EmpresaId = administrador.EmpresaId;
var response = await ApiServicio.InsertarAsync(vendedor,
new Uri(WebApp.BaseAddress),
"api/Vendedors/CreateVendedor");
if (!response.IsSuccess)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
return(RedirectToAction("Index", "Vendedores"));
}
public override void OnActionExecuted(ActionExecutedContext context)
{
string controlador = context.Controller.ControllerContext.RouteData.Values["controller"].ToString();
string action = context.Controller.ControllerContext.RouteData.Values["action"].ToString();
string mensaje = controlador + "/" + action;
string ruta = context.Controller.ControllerContext.RouteData.ToString();
if (_funcion == "UsuarioNR")
{
return;
}
if (_funcion != null)
{
IdentityPersonalizado Ident = (IdentityPersonalizado)HttpContext.Current.User.Identity;
h_acceso_establecimiento acceso = new h_acceso_establecimiento();
acceso.fe_acceso = DateTime.Now;
acceso.id_establecimiento = Ident.Id_establecimiento;
acceso.nb_funcion = mensaje;
db.h_acceso_establecimiento.Add(acceso);
db.SaveChanges();
}
return;
}
protected void Application_PostAuthenticateRequest(object sender, EventArgs e)
{
if (Request.IsAuthenticated)
{
var identity = new IdentityPersonalizado(HttpContext.Current.User.Identity);
var principal = new PrincipalPersonalizado(identity);
HttpContext.Current.User = principal;
}
}
protected List <WebApplicationMod.Clientes> SesionClientesPermi()
{
if ((Session["SesionClientesPermi"] as List <WebApplicationMod.Clientes>) == null)
{
IdentityPersonalizado mu = HttpContext.User.Identity as IdentityPersonalizado;
Session["SesionClientesPermi"] = mu.clientsUser;
}
return(Session["SesionClientesPermi"] as List <WebApplicationMod.Clientes>);
}
protected List <string> SesionLoginPermisos()
{
if ((Session["SesionLoginPermisos"] as List <string>) == null)
{
IdentityPersonalizado mu = HttpContext.User.Identity as IdentityPersonalizado;
Session["SesionLoginPermisos"] = mu.roles;
}
return(Session["SesionLoginPermisos"] as List <string>);
}
protected WebApplicationMod.Usu SesionLogin()
{
if ((Session["usuario"] as WebApplicationMod.Usu) == null)
{
IdentityPersonalizado mu = HttpContext.User.Identity as IdentityPersonalizado;
Session["usuario"] = mu.user;
}
return(Session["usuario"] as WebApplicationMod.Usu);
}
public ActionResult Editar()
{
IdentityPersonalizado ident = (IdentityPersonalizado)ControllerContext.HttpContext.User.Identity;
EditarDatosUsuarioViewModel model = new EditarDatosUsuarioViewModel();
model.nb_establecimiento = ident.Nb_establecimiento;
//model.email_principal = ident.Email_principal;
//model.telefono = ident.Telefono;
return(View(model));
}
// GET: Empresas
public async Task <JsonResult> GetIdEmpresa()
{
IdentityPersonalizado ci = (IdentityPersonalizado)HttpContext.User.Identity;
string nombreUsuario = ci.Identity.Name;
var administrador = new Administrador {
Nombre = nombreUsuario
};
administrador = await ProveedorAutenticacion.GetUser(administrador);
return(Json(administrador.EmpresaId));
}
public override void OnActionExecuting(ActionExecutingContext filterContext)
{
IdentityPersonalizado Ident = (IdentityPersonalizado)HttpContext.Current.User.Identity;
if (Ident.Solo_lectura)
{
filterContext.Result = new RedirectResult(string.Format("~/Error/OnlyRead", filterContext.HttpContext.Request.Url.Host));
}
else
{
return;
}
}
public ActionResult ChangePassword()
{
int segundos_restantes;
string scc;
try
{
segundos_restantes = Int32.Parse(HttpContext.Session["STCP"].ToString());
}
catch
{
segundos_restantes = 1;
}
try
{
scc = HttpContext.Session["SCC"].ToString();
}
catch
{
scc = "false";
}
if (segundos_restantes == -1)
{
ViewBag.Mensaje = "Su contraseña ha caducado, por favor ingrese una nueva.";
}
else
{
ViewBag.Mensaje = "false";
}
if (scc == "true")
{
ViewBag.Mensaje = "La contraseña actual fue establecida por el administrador, por favor ingrese una nueva.";
}
else
{
ViewBag.Mensaje = "false";
}
IdentityPersonalizado ident = (IdentityPersonalizado)ControllerContext.HttpContext.User.Identity;
CambiarContrasenaViewModel model = new CambiarContrasenaViewModel();
model.original_password = ident.Password;
return(View(model));
}
public async Task <ActionResult> Create()
{
IdentityPersonalizado ci = (IdentityPersonalizado)HttpContext.User.Identity;
string nombreUsuario = ci.Identity.Name;
var administrador = new Administrador {
Nombre = nombreUsuario
};
administrador = await ProveedorAutenticacion.GetUser(administrador);
var agente = new Agente {
EmpresaId = administrador.EmpresaId
};
return(View());
}
public ActionResult Editar(EditarDatosUsuarioViewModel cambio)
{
IdentityPersonalizado ident = (IdentityPersonalizado)ControllerContext.HttpContext.User.Identity;
if (ModelState.IsValid)
{
c_establecimiento c_establecimiento = db.c_establecimiento.Find(ident.Id_establecimiento);
c_establecimiento.nb_establecimiento = cambio.nb_establecimiento;
//c_establecimiento.email_principal = cambio.email_principal;
//c_establecimiento.telefono = cambio.telefono;
db.SaveChanges();
FormsAuthentication.SignOut();
return(RedirectToAction("Index", "Home", ""));
}
return(View(cambio));
}
public async Task <JsonResult> InsertarSector(string nombreSector, List <Posiciones> arreglo)
{
if (string.IsNullOrEmpty(nombreSector) || arreglo.Count <= 2)
{
return(Json(false));
}
IdentityPersonalizado ci = (IdentityPersonalizado)HttpContext.User.Identity;
string nombreUsuario = ci.Identity.Name;
var administrador = new Administrador {
Nombre = nombreUsuario
};
administrador = await ProveedorAutenticacion.GetUser(administrador);
var lista = new List <PuntoSector>();
foreach (var item in arreglo)
{
//item.latitud=item.latitud.Replace(".", ",");
//item.longitud=item.longitud.Replace(".", ",");
lista.Add(new PuntoSector {
Latitud = Convert.ToDouble(item.latitud), Longitud = Convert.ToDouble(item.longitud)
});
}
var sector = new SectorViewModel
{
Sector = new Sector {
NombreSector = nombreSector, EmpresaId = administrador.EmpresaId
},
PuntoSector = lista,
};
var response = await ApiServicio.InsertarAsync(sector, new Uri( WebApp.BaseAddress), "/api/Sectors/InsertarSector");
if (!response.IsSuccess)
{
return(Json(false));
}
return(Json(true));
}
public ActionResult ChangePassword([Bind(Include = "original_password,password,new_password,repeat_password")] CambiarContrasenaViewModel cambio)
{
IdentityPersonalizado ident = (IdentityPersonalizado)ControllerContext.HttpContext.User.Identity;
if (ModelState.IsValid)
{
string newPass = SeguridadUtilidades.SHA256Encripta(cambio.new_password);
c_usuario c_usuario = db.c_usuario.Find(ident.Id_usuario);
h_password Pass = new h_password();
Pass.id_usuario = c_usuario.id_usuario;
Pass.password = newPass;
Pass.fe_actualizacion = DateTime.Now;
db.h_password.Add(Pass);
c_usuario.password = newPass;
c_usuario.id_estatus_usuario = 2;
c_usuario.fe_cambio_password = DateTime.Now;
db.SaveChanges();
HttpContext.Session["SCC"] = "false";
return(RedirectToAction("Success"));
}
string scc;
try
{
scc = HttpContext.Session["SCC"].ToString();
}
catch
{
scc = "false";
}
if (scc == "true")
{
ViewBag.Mensaje = "La contraseña actual fue establecida por el administrador, por favor ingrese una nueva.";
}
else
{
ViewBag.Mensaje = "false";
}
return(View());
}
public override void OnActionExecuting(ActionExecutingContext filterContext)
{
if (filterContext.HttpContext.User.Identity.IsAuthenticated)
{
if ((filterContext.HttpContext.Session["SesionLoginPermisos"] as List <string>) == null)
{
IdentityPersonalizado mu = (filterContext.HttpContext.User.Identity as IdentityPersonalizado);
filterContext.Controller.ViewBag.permisos = mu.roles;
filterContext.Controller.ViewBag.nomusu = mu.user.Nom;
//FilterContext.Controller.ViewBag.nomusu = mu.user.Nom;
filterContext.Controller.ViewBag.rutaPhoto = "../Img/fotos2/" + mu.user.Sigla + ".jpg";
}
else
{
filterContext.Controller.ViewBag.permisos = filterContext.HttpContext.Session["SesionLoginPermisos"] as List <string>;
}
}
}
public ActionResult Index()
{
//Obtenemos el valor de la variable de sesion
int segundos_restantes;
try
{
segundos_restantes = Int32.Parse(HttpContext.Session["STCP"].ToString());
}
catch
{
segundos_restantes = 253800;
}
//si quedan menos de 253800 segundos (3 días) construir el mensaje que se mostrará
if (segundos_restantes < 253800)
{
int dias = segundos_restantes / 86400;
segundos_restantes = segundos_restantes % 86400;
int horas = segundos_restantes / 3600;
segundos_restantes = segundos_restantes % 3600;
int minutos = segundos_restantes / 60;
string mensaje = "Quedan: " + dias + " días " + horas + " horas y " + minutos + " minutos para que la contraseña actual expire";
ViewBag.Mensaje = mensaje;
}
else
{
ViewBag.Mensaje = "false";
}
HttpContext.Session["STCP"] = "253800";
// Obtiene los datos generales para mostrarlos en la página de inicio
IdentityPersonalizado identity = (IdentityPersonalizado)ControllerContext.HttpContext.User.Identity;
c_establecimiento c_establecimiento = db.c_establecimiento.Find(identity.Id_establecimiento);
ViewBag.responsable = "Responsable: " + c_establecimiento.nb_responsable;
var periodo = db.c_periodo.Where(u => u.esta_activo == true).FirstOrDefault();
ViewBag.periodo = periodo != null ? "Periodo Activo: " + periodo.nb_periodo : "Sin Periodo Activo";
return(View());
}
private async Task <List <Sector> > obtenerSectoresPorEmpresa()
{
IdentityPersonalizado ci = (IdentityPersonalizado)HttpContext.User.Identity;
string nombreUsuario = ci.Identity.Name;
var administrador = new Administrador {
Nombre = nombreUsuario
};
administrador = await ProveedorAutenticacion.GetUser(administrador);
var empresa = new Empresa {
EmpresaId = administrador.EmpresaId
};
var listaSectores = await ApiServicio.Listar <Sector>(empresa,
new Uri(WebApp.BaseAddress),
"api/Sectors/GetSectoresPorEmpresa");
return(listaSectores);
}
public string[] ObtenerFunciones()
{
CNTSEntities db = new CNTSEntities();
IdentityPersonalizado Ident = (IdentityPersonalizado)HttpContext.Current.User.Identity;
if (Ident == null)
{
return(null);
}
int id_usuario = Ident.Id_usuario;
//Encontrar los roles que tiene el usuario
string sql = "select id_rol from c_rol_usuario where id_usuario = " + id_usuario;
var roles = db.Database.SqlQuery <int>(sql).ToArray();
//Encontrar cada funcion que tienen los roles
int[] funciones = new int[] { };
IEnumerable <int> union = funciones;
foreach (int rol in roles)
{
sql = "select id_funcion from c_funcion_rol where id_rol = " + rol;
var fns = db.Database.SqlQuery <int>(sql).ToArray();
union = union.Union(fns);
}
//Encontrar el nombre a partir de cada id
funciones = union.ToArray();
int nfunciones = funciones.Length;
string[] resultado = new string[nfunciones];
for (int i = 0; i < nfunciones; i++)
{
c_funcion c_funcion = db.c_funcion.Find(funciones[i]);
resultado[i] = c_funcion.cl_funcion;
}
return(resultado);
}
public async Task <ActionResult> Index()
{
IdentityPersonalizado ci = (IdentityPersonalizado)HttpContext.User.Identity;
string nombreUsuario = ci.Identity.Name;
var administrador = new Administrador {
Nombre = nombreUsuario
};
administrador = await ProveedorAutenticacion.GetUser(administrador);
var empresa = new Empresa {
EmpresaId = administrador.EmpresaId
};
var response = await ApiServicio.Listar <Vendedor>(empresa,
new Uri(WebApp.BaseAddress),
"api/Vendedors/GetVendedoresPorEmpresa");
if (response == null)
{
return(View(new List <Vendedor>()));
}
return(View(response));
}
protected override ValidationResult IsValid(object value, ValidationContext validationContext)
{
var model = (CambiarContrasenaViewModel)validationContext.ObjectInstance;
string Original = model.original_password;
if (value != null)
{
string encPass = SeguridadUtilidades.SHA256Encripta(value.ToString());
//Leer cada atributo necesario
int MaxLongitudPass = Utilidades.Utilidades.GetIntSecurityProp("MaxLongitudPass", "10");
int MinLongitudPass = Utilidades.Utilidades.GetIntSecurityProp("MinLongitudPass", "6");
bool ReutilizarPass = Utilidades.Utilidades.GetBoolSecurityProp("ReutilizarPass", "false");
bool Mayuscula = Utilidades.Utilidades.GetBoolSecurityProp("Mayuscula", "false");
bool Numero = Utilidades.Utilidades.GetBoolSecurityProp("Numero", "false");
bool RepetirUsuario = Utilidades.Utilidades.GetBoolSecurityProp("RepetirUsuario", "false");
IdentityPersonalizado Ident = (IdentityPersonalizado)HttpContext.Current.User.Identity;
//Verificar si existe validacion de logintud
if (value.ToString().Length > MaxLongitudPass)
{
return(new ValidationResult("La longitud máxima de la contraseña es de " + MaxLongitudPass + " caracteres."));
}
if (value.ToString().Length < MinLongitudPass)
{
return(new ValidationResult("La longitud mínima de la contraseña es de " + MinLongitudPass + " caracteres."));
}
//Verificar si se puede reutilizar el password
if (!ReutilizarPass)
{
var passwords = db.h_password.Where(p => p.id_usuario == Ident.Id_usuario).ToList();
foreach (var pass in passwords)
{
if (pass.password == encPass)
{
return(new ValidationResult("No esta permitido reutilizar contraseñas anteriores."));
}
}
}
//Requiere una mayuscula
if (Mayuscula)
{
bool capital = false;
foreach (char c in value.ToString())
{
if ((int)c < 91 && (int)c > 64)
{
capital = true;
break;
}
}
if (!capital)
{
return(new ValidationResult("La contraseña debe contener al menos una mayúscula"));
}
}
//Requiere un número
if (Numero)
{
bool num = false;
foreach (char c in value.ToString())
{
if ((int)c < 58 && (int)c > 47)
{
num = true;
break;
}
}
if (!num)
{
return(new ValidationResult("La contraseña debe contener al menos un número"));
}
}
//Puede incluir el usuario?
if (!RepetirUsuario)
{
string nb_usuario = Ident.Email_principal;
if (value.ToString().Contains(nb_usuario))
{
return(new ValidationResult("La contraseña no puede contener tu nombre de usuario"));
}
}
return(ValidationResult.Success);
}
else
{
return(new ValidationResult("Ingresa tu contraseña."));
}
}
public override void OnActionExecuting(ActionExecutingContext filterContext)
{
if (_funcion == "UsuarioNR")
{
return;
}
IdentityPersonalizado Ident = (IdentityPersonalizado)HttpContext.Current.User.Identity;
bool checkedpass;
try
{
checkedpass = (bool)HttpContext.Current.Session["CHECKEDPASS"];
}
catch
{
checkedpass = true;
}
if (!checkedpass)
{
double total_segundos = Utilidades.Utilidades.SegundosTiempoCaducidad();
if (total_segundos > -1)
{
//obtener fecha actual y fecha de ultimo cambio de contraseña
DateTime actual = DateTime.Now;
DateTime ultima = Ident.Fe_cambio_password;
//la diferencia se medira en segundos
double diferencia = actual.Subtract(ultima).TotalSeconds;
double tiempo_restante = total_segundos - diferencia;
//que pasa si quedan menos de 3 días pero mas de 0 segundo
if (tiempo_restante < 253800 && tiempo_restante > 0)
{
//fijamos la variable de sesion con el tiempo restante
HttpContext.Current.Session["STCP"] = ((int)tiempo_restante).ToString();
//Marcamos la variable de sesion para evitar dobles validaciones
HttpContext.Current.Session["CHECKEDPASS"] = true;
//redirigimos a la funcion home/index
filterContext.Result = new RedirectResult(string.Format("~/Home/Index", filterContext.HttpContext.Request.Url.Host));
}
//que pasa si es negativo el resultado
if (tiempo_restante <= 0)
{
//fijamos la variable de sesion con un -1 para mostrar un aviso al cargar la vista de cambio de contraseña
HttpContext.Current.Session["STCP"] = "-1";
//redirigimos a la funcion home/index
filterContext.Result = new RedirectResult(string.Format("~/UsuarioNR/ChangePassword", filterContext.HttpContext.Request.Url.Host));
}
}
}
//Si la contraseña fue establecida por el administrador, solicitar el cambio
if (Ident.Id_estatus_establecimiento == 1)
{
HttpContext.Current.Session["SCC"] = "true";
filterContext.Result = new RedirectResult(string.Format("~/UsuarioNR/ChangePassword", filterContext.HttpContext.Request.Url.Host));
}
if (_funcion == null)
{
return;
}
//string[] funciones = utilidades.ObtenerFunciones();
//foreach (string fn in funciones)
//{
// if (_funcion.Equals(fn))
// {
// return;
// }
//}
filterContext.Result = new RedirectResult(string.Format("~/Error/Denied", filterContext.HttpContext.Request.Url.Host));
}
protected List <parametros> SesionRolesParam()
{
IdentityPersonalizado mu = HttpContext.User.Identity as IdentityPersonalizado;
return(mu.param);
}
protected List <Permisos> SesionPermisos()
{
IdentityPersonalizado mu = HttpContext.User.Identity as IdentityPersonalizado;
return(mu.roles);
}
protected Cliente SesionCliente()
{
IdentityPersonalizado mu = HttpContext.User.Identity as IdentityPersonalizado;
return(mu.clientUser);
}
protected Usuario SesionLogin()
{
IdentityPersonalizado mu = HttpContext.User.Identity as IdentityPersonalizado;
return(mu.user);
}
