Sic.Framework-Nanjing-Baishi/MECF.Framework.UI.Client/CenterViews/Configs/Roles/RoleManager.cs

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using Aitex.Core.RT.Log;
using Aitex.Core.Util;
using MECF.Framework.Common.Account;
using MECF.Framework.Common.Account.Extends;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.UI.Client.CenterViews.Editors;
using MECF.Framework.UI.Client.ClientBase;
using MECF.Framework.UI.Client.RecipeEditorLib.RecipeModel;
using MECF.Framework.UI.Core.Accounts;
using OpenSEMI.ClientBase;

namespace MECF.Framework.UI.Client.CenterViews.Configs.Roles
{
    public class RoleManager : Singleton<RoleManager>
    {
        #region Variables

        private List<AppMenu> _appMenuPermSource;
        private List<PermissionControlItem> _recipeColumnPermSource;
        private List<PermissionControlItem> _recipeStepPermSource;
        private List<PermissionControlItem> _contentPermSource;
        
        private readonly RecipeFormatBuilder _recipeBuilder = new();
        private readonly ObservableCollection<RoleItem> _roleContainer = new();

        #endregion

        #region Properties

        public ObservableCollection<string> ChamberType { get; set; }

        public ObservableCollection<ProcessTypeFileItem> ProcessTypeFileList { get; set; }

        #endregion

        #region Methods

        public bool Initialize()
        {
            _roleContainer.Clear();
            var roles = RoleAccountProvider.Instance.GetRoles();
            if (roles == null)
            {
                LOG.Error("GetRoles method failed,in RoleManager");
                return false;
            }

            var menus = AccountClient.Instance.Service.GetAllMenus();
            _appMenuPermSource = menus;
            if (menus == null)
            {
                LOG.Error("GetMenus method failed,in RoleManager");
                return false;
            }

            //每个Role下再挂一个Recipe权限
            //Recipe名称从RecipeFormat文件中获取
            var chamberType = QueryDataClient.Instance.Service.GetConfig("System.Recipe.SupportedChamberType");
            if (chamberType == null)
            {
                ChamberType = new ObservableCollection<string>() { "Default" };
            }
            else
            {
                ChamberType = new ObservableCollection<string>(((string)(chamberType)).Split(','));
            }

            var processType = QueryDataClient.Instance.Service.GetConfig("System.Recipe.SupportedProcessType");
            if (processType == null)
            {
                processType = "Process,Routine";
            }

            ProcessTypeFileList = new ObservableCollection<ProcessTypeFileItem>();
            var recipeProcessType = ((string)processType).Split(',');

            _recipeColumnPermSource = _recipeBuilder.GetRecipeColumnPermSource($"{ChamberType[0]}\\{recipeProcessType[0]}", "PM1");
            _recipeStepPermSource = _recipeBuilder.GetRecipeStepPermSource();
            _contentPermSource = _recipeBuilder.GetContentPermSource($"{ChamberType[0]}\\Content", "PM1");

            // 根据系统中已存在的角色创建Role编辑器左侧的树状列表。
            foreach (var role in roles)
            {
                var ri = new RoleItem(role);
                var headerPerm = RolePermissionMapper.FromMenuPermissionEnum(role.PermissionControlItems["Header"]);
                var mp = new PermissionControlItem("Header", headerPerm, "Header");
                
                ri.AddMenuInfo(mp);

                //Get Menu information
                foreach (var topMenuItem in menus)
                {
                    foreach (var subMenuItem in topMenuItem.MenuItems)
                    {
                        var appName = topMenuItem.ResKey + "." + subMenuItem.ResKey;
                        var id = subMenuItem.MenuID;
                        var appPerm = RolePermissionMapper.FromMenuPermissionEnum(
                            role.GetPermission(id));
                        var perm = new PermissionControlItem(appName, appPerm, id);
                        ri.AddMenuInfo(perm);
                    }
                }

                foreach (var recipeInfo in _recipeColumnPermSource)
                {
                    var recipePerm = RolePermissionMapper.FromMenuPermissionEnum(
                        role.GetPermission(recipeInfo.Name));
                    var perm = new PermissionControlItem(recipeInfo.Name, recipePerm);
                    ri.AddRecipeInfo(perm);
                }

                foreach (var stepInfo in _recipeStepPermSource)
                {
                    var stepPerm = RolePermissionMapper.FromMenuPermissionEnum(
                        role.GetPermission(stepInfo.Name));
                    var perm = new PermissionControlItem(stepInfo.Name, stepPerm);
                    ri.AddStepInfo(perm);
                }

                foreach (var contentInfo in _contentPermSource)
                {
                    var contentPerm = RolePermissionTrueFalseMapper.FromMenuPermissionEnum(
                        role.GetPermission(contentInfo.Name));
                    var perm = new PermissionControlItem(contentInfo.Name, contentPerm, description:contentInfo.Description);
                    
                    ri.AddContentInfo(perm);
                }

                _roleContainer.Add(ri);
            }
            return true;
        }
        
        /// <summary>
        /// 返回包含所有角色的列表。
        /// </summary>
        /// <returns></returns>
        public List<RoleItem> GetAllRoles()
        {
            return _roleContainer.ToList();
        }

        /// <summary>
        /// 新建角色。
        /// </summary>
        /// <param name="ri"></param>
        /// <param name="reason">新增角色失败的原因。</param>
        /// <returns></returns>
        public bool AddRole(RoleItem ri, out string reason)
        {
            reason = "";
            var existRole = FindRoleByName(ri.RoleName);
            if (existRole != null)
            {
                reason = $"the role name {ri.RoleName} already exists in RoleManager";
                LOG.Info($"Add Role failed, {reason}");
                return false;
            }
            existRole = FindRoleByID(ri.RoleId);
            if (existRole != null)
            {
                reason = $"the role ID {ri.RoleId} already exists in RoleManager";
                LOG.Info($"Add Role failed, {reason}");
                return false;
            }
            
            _roleContainer.Add(ri);

            return true;
        }
        
        /// <summary>
        ///  创建角色ID。
        /// </summary>
        /// <returns></returns>
        public string GenerateRoleID()
        {
            // 0 -  3为系统保留ID
            var roleId = 4;
            var ri = FindRoleByID(roleId.ToString());
            while (ri != null)
            {
                roleId++;
                ri = FindRoleByID(roleId.ToString());
            }

            return roleId.ToString();
        }
        
        /// <summary>
        /// 查找指定ID的角色。
        /// </summary>
        /// <param name="ID"></param>
        /// <returns></returns>
        public RoleItem FindRoleByID(string ID)
        {
            return _roleContainer.FirstOrDefault(t => t.RoleId == ID);
        }

        /// <summary>
        /// 查找指定名称的角色。
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        public RoleItem FindRoleByName(string name)
        {
            return _roleContainer.FirstOrDefault(t => t.RoleName == name);
        }
        
        public RoleItem CreateRole()
        {
            var r = new RoleItem(GenerateRoleID());

            r.DisplayRoleName = r.RoleName = string.Empty;
            r.DisplayAutoLogoutTime = r.AutoLogoutTime = 10;
            r.DisplayIsAutoLogout = r.IsAutoLogout = false;
            r.DisplayDescription = r.Description = string.Empty;

            r.MenuPermCollection.Add(new PermissionControlItem( "Header", RolePermissionMapper.None, "Header"));

            foreach (var topMenuItem in _appMenuPermSource)
            {
                foreach (var subMenuItem in topMenuItem.MenuItems)
                {
                    var mp = new PermissionControlItem(topMenuItem.ResKey + "." + subMenuItem.ResKey,
                        RolePermissionMapper.None, subMenuItem.MenuID);
                    r.MenuPermCollection.Add(mp);
                }
            }

            foreach (var perm in _recipeColumnPermSource)
            {
                var recipe = new PermissionControlItem(perm.Name, RolePermissionMapper.None, perm.Name, perm.Description);
                r.AddRecipeInfo(recipe);
            }

            foreach (var perm in _recipeStepPermSource)
            {
                var step = new PermissionControlItem(perm.Name, RolePermissionMapper.None, perm.Name, perm.Description);
                r.AddStepInfo(step);
            }

            foreach (var perm in _contentPermSource)
            {
                var permission = new PermissionControlItem(perm.Name, RolePermissionTrueFalseMapper.No, perm.Name, perm.Description);
                r.AddContentInfo(permission);
            }

            return r;
        }

        public RoleItem CreateRole(RoleItem role)
        {
            var newRole = new RoleItem(GenerateRoleID())
            {
                RoleName = role.RoleName,
                AutoLogoutTime = role.AutoLogoutTime,
                IsAutoLogout = role.IsAutoLogout,
                Description = role.Description,
                DisplayRoleName = role.DisplayRoleName,
                DisplayAutoLogoutTime = role.DisplayAutoLogoutTime,
                DisplayIsAutoLogout = role.DisplayIsAutoLogout,
                DisplayDescription = role.DisplayDescription
            };

            foreach (var mInfo in role.MenuPermCollection)
            {
                newRole.AddMenuInfo((PermissionControlItem)mInfo.Clone());
            }

            foreach (var rInfo in role.RecipePermCollection)
            {
                newRole.AddRecipeInfo((PermissionControlItem)rInfo.Clone());
            }

            foreach (var sInfo in role.RecipeStepPermCollection)
            {
                newRole.AddStepInfo((PermissionControlItem)sInfo.Clone());
            }

            foreach (var pInfo in role.ContentPermCollection)
            {
                newRole.AddContentInfo((PermissionControlItem)pInfo.Clone());
            }

            return newRole;
        }

        public RoleItem CloneRole(RoleItem ri)
        {
            var newRole = new RoleItem(ri.RoleId)
            {
                RoleName = ri.RoleName,
                AutoLogoutTime = ri.AutoLogoutTime,
                IsAutoLogout = ri.IsAutoLogout,
                Description = ri.Description,
                DisplayRoleName = ri.DisplayRoleName,
                DisplayAutoLogoutTime = ri.DisplayAutoLogoutTime,
                DisplayIsAutoLogout = ri.DisplayIsAutoLogout,
                DisplayDescription = ri.DisplayDescription
            };

            foreach (var mInfo in ri.MenuPermCollection)
            {
                newRole.AddMenuInfo((PermissionControlItem)mInfo.Clone());
            }

            foreach (var rInfo in ri.RecipePermCollection)
            {
                newRole.AddRecipeInfo((PermissionControlItem)rInfo.Clone());
            }

            foreach (var sInfo in ri.RecipeStepPermCollection)
            {
                newRole.AddStepInfo((PermissionControlItem)sInfo.Clone());
            }

            foreach (var pInfo in ri.ContentPermCollection)
            {
                newRole.AddContentInfo((PermissionControlItem)pInfo.Clone());
            }

            return newRole;
        }

        public bool CheckAvailable(RoleItem ri)
        {
            if (ri == null)
                return false;

            foreach (var r in _roleContainer)
            {
                if (ri.RoleName == r.RoleName && ri.RoleId != r.RoleId)
                {
                    LOG.Info("Check account available fail because the name already exists, in RoleManager");
                    return false;
                }
            }

            return true;
        }

        public bool SaveRole(RoleItem ri)
        {
            if (!CheckAvailable(ri))
                return false;

            var role = new Role(
                ri.RoleId,
                ri.RoleName,
                ri.IsAutoLogout,
                ri.AutoLogoutTime,
                PermissionHelper.PermissionToDictionary(ri.MenuPermCollection, ri.RecipePermCollection,
                ri.ContentPermCollection,ri.RecipeStepPermCollection),
                ri.Role.IsBuildIn,
                ri.Description
                );

            if (RoleAccountProvider.Instance.UpdateRole(role))
            {
                if (null == FindRoleByID(ri.RoleId))
                {
                    // 如果是新建角色
                    var newRole = CloneRole(ri);
                    var ret = AddRole(newRole, out var reason);
                    if (!ret)
                        DialogBox.ShowError($"Add Role failed, {reason}");
                    return ret;
                }
                else
                {
                    // 刷新当前RoleItem，将保存状态置为已保存。
                    ri.RoleName = ri.RoleName;
                    ri.IsAutoLogout = ri.IsAutoLogout;
                    ri.AutoLogoutTime = ri.AutoLogoutTime;
                    ri.IsBuildIn = ri.IsBuildIn;
                    ri.Description = ri.Description;
                
                    foreach (var perm in ri.MenuPermCollection)
                        perm.Update();

                    foreach (var perm in ri.RecipePermCollection)
                        perm.Update();
                
                    foreach (var perm in ri.RecipeStepPermCollection)
                        perm.Update();
                
                    foreach (var perm in ri.ContentPermCollection)
                        perm.Update();
                }
            }
            else
            {
                LOG.Error("UpdateRoles method failed, in RoleManager");
                return false;
            }

            return true;
        }

        public bool DeleteRole(string strRoleID)
        {
            var r = FindRoleByID(strRoleID);
            if (r != null)
            {
                if (RoleAccountProvider.Instance.DeleteRole(strRoleID))
                {
                    _roleContainer.Remove(r);
                    return true;
                }
                else
                {
                    LOG.Error("DeleteRole method failed, in RoleManager");
                }
            }
            else
            {
                LOG.Warning("Can not find the role to delete, in RoleManager");
            }

            return false;
        }
        
                
        #endregion
        
    }
}