AuthorizeMultipleAttribute

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using Houseman.Erp.App_Start;
using Houseman.Model.Dao.Enums;
using Houseman.Model.Dto;
using Houseman.Service.Service;


namespace Houseman.Erp.Filters
{
    public class AuthorizeMultipleAttribute : AuthorizeAttribute
    {
        public string MultipleRoles { get; set; }
        public UserDto User { get; set; }
        public string Action { get; set; }
        public ContextEnum Context { get; set; }
        public static RoleService roleService;
        public static UserService userService;
        public static RoleRightService roleRightService;
        public static List<UserDto> allUser;
        public static List<RoleDto> allRole;
        public static List<RoleRightDto> allRoleRights;
        public static int FlagInit = 0;


        public AuthorizeMultipleAttribute()
        {
            if(FlagInit==0)
            {
                Init();
            }
        }

        public static void Init()
        {
            roleService = StructuremapMvc.StructureMapDependencyScope.Container.GetInstance<RoleService>();
            userService = StructuremapMvc.StructureMapDependencyScope.Container.GetInstance<UserService>();
            roleRightService = StructuremapMvc.StructureMapDependencyScope.Container.GetInstance<RoleRightService>();
            allUser = userService.GetAll().ToList();
            allRole = roleService.GetAll().ToList();
            allRoleRights = roleRightService.GetAll().ToList();
            FlagInit = 1;
        }


        protected override bool AuthorizeCore(HttpContextBase httpContext)
        {

            var isAuthorized = base.AuthorizeCore(httpContext);
            if (Action.Equals("First"))
            {
                if (allRole.Any())
                    return isAuthorized;
            }
            if (Action.Equals("FirstUser"))
            {
                if (allUser.Any())
                    return isAuthorized;
            }


            if (!isAuthorized)
            {
                if (!allRole.Any())
                {
                    return true;
                }
                if (!allUser.Any())
                {
                    return true;
                }
                return false;
            }

            var roleRights =allRoleRights.Where(roleRightDto => roleRightDto.Role.Id == User.Role.Id).Where(roleRightDto => roleRightDto.Context.Equals(Context));
            foreach (var roleRightDto in roleRights)
            {
                switch (Action)
                {
                    case "View":
                        return roleRightDto.View;
                    case "Create":
                        return roleRightDto.Create;
                    case "Update":
                        return roleRightDto.Update;
                    case "Delete":
                        return roleRightDto.Delete;
                }
            }

            return false;
        }


        public override void OnAuthorization(AuthorizationContext filterContext)
        {
            if (!Action.Equals("First") && allRole.Any() && !Action.Equals("FirstUser") && allUser.Any())
            {
                if (filterContext.HttpContext.User.Identity.Name.Equals(""))
                {
                    filterContext.Result =
                        new RedirectResult("/Home/Index");
                }
                else
                {
                    var username = filterContext.HttpContext.User.Identity.Name;
                    User = allUser.First(x => x.Username.Equals(username));
                }
            }

            if (!AuthorizeCore(filterContext.HttpContext))
            {

                if (!allRole.Any())
                {
                    base.OnAuthorization(filterContext);
                }

                if (! allUser.Any())
                {
                    base.OnAuthorization(filterContext);
                }
                filterContext.Result = filterContext.HttpContext.User.Identity.Name.Equals("") ? new RedirectResult("/Account/Login") : new RedirectResult("/Home/Index");
            }

            else
            {
                base.OnAuthorization(filterContext);
            }
        }
    }
}