IStation/Service.V4.1.git

using AutoMapper;
using IStation.Untity;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace IStation.Service
{
    /// <summary>
    /// 用户
    /// </summary>
    public partial class User
    {
        #region Cache
 
        private List<Model.User> GetCache()
        {
            return UserCacheHelper.GetSet(() =>
           {
               var dal = new DAL.User();
               var entity_list = dal.GetAll();
               var model_list = Entity2Models(entity_list);
               if (model_list == null)
               {
                   model_list = new List<Model.User>();
               }
               return model_list;
           }, ConfigHelper.KeepCacheTime, ConfigHelper.RandomCacheTime);
        }
 
        private void UpdateCache(long ID)
        {
            var dal = new DAL.User();
            var entity_rhs = dal.GetByID(ID);
            var model_rhs = Entity2Model(entity_rhs);
            var all = GetCache();
            var model = all.Find(x => x.ID == ID);
            if (model == null)
            {
                all.Add(model_rhs);
            }
            else
            {
                model.Reset(model_rhs);
            }
        }
 
        private void UpdateCache(List<long> Ids)
        {
            if (Ids == null || Ids.Count() < 1)
                return;
            var dal = new DAL.User();
            var entity_list = dal.GetByIds(Ids);
            var model_list = Entity2Models(entity_list);
            var all = GetCache();
            all.RemoveAll(x => Ids.Contains(x.ID));
            if (model_list != null && model_list.Count > 0)
            {
                all.AddRange(model_list);
            }
        }
 
        private void RemoveCache(long ID)
        {
            var all = GetCache();
            all.RemoveAll(x => x.ID == ID);
        }
 
        private void RemoveCache(List<long> Ids)
        {
            if (Ids == null || Ids.Count() < 1)
                return;
            var all = GetCache();
            all.RemoveAll(x => Ids.Contains(x.ID));
        }
 
        #endregion
 
        #region Query
 
        /// <summary>
        /// 获取所有
        /// </summary>
        public List<Model.User> GetAll()
        {
            var all = GetCache();
            return all.OrderBy(x => x.SortCode).ToList();
        }
 
        /// <summary>
        /// 通过 CorpID 获取
        /// </summary>
        public List<Model.User> GetByCorpID(long CorpID)
        {
            var all = GetAll();
            return all.Where(x => x.CorpID == CorpID).OrderBy(x => x.SortCode).ToList();
        }
 
        /// <summary>
        /// 通过 ID 获取
        /// </summary>
        public Model.User GetByID( long ID)
        {
            var all = GetAll();
            return all.Find(x => x.ID == ID);
        }
 
        /// <summary>
        /// 通过 Ids 获取
        /// </summary>
        public List<Model.User> GetByIds(List<long> Ids)
        {
            if (Ids == null || Ids.Count() < 1)
                return default;
            var all = GetAll();
            return all?.Where(x => Ids.Contains(x.ID)).OrderBy(x => x.SortCode).ToList();
        }
 
        /// <summary>
        /// 通过 CreateUserID 获取
        /// </summary>
        public List<Model.User> GetByCreateUserID(long CreateUserID)
        {
            var all = GetAll();
            return all.Where(x => x.CreateUserID == CreateUserID).OrderBy(x => x.SortCode).ToList();
        }
 
        /// <summary>
        /// 通过 Flag 获取
        /// </summary>
        public List<Model.User> GetByFlag(string Flag)
        {
            if (string.IsNullOrEmpty(Flag))
                return default;
            var all = GetAll();
            return all.Where(x => x.Flags != null && x.Flags.Contains(Flag)).ToList();
        }
 
        /// <summary>
        /// 通过 CorpID 和 Flag 获取
        /// </summary>
        public List<Model.User> GetByCorpIDAndFlag(long CorpID, string Flag)
        {
            if (string.IsNullOrEmpty(Flag))
                return default;
            var all = GetAll();
            return all.Where(x =>x.CorpID==CorpID&& x.Flags != null && x.Flags.Contains(Flag)).ToList();
        }
 
        /// <summary>
        /// 通过 LoginName 获取
        /// </summary>
        public Model.User GetByLoginName(string LoginName)
        {
            if (string.IsNullOrEmpty(LoginName))
                return default;
            var all = GetAll();
            return all.Find(x => x.LoginName?.ToLower() == LoginName.ToLower());
        }
 
        /// <summary>
        /// 获取子项
        /// </summary>
        public List<Model.User> GetChildrenByCreateUserID(long CreateUserID)
        {
            var all = GetAll();
            return FindChildrenByCreateUserID(CreateUserID, all)?.OrderBy(x=>x.SortCode).ToList();
        }
 
        /// <summary>
        /// 获取子项及自身
        /// </summary>
        public List<Model.User> GetChildAndSelfByCreateUserID(long CreateUserID)
        {
            var all = GetAll();
            var self = all.Find(x => x.ID == CreateUserID);
            if (self == null)
                return default;
            var vm_list = new List<Model.User>
            {
                self
            };
            var children = FindChildrenByCreateUserID(CreateUserID, all);
            if (children != null && children.Count > 0)
                vm_list.AddRange(children);
            return vm_list?.OrderBy(x=>x.SortCode).ToList();
        }
 
        // 寻找孩子
        private List<Model.User> FindChildrenByCreateUserID(long CreateUserID, List<Model.User> All)
        {
            var list = new List<Model.User>();
            var children = All?.Where(x => x.CreateUserID == CreateUserID).ToList();
            if (children != null && children.Count > 0)
            {
                foreach (var child in children)
                {
                    list.Add(child);
                    list.AddRange(FindChildrenByCreateUserID(child.ID, All));
                }
            }
            return list;
        }
 
        /// <summary>
        /// 是否有子项
        /// </summary>
        public bool HasChildren( long CreateUserID)
        {
            var all = GetAll();
            return all.Exists(x => x.CreateUserID == CreateUserID);
        }
 
        /// <summary>
        /// 验证上级使用状态
        /// </summary>
        public bool VerifyCreateUseStatus( long ID)
        {
            var all = GetAll();
            var user = all.Find(x => x.ID == ID);
            if (user == null)
                return false;
            return VerifyCreatetUseStatus(all, user);
        }
 
        //验证创建使用状态
        private bool VerifyCreatetUseStatus(List<Model.User> all, Model.User user)
        {
            var parent = all.Find(x => x.ID == user.CreateUserID);
            if (parent == null)
                return true;
            if (parent.UseStatus != Model.eUseStatus.Enable)
                return false;
            return VerifyCreatetUseStatus(all, parent);
        }
 
        /// <summary>
        /// 根据 Relation 判断是否存在
        /// </summary>
        public bool IsExistByRelation(long CorpID, string RelatedType, long RelatedID)
        {
            var all = GetAll();
            return all.Exists(x =>x.CorpID==CorpID&& x.RelatedType == RelatedType && x.RelatedID == RelatedID);
        }
 
        #endregion
 
        #region Insert
 
        /// <summary>
        /// 插入一条用户记录
        /// </summary>
        public long Insert(Model.User model)
        {
            if (model == null)
                return default;
            if (model.CreateUserID < 1)
                return default;
            if (model.RelatedID < 1)
                return default;
            var dal = new DAL.User();
            var entity = Model2Entity(model);
            if (string.IsNullOrEmpty(entity.LoginPwd))
            {
                entity.LoginPwd = ConfigHelper.DefaultLoginPwd;
            }
            var id = dal.Insert(entity);
            if (id > 0)
            {
                UpdateCache(id);
            }
            return id;
        }
 
        /// <summary>
        /// 批量插入
        /// </summary>
        public bool Inserts(List<Model.User> list)
        {
            if (list == null || list.Count() < 1)
                return default;
            var createUserIds = list.Select(x => x.CreateUserID).Distinct().ToList();
            if (createUserIds.Count != 1 || createUserIds[0] < 1)
                return default;
            if (list.ToList().Exists(x => x.RelatedID < 1))
                return default;
            var dal = new DAL.User();
            var entity_list = Model2Entities(list);
            foreach (var entity in entity_list)
            {
                if (string.IsNullOrEmpty(entity.LoginPwd))
                {
                    entity.LoginPwd = ConfigHelper.DefaultLoginPwd;
                }
            }
            var ids = dal.InsertsR(entity_list);
            if (ids != null && ids.Count > 0)
            {
                UpdateCache( ids);
                return true;
            }
            return default;
        }
 
        #endregion
 
        #region Update
 
        /// <summary>
        /// 更新一条
        /// </summary>
        public bool Update(Model.User model)
        {
            if (model == null)
                return default;
            if (model.ID < 1)
                return default;
            if (IsExistLoginNameExceptID(model.LoginName, model.ID))
                return default;
            var dal = new DAL.User();
            var entity = Model2Entity(model);
            var bol = dal.Update(entity);
            if (bol)
            {
                UpdateCache(model.ID);
            }
            return bol;
        }
 
        /// <summary>
        /// 批量更新
        /// </summary>
        public bool Updates(List<Model.User> list)
        {
            if (list == null || list.Count() < 1)
                return default;
            var loginName_list = list.Select(x => x.LoginName).Distinct().ToList();
            if (loginName_list.Count() != list.Count())
                return default;
            var id_list = list.Select(x => x.ID).Distinct().ToList();
            if (id_list.Count() != list.Count())
                return default;
            var user_list = GetAll();
            if (user_list == null || user_list.Count < 1)
                return default;
            if (user_list.Exists(x => (loginName_list.Contains(x.LoginName)) && (!id_list.Contains(x.ID))))
            {
                return default;
            }
 
            var dal = new DAL.User();
            var entity_list = Model2Entities(list);
            var bol = dal.Updates(entity_list);
            if (bol)
            {
                UpdateCache (id_list);
            }
            return bol;
        }
 
        /// <summary>
        /// 更新登录密码
        /// </summary>
        public bool UpdateLoginPwd(long ID, string LoginPwd,long UpdateUserID,DateTime UpdateTime)
        {
            if (ID < 1)
                return default;
            if (string.IsNullOrEmpty(LoginPwd))
                return default;
            var dal = new DAL.User();
            var bol = dal.UpdateLoginPwd( ID, LoginPwd,UpdateUserID,UpdateTime);
            if (bol)
            {
                UpdateCache( ID);
            }
            return bol;
        }
 
        /// <summary>
        /// 重置密码
        /// </summary>
        public bool ResetLoginPwd( long ID,long UpdateUserID,DateTime UpdateTime)
        {
            if (ID < 1)
                return default;
            return UpdateLoginPwd( ID, ConfigHelper.DefaultLoginPwd, UpdateUserID, UpdateTime);
        }
 
        /// <summary>
        /// 更新排序码
        /// </summary>
        public bool UpdateSortCode( long ID, int SortCode,long UpdateUserID,DateTime UpdateTime)
        {
            if (ID < 1)
                return default;
            var dal = new DAL.User();
            var bol = dal.UpdateSortCode(ID, SortCode, UpdateUserID,UpdateTime);
            if (bol)
            {
                UpdateCache(ID);
            }
            return bol;
        }
 
        /// <summary>
        /// 更新排序
        /// </summary>
        public bool UpdateSorter(List<Model.TraceSorter> sorters)
        {
            if (sorters == null || sorters.Count() < 1)
                return default;
            var dal = new DAL.User();
            var bol = dal.UpdateSorter(sorters.ToEntityList());
            if (bol)
            {
                UpdateCache( sorters.Select(x => x.ID).ToList());
            }
            return bol;
        }
 
        /// <summary>
        /// 更新使用状态
        /// </summary>
        public bool UpdateUseStatus(long ID, Model.eUseStatus UseStatus,long UpdateUserID,DateTime UpdateTime)
        {
            if (ID < 1)
                return default;
            var dal = new DAL.User();
            var bol = dal.UpdateUseStatus(ID, (int)UseStatus,UpdateUserID,UpdateTime);
            if (bol)
            {
                UpdateCache(ID);
            }
            return bol;
        }
 
        /// <summary>
        /// 更新最后一次登录
        /// </summary>
        public bool UpdateLastLogin(Model.UserLastLogin model)
        {
            if (model == null)
                return default;
            if (model.ID < 1)
                return default;
            var current = GetByID( model.ID);
            if (current == null)
                return default;
            var entity = Model2Entity(current);
            model.Map(entity);
            var dal = new DAL.User();
            var bol = dal.Update(entity);
            if (bol)
            {
                UpdateCache(model.ID);
            }
            return bol;
        }
 
        /// <summary>
        /// 更新TagName
        /// </summary>
        public bool UpdateTagName(long ID, string TagName,long UpdateUserID,DateTime UpdateTime)
        {
            var dal = new DAL.User();
            var bol = dal.UpdateTagName(ID, TagName,UpdateUserID,UpdateTime);
            if (bol)
            {
                UpdateCache(ID);
            }
            return bol;
        }
 
        #endregion
 
        #region LoginName
 
        /// <summary>
        /// 是否存在登录名
        /// </summary>
        public bool IsExistLoginName(string LoginName)
        {
            if (string.IsNullOrEmpty(LoginName))
                return default;
            var all = GetAll();
            return all.Exists(x => x.LoginName?.ToLower() == LoginName.ToLower());
        }
 
        /// <summary>
        /// 是否存在登录名
        /// </summary>
        public bool IsExistLoginNameExceptID( string LoginName, long ExceptID)
        {
            if (string.IsNullOrEmpty(LoginName))
                return default;
            var all = GetAll();
            return all.Exists(x => x.LoginName?.ToLower() == LoginName.ToLower() && x.ID != ExceptID);
        }
 
        #endregion
 
        #region Delete
 
        /// <summary>
        /// 通过 ID 删除
        /// </summary>
        public bool DeleteByID(long ID, out string Msg)
        {
            Msg = string.Empty;
            if (HasChildren(ID))
            {
                Msg = "包含子用户";
                return default;
            }
            if (new UserRoleMapping().IsExistByUserID(ID))
            {
                Msg = "已配置角色";
                return default;
            }
            if (new Role().IsExistByCreateUserID(ID))
            {
                Msg = "已创建角色";
                return default;
            }
            var dal = new DAL.User();
            var bol = dal.DeleteByID(ID);
            if (bol)
            {
                RemoveCache(ID);
                new UserAttention().RemoveCacheByUserID(ID);
            }
            return bol;
        }
 
        #endregion
 
 
    }
}