Roles and Add,Edit,Delete Rights in .NET MVC

I provide you two reference bellow

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
namespace Filters.Infrastructure {
public class CustomAuthAttribute: AuthorizeAttribute {
private bool localAllowed;
public CustomAuthAttribute(bool allowedParam) {
localAllowed = allowedParam;
}
protected override bool AuthorizeCore(HttpContextBase httpContext) {
if (httpContext.Request.IsLocal) {
return localAllowed;
} else {
return true;
}
}
}
}
public class CustomAuthAttribute: AuthorizeAttribute {
public override void OnAuthorization(AuthorizationContext filterContext) {
base.OnAuthorization(filterContext);
//your code here
}
}
[Authorize(Roles = "Administrators")]
public class ValuesController: ApiController {}
namespace MvcApplication.HowTo.Enums {
public enum Role {
Administrator = 1,
UserWithPrivileges = 2,
User = 3,
}
}
using System;
using System.Linq;
using System.Web.Mvc;
namespace MvcApplication.HowTo.Attributes {
[AttributeUsage(AttributeTargets.Method | AttributeTargets.Class, Inherited = true, AllowMultiple = true)]
public class AuthorizeEnumAttribute: AuthorizeAttribute {
public AuthorizeEnumAttribute(params object[] roles) {
if (roles.Any(r => r.GetType().BaseType != typeof(Enum)))
throw new ArgumentException("roles");
this.Roles = string.Join(",", roles.Select(r => Enum.GetName(r.GetType(), r)));
}
}
}
[AuthorizeEnum(Role.Administrator, Role.UserWithPrivileges)]
public ActionResult ThePrivilegeZone() {
return View();
}
[Flags]
public enum Roles {
Guest = 0,
Editor = 1,
Author = 2,
Administrator = 4
}
public static class EnumExtensions {
private static void IsEnumWithFlags < T > () {
if (!typeof(T).IsEnum)
throw new ArgumentException(string.Format("Type '{0}' is not an enum", typeof(T).FullName));
if (!Attribute.IsDefined(typeof(T), typeof(FlagsAttribute)))
throw new ArgumentException(string.Format("Type '{0}' doesn't have the 'Flags' attribute", typeof(T).FullName));
}
public static IEnumerable < T > GetFlags < T > (this T value) where T: struct {
IsEnumWithFlags < T > ();
return from flag in Enum.GetValues(typeof(T)).Cast < T > () let lValue = Convert.ToInt64(value) let lFlag = Convert.ToInt64(flag) where(lValue & lFlag) != 0 select flag;
}
}
public class AuthorizationService: IAuthorizationService {
// Convert role strings into a Roles enum flags using the additive "|" (OR) operand.
public Roles AggregateRoles(IEnumerable < string > roles) {
return roles.Aggregate(Roles.Guest, (current, role) => current | (Roles) Enum.Parse(typeof(Roles), role));
}
// Checks if a user's roles contains Administrator role.
public bool IsAdministrator(Roles userRoles) {
return userRoles.HasFlag(Roles.Administrator);
}
// Checks if user has ANY of the allowed role flags.
public bool IsUserInAnyRoles(Roles userRoles, Roles allowedRoles) {
var flags = allowedRoles.GetFlags();
return flags.Any(flag => userRoles.HasFlag(flag));
}
// Checks if user has ALL required role flags.
public bool IsUserInAllRoles(Roles userRoles, Roles requiredRoles) {
return ((userRoles & requiredRoles) == requiredRoles);
}
// Validate authorization
public bool IsAuthorized(UserSessionInfoViewModel user, Roles roles) {
// convert comma delimited roles to enum flags, and check privileges.
var userRoles = AggregateRoles(user.Roles);
return IsAdministrator(userRoles) || IsUserInAnyRoles(userRoles, roles);
}
}
public class AuthorizationFilter: IAuthorizationFilter {
private readonly IAuthorizationService _authorizationService;
private readonly Roles _authorizedRoles;
///
/// Constructor
///
/// The AuthorizedRolesAttribute is used on actions and designates the
/// required roles. Using dependency injection we inject the service, as well
/// as the attribute's constructor argument (Roles).
public AuthorizationFilter(IAuthorizationService authorizationService, Roles authorizedRoles) {
_authorizationService = authorizationService;
_authorizedRoles = authorizedRoles;
}
///
/// Uses injected authorization service to determine if the session user
/// has necessary role privileges.
///
/// As authorization code runs at the action level, after the
/// caching module, our authorization code is hooked into the caching
/// mechanics, to ensure unauthorized users are not served up a
/// prior-authorized page.
/// Note: Special thanks to TheCloudlessSky on StackOverflow.
///
public void OnAuthorization(AuthorizationContext filterContext) {
// User must be authenticated and Session not be null
if (!filterContext.HttpContext.User.Identity.IsAuthenticated || filterContext.HttpContext.Session == null)
HandleUnauthorizedRequest(filterContext);
else {
// if authorized, handle cache validation
if (_authorizationService.IsAuthorized((UserSessionInfoViewModel) filterContext.HttpContext.Session["user"], _authorizedRoles)) {
var cache = filterContext.HttpContext.Response.Cache;
cache.SetProxyMaxAge(new TimeSpan(0));
cache.AddValidationCallback((HttpContext context, object o, ref HttpValidationStatus status) => AuthorizeCache(context), null);
} else
HandleUnauthorizedRequest(filterContext);
}
}
https: //scotch.io/@ethanmillar/user-role-based-dynamic-navigation-from-sql-database-entity-framework-in-mvc318
private async Task CreateRoles(IServiceProvider serviceProvider) {
//adding custom roles
var RoleManager = serviceProvider.GetRequiredService < RoleManager < IdentityRole >> ();
var UserManager = serviceProvider.GetRequiredService < UserManager < ApplicationUser >> ();
string[] roleNames = {
"Admin",
"Manager",
"Member"
};
IdentityResult roleResult; ?
foreach(var roleName in roleNames) {
//creating the roles and seeding them to the database
var roleExist = await RoleManager.RoleExistsAsync(roleName);
if (!roleExist) {
roleResult = await RoleManager.CreateAsync(new IdentityRole(roleName));
}
} ?
//creating a super user who could maintain the web app
var poweruser = new ApplicationUser {
UserName = Configuration.GetSection("UserSettings")["UserEmail"],
Email = Configuration.GetSection("UserSettings")["UserEmail"]
}; ?
string UserPassword = Configuration.GetSection("UserSettings")["UserPassword"];
var _user = await UserManager.FindByEmailAsync(Configuration.GetSection("UserSettings")["UserEmail"]); ?
if (_user == null) {
var createPowerUser = await UserManager.CreateAsync(poweruser, UserPassword);
if (createPowerUser.Succeeded) {
//here we tie the new user to the "Admin" role
await UserManager.AddToRoleAsync(poweruser, "Admin"); ?
}
}
}
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory, IServiceProvider serviceProvider) {
loggerFactory.AddConsole(Configuration.GetSection("Logging"));
loggerFactory.AddDebug();
app.UseStaticFiles(); ?
app.UseIdentity();
app.UseMvc(routes => {
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});
CreateRoles(serviceProvider).Wait();
}

1 Reply

Know the answer? Post it — somebody with the same question will find it here.

Laxmidhar Sahoo6y ago
Hi
I provide you two reference bellow
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
namespace Filters.Infrastructure {
public class CustomAuthAttribute: AuthorizeAttribute {
  private bool localAllowed;
  public CustomAuthAttribute(bool allowedParam) {
   localAllowed = allowedParam;
  }
  protected override bool AuthorizeCore(HttpContextBase httpContext) {
   if (httpContext.Request.IsLocal) {
    return localAllowed;
   } else {
    return true;
   }
  }
}
}



public class CustomAuthAttribute: AuthorizeAttribute {
public override void OnAuthorization(AuthorizationContext filterContext) {
  base.OnAuthorization(filterContext);

  //your code here
}
}




[Authorize(Roles = "Administrators")]
public class ValuesController: ApiController {}





namespace MvcApplication.HowTo.Enums {
public enum Role {
  Administrator = 1,
   UserWithPrivileges = 2,
   User = 3,
}
}



using System;
using System.Linq;
using System.Web.Mvc;

namespace MvcApplication.HowTo.Attributes {
[AttributeUsage(AttributeTargets.Method | AttributeTargets.Class, Inherited = true, AllowMultiple = true)]
public class AuthorizeEnumAttribute: AuthorizeAttribute {
  public AuthorizeEnumAttribute(params object[] roles) {
   if (roles.Any(r => r.GetType().BaseType != typeof(Enum)))
    throw new ArgumentException("roles");

   this.Roles = string.Join(",", roles.Select(r => Enum.GetName(r.GetType(), r)));
  }
}
}




[AuthorizeEnum(Role.Administrator, Role.UserWithPrivileges)]
public ActionResult ThePrivilegeZone() {
return View();
}




[Flags]
public enum Roles {
Guest = 0,
  Editor = 1,
  Author = 2,
  Administrator = 4
}


public static class EnumExtensions {
private static void IsEnumWithFlags < T > () {
  if (!typeof(T).IsEnum)
   throw new ArgumentException(string.Format("Type '{0}' is not an enum", typeof(T).FullName));
  if (!Attribute.IsDefined(typeof(T), typeof(FlagsAttribute)))
   throw new ArgumentException(string.Format("Type '{0}' doesn't have the 'Flags' attribute", typeof(T).FullName));
}

public static IEnumerable < T > GetFlags < T > (this T value) where T: struct {
  IsEnumWithFlags < T > ();
  return from flag in Enum.GetValues(typeof(T)).Cast < T > () let lValue = Convert.ToInt64(value) let lFlag = Convert.ToInt64(flag) where(lValue & lFlag) != 0 select flag;
}
}



public class AuthorizationService: IAuthorizationService {
// Convert role strings into a Roles enum flags using the additive "|" (OR) operand.
public Roles AggregateRoles(IEnumerable < string > roles) {
  return roles.Aggregate(Roles.Guest, (current, role) => current | (Roles) Enum.Parse(typeof(Roles), role));
}

// Checks if a user's roles contains Administrator role.
public bool IsAdministrator(Roles userRoles) {
  return userRoles.HasFlag(Roles.Administrator);
}

// Checks if user has ANY of the allowed role flags.
public bool IsUserInAnyRoles(Roles userRoles, Roles allowedRoles) {
  var flags = allowedRoles.GetFlags();
  return flags.Any(flag => userRoles.HasFlag(flag));
}

// Checks if user has ALL required role flags.
public bool IsUserInAllRoles(Roles userRoles, Roles requiredRoles) {
  return ((userRoles & requiredRoles) == requiredRoles);
}

// Validate authorization
public bool IsAuthorized(UserSessionInfoViewModel user, Roles roles) {
  // convert comma delimited roles to enum flags, and check privileges.
  var userRoles = AggregateRoles(user.Roles);
  return IsAdministrator(userRoles) || IsUserInAnyRoles(userRoles, roles);
}
}




public class AuthorizationFilter: IAuthorizationFilter {
  private readonly IAuthorizationService _authorizationService;
  private readonly Roles _authorizedRoles;

  ///

  /// Constructor
  ///
  /// The AuthorizedRolesAttribute is used on actions and designates the
  /// required roles. Using dependency injection we inject the service, as well
  /// as the attribute's constructor argument (Roles).
  public AuthorizationFilter(IAuthorizationService authorizationService, Roles authorizedRoles) {
   _authorizationService = authorizationService;
   _authorizedRoles = authorizedRoles;
  }

  ///

  /// Uses injected authorization service to determine if the session user
  /// has necessary role privileges.
  ///
  /// As authorization code runs at the action level, after the
  /// caching module, our authorization code is hooked into the caching
  /// mechanics, to ensure unauthorized users are not served up a
  /// prior-authorized page.
  /// Note: Special thanks to TheCloudlessSky on StackOverflow.
  ///
  public void OnAuthorization(AuthorizationContext filterContext) {
   // User must be authenticated and Session not be null
   if (!filterContext.HttpContext.User.Identity.IsAuthenticated || filterContext.HttpContext.Session == null)
    HandleUnauthorizedRequest(filterContext);
   else {
    // if authorized, handle cache validation
    if (_authorizationService.IsAuthorized((UserSessionInfoViewModel) filterContext.HttpContext.Session["user"], _authorizedRoles)) {
     var cache = filterContext.HttpContext.Response.Cache;
     cache.SetProxyMaxAge(new TimeSpan(0));
     cache.AddValidationCallback((HttpContext context, object o, ref HttpValidationStatus status) => AuthorizeCache(context), null);
    } else
     HandleUnauthorizedRequest(filterContext);
   }
  }



  https: //scotch.io/@ethanmillar/user-role-based-dynamic-navigation-from-sql-database-entity-framework-in-mvc318





   private async Task CreateRoles(IServiceProvider serviceProvider) {
    //adding custom roles
    var RoleManager = serviceProvider.GetRequiredService < RoleManager < IdentityRole >> ();
    var UserManager = serviceProvider.GetRequiredService < UserManager < ApplicationUser >> ();
    string[] roleNames = {
     "Admin",
     "Manager",
     "Member"
    };
    IdentityResult roleResult; ?
    foreach(var roleName in roleNames) {
      //creating the roles and seeding them to the database
      var roleExist = await RoleManager.RoleExistsAsync(roleName);
      if (!roleExist) {
       roleResult = await RoleManager.CreateAsync(new IdentityRole(roleName));
      }
     } ?
     //creating a super user who could maintain the web app
     var poweruser = new ApplicationUser {
      UserName = Configuration.GetSection("UserSettings")["UserEmail"],
       Email = Configuration.GetSection("UserSettings")["UserEmail"]
     }; ?
    string UserPassword = Configuration.GetSection("UserSettings")["UserPassword"];
    var _user = await UserManager.FindByEmailAsync(Configuration.GetSection("UserSettings")["UserEmail"]); ?
    if (_user == null) {
     var createPowerUser = await UserManager.CreateAsync(poweruser, UserPassword);
     if (createPowerUser.Succeeded) {
      //here we tie the new user to the "Admin" role
      await UserManager.AddToRoleAsync(poweruser, "Admin"); ?
     }
    }
   }

  public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory, IServiceProvider serviceProvider) {
   loggerFactory.AddConsole(Configuration.GetSection("Logging"));
   loggerFactory.AddDebug();

   app.UseStaticFiles(); ?
   app.UseIdentity();
   app.UseMvc(routes => {
    routes.MapRoute(
     name: "default",
     template: "{controller=Home}/{action=Index}/{id?}");
   });
   CreateRoles(serviceProvider).Wait();
  }