/// <summary>
/// Método utilizado para verificar que el usuario de la aplicación
/// tiene permiso sobre la acción que intente ejecutar, y si dicho
/// rol no tiene permiso es redireccionado a una página que le muestra
/// al usuario un error indicando que no tiene permisos.
/// </summary>
/// <param name="filterContext">
/// Encapsula la información usasa para el mecanismo de autorización.
/// </param>
public override void OnAuthorization(AuthorizationContext filterContext)
{
base.OnAuthorization(filterContext);
db = new SIGECContext();
var descriptor = filterContext.ActionDescriptor;
bool isAView = descriptor.GetCustomAttributes(typeof(IsViewAttribute), true).Count() > 0;
if (!isAView)
{
return;
}
if (filterContext.ActionDescriptor.ActionName.ToLower() == "login")
{
return;
}
if (WebSecurity.IsAuthenticated) // si el usuario inició sesion
{
var a = db.Actions
.FirstOrDefault(ac => ac.name == descriptor.ActionName);
//si el usuario tiene permisos.
if (new MenuAuthorize().HasPermission(descriptor.ActionName, descriptor.ControllerDescriptor.ControllerName))
{
return;
}
filterContext.Result = new RedirectToRouteResult(
new RouteValueDictionary
{
{ "controller", "Unauthorize" },
{ "action", "ErrorUnauthorized" }
});
}
else // si el usuario no ha iniciado sesión.
{
bool isAllowAnonymous = descriptor.GetCustomAttributes(typeof(AllowAnonymousAttribute), true).Count() > 0;
if (isAllowAnonymous)
{
return;
}
filterContext.Result = new RedirectToRouteResult(
new RouteValueDictionary
{
{ "controller", "Account" },
{ "action", "Login" }
});
}
}
public static bool CheckUser(int userID, string username, string password)
{
var valid = false;
using (SIGECContext db = new SIGECContext())
{
var user = db.Users.Find(userID);
if (user == null)
{
return(false);
}
var passwordHelper = new PasswordHelper();
valid = passwordHelper.ComparePassword(password, user.password, user.salt);
}
return(valid);
}
/// <summary>
/// Constructor para sacar los permisos que tiene un usuario y almacenarlos en la variable Menu
/// </summary>
public MenuAuthorize()
{
try
{
if (WebSecurity.IsAuthenticated)
{
db = new SIGECContext();
var user = db.Users.FirstOrDefault(usr => usr.ID == WebSecurity.CurrentUserId);
foreach (webpages_Roles role in user.webpages_Roles)
{
foreach (SIGEC.Models.Action action in role.Actions)
{
if (!Menu.ContainsKey(
string.Format("{0}-{1}", action.Menu.name.Replace("Controller", ""),
action.name)
))
{
Menu.Add(
string.Format("{0}-{1}", action.Menu.name.Replace("Controller", ""), action.name),
action.name
);
}
}
}
}
}
catch
{
new AuthorizationContext().Result = new RedirectToRouteResult(
new RouteValueDictionary
{
{ "controller", "Account" },
{ "action", "Login" }
});
}
}
/// <summary>
/// Metodo utilizado para inicializar la configuración del
/// plugin WebSecurity, y la inicialización de la conexión
/// de la base de datos, tomando en cuenta la tabla de la
/// base de datos que almacenará los datos de los usuarios
/// de la aplicación. También en este método se insertan los
/// datos por defecto requeridos para el mínimo funcionamiento
/// de la aplicación, tales como roles y un usuario por defecto.
/// </summary>
public static void RegisterWebSec()
{
///inizializar el websecurity, especificando la tabla
///que guardará los datos básicos de usuario.
WebSecurity.InitializeDatabaseConnection
(
"SIGECContext",
"Users",
"ID",
"username",
autoCreateTables: true
);
///creación de la cuenta por defecto de administrador.
if (!WebSecurity.UserExists("admin"))
{
using (SIGECContext db = new SIGECContext())
{
Address a = new Address();
a.city = "Ciudad";
a.municipality = "Municipio";
a.sector = "Sector";
a.street = "Calle";
a.number = "Numero";
a.country = "Republica Dominicana";
var passwordHelper = new PasswordHelper();
passwordHelper.HashPassword("123456");
db.Addresses.Add(a);
var user = new User();
user.username = "******";
user.password = PWDTK.HashBytesToHexString(passwordHelper.Hash);
user.salt = PWDTK.HashBytesToHexString(passwordHelper.Salt);
user.bornDate = DateTime.Now;
user.createDate = DateTime.Now;
user.email = "*****@*****.**";
user.status = true;
user.gender = "M";
user.maritalStatus = "S";
user.dni = "00000000000";
user.firstName = "admin";
user.lastName = "istrador";
user.occupation = "Super Admin";
db.Users.Add(user);
user.Address = a;
db.SaveChanges();
}
}
var roles = (SimpleRoleProvider)Roles.Provider;
if (!roles.RoleExists("Admin"))
{
roles.CreateRole("Admin");
}
if (!roles.GetRolesForUser("admin").Contains("Admin"))
{
roles.AddUsersToRoles(new[] { "admin" }, new[] { "Admin" });
}
///insertar datos de menús y acciones en la base de datos
///para el manejo de permisos.
//GlobalHelpers.InsertMenusAndActions();
///asignar permisos sobre todas las acciones al rol Admin
using (var db = new SIGECContext())
{
var adminRole = db.webpages_Roles.FirstOrDefault(r => r.RoleName == "Admin");
foreach (SIGEC.Models.Action a in db.Actions)
{
if (!adminRole.Actions.Contains(a))
{
adminRole.Actions.Add(a);
}
}
db.Entry(adminRole).State = System.Data.EntityState.Modified;
db.SaveChanges();
}
}
/// <summary>
/// Metodo utilizado para almacenar los nombres de los controladores
/// y sus acciones asociadas en la base de datos.
/// </summary>
public static void InsertMenusAndActions()
{
MenuActionProvider cp = new MenuActionProvider();
bool insertNew = false;
using (SIGECContext db = new SIGECContext())
{
foreach (string controllerName in cp.GetControllerNames())
{
Menu m = db.Menus.FirstOrDefault(t => t.name == controllerName);
if (m == null)
{
insertNew = true;
m = new Menu();
m.name = controllerName;
}
List <SIGEC.Models.Action> actions = new List <SIGEC.Models.Action>();
string[] lstActions = cp.GetActionNames(controllerName).Distinct().ToArray();
foreach (string action in lstActions)
{
SIGEC.Models.Action a = new SIGEC.Models.Action();
a.name = action;
actions.Add(a);
}
if (insertNew)
{
m.Actions = actions;
}
else
{
foreach (SIGEC.Models.Action a in actions)
{
if (!m.Actions.Contains(a, new Compare <SIGEC.Models.Action>((r, l) => r.name == l.name)))
{
m.Actions.Add(a);
}
}
}
if (db.Menus.FirstOrDefault(con => con.name == controllerName) == null)
{
db.Menus.Add(m);
}
try
{
if (insertNew)
{
db.SaveChanges();
}
else
{
db.Entry(m).State = System.Data.EntityState.Modified;
db.SaveChanges();
}
}
catch (Exception ex)
{
Console.Error.WriteLine(ex.InnerException.ToString());
}
insertNew = false;
}
}
}
