业务规则类库主要就是实现业务需求的功能类库。这些功能类库对应GUI界面操作的各个功能。比方菜单业务规则类MenuService实现接口IMenuService类的各个方法。

public interface IMenuService
    {
        void Create(Menu menu);//创建菜单项
        void Delete(Menu menu);//删除菜单项
        void Delete(int menuId);//通过ID删除菜单项
        void Update(Menu menuId);//更新菜单项
        List ListRoleMenu(User user);//列出角色的菜单
        List ListUserMenu(User user);//列出用户的菜单
        List ListMenu();//列出所有菜单
        Menu Get(int id);//通过ID获取菜单
        List GetRoleMenuIds(int roleId);//通过角色ID获取菜单
        List GetUserMenuIds(int UserId);//通过用户ID获取用户菜单
        List GetRoleMenuIds(User user);
        List GetMenuForNode();
        void CreateRoleMenu(RoleMenu rolemenu);//创建角色菜单
        void CreateUserMenu(UserMenu rolemenu);//创建用户菜单
        void DeleteRoleMenu(int menuId, int roleId);//删除角色菜单
        void DeleteUserMenu(int menuId, int UserId);//删除用户菜单
        bool HasRoleMenu(RoleMenu rolemenus);//包含角色菜单
        bool HasUserMenu(UserMenu rolemenus);//包含用户菜单
    }

菜单接口类定义了操作菜单、角色菜单、用户菜单三个表的方法。

public interface IUserService
    {

        User GetUserBySystemName(string systemName);
        User GetUserByUsername(string username);
        User GetUserByFullName(string fullname);
        User GetUserByEmail(string email);
        User GetUserByUserNameOrEmail(string usernameOrEmail);
        User ValidateUserPassword(string usernameOrEmail, string password,SysLang lang);
        void Create(User user);
        void Delete(int userId);
        void Update(User user);
        void Enable(int UserID,bool stopflag);
        void ChangePassword(User user,string newPassword);
        User GetById(int userId); 
        IPagedList ListUsers(int pageSize = 15, int pageIndex = 0);
        List ListUsers();
        List ListUsers(QueryDescriptor conddes);
        List ListUsersForRole(int roleId);
        List ListUsersNotInRole(int roleId);
        List ListUsersNotInRole(string UserName, string FullName, string Email, int RoleId);
        IPagedList Query(string keyword, int pageSize = 15, int pageIndex = 0);
        IList GetUserCanLoginModules(int langId, User curUser);
        List ListRoles(QueryDescriptor conddes);
        void AddMember(UserRole model);
        void DeleteMember(UserRole model);
    }

用户接口类定义了操作用户、用户角色表的方法

这两个接口的实现类MenuService,UserService类在我们的登录窗口、主窗口都会用到。

public class UserService : IUserService
    {
        private readonly IRepository _userRepository;
        private readonly IRepository _userroleRepository;
        private readonly IRepository _roleRepository;
        private readonly IEncryptionService _encryptionService;
        private readonly IStrResourceService _strresStrService;
        private readonly IEnumItemStrService _enumItemStrService;
        private readonly IEventPublisher _eventPublisher;
        private readonly IPublicService _pubService;
        private readonly IRelCustomerUserService _relcustuserService;
        public UserService(IRepository userRepository,
            IRepository roleRepository,
            IEncryptionService encryptionService,
            IEventPublisher eventPublisher,
            IRepository userroleRepository,
            IStrResourceService strresStrService,
            IEnumItemStrService enumItemStrService,
            IRelCustomerUserService relcustuserService,
            IPublicService pubService)
        {
            _userRepository = userRepository;
            _roleRepository = roleRepository;
            _encryptionService = encryptionService;
            _eventPublisher = eventPublisher;
            _userroleRepository = userroleRepository;
            _strresStrService = strresStrService;
            _enumItemStrService = enumItemStrService;
            _relcustuserService = relcustuserService;
            _pubService = pubService;
        }

        public void ChangePassword(User user, string newPassword)
        {

            user.LoginPassword = _encryptionService.CreatePasswordHash(newPassword, user.PasswordSalt);


            _userRepository.Update(user);
        }


        public void Create(User user)
        {
            if (_userRepository.Table.Where(e => e.Name == user.Name).Count() > 0)
            {
                throw new MPlatException("已存在该用户名");
            }
            if(_userRepository.Table.Where(e=>e.LoginName==user.LoginName).Count()>0)
            {
                throw new MPlatException("已存在该登录名");
            }
            if (user == null)
                throw new ArgumentNullException("user");

            user.UserID = _pubService.CRMGetNextID("User");

            _userRepository.Insert(user);

            _eventPublisher.EntityInserted(user);
        }


        public void Delete(int userId)
        {
            var userInDB = _userRepository.GetById(userId);
            if (userInDB == null)
            {
                throw new MPlatException("未找到用户"); 
            }
            var data = _relcustuserService.GetCustomersByUserId(userId);
            if(data.Count>0)
            {
                throw new MPlatException("用户已经使用不能删除");
            }
            var bret = _pubService.ObjectUsed(userInDB, "User");
            if(bret)
            {
                throw new MPlatException("用户已经使用不能删除");
            }
            if (!userInDB.IsDeleted)
            {
                _userRepository.Delete(userInDB);
                _eventPublisher.EntityDeleted(userInDB);
            }
        }

        public User GetById(int userId)
        {
            var userInDb = _userRepository.GetById(userId);
            return userInDb;
        }

        public User GetUserByEmail(string email)
        {
            if (string.IsNullOrWhiteSpace(email))
                return null;

            var query = from c in _userRepository.Table
                        where c.Email == email
                        select c;
            var user = query.FirstOrDefault();
            return user;
        }

        public User GetUserBySystemName(string systemName)
        {
            if (string.IsNullOrWhiteSpace(systemName))
                return null;

            var query = from c in _userRepository.Table
                        orderby c.UserID
                        where c.UserType == systemName
                        select c;
            var user = query.FirstOrDefault();
            return user;
        }

        public User GetUserByUsername(string username)
        {
            if (string.IsNullOrWhiteSpace(username))
                return null;

            var query = from c in _userRepository.Table
                        where c.LoginName == username
                        select c;
            var user = query.FirstOrDefault();
            return user;
        }
        public User GetUserByFullName(string fullname)
        {
            if (string.IsNullOrWhiteSpace(fullname))
                return null;

            var query = from c in _userRepository.Table
                        where c.Name == fullname
                        select c;
            var user = query.FirstOrDefault();
            return user;
        }
        public User GetUserByUserNameOrEmail(string usernameOrEmail)
        {
            if (string.IsNullOrWhiteSpace(usernameOrEmail))
                return null;

            var query = from c in _userRepository.Table
                        where c.LoginName == usernameOrEmail || c.Email == usernameOrEmail
                        select c;
            var user = query.FirstOrDefault();
            return user;

        }
        /// 

        /// 获取用户能登录的模块
        /// 
        /// 
        /// 
        /// 
        public IList GetUserCanLoginModules(int langId, User curUser)
        {
            var moditems = _enumItemStrService.GetEnumStrItem(langId, "User.CanLoginModules");
            var newModItems = moditems.ToList();
            var items = curUser.CanLoginModules.Split(',');
            foreach(var key in items)
            {
                foreach(var item in newModItems)
                {
                    if(item.EnumKey!=int.Parse(key))
                    {
                        moditems.Remove(item);
                    }
                }
            }
            return moditems;
        }

        public IPagedList ListUsers(int pageSize = 15, int pageIndex = 0)
        {
            var query = _userRepository.Table;
     
            return new PagedList(query, pageIndex, pageSize);
      
        }
        public List ListUsers()
        {
            var query = _userRepository.Table;

            return query.ToList();

        }
        public List ListUsers(QueryDescriptor conddes)
        {
            var filter = new Filter();
            conddes.GetFilter(filter);
            var query = _userRepository.Table.Where(filter);
            query = conddes.Page(query);
            var data = query.ToList();
            return data;

        }
        public List ListUsersForRole(int roleId)
        {
            var userIds = _userroleRepository.Table.Where(e=>e.RoleId == roleId).Select(x=>x.UserID).ToList();
            var query = _userRepository.Table.Where(r => userIds.Contains(r.UserID));

            return query.ToList();

        }
        public List ListUsersNotInRole(int roleId)
        {
            var userIds = _userroleRepository.Table.Where(e => e.RoleId == roleId).Select(x => x.UserID).ToList();
            var query = _userRepository.Table.Where(r => !userIds.Contains(r.UserID));            
            return query.ToList();

        }
       
        public List ListUsersNotInRole(string UserName, string FullName, string Email, int RoleId)
        {
            var userIds = _userroleRepository.Table.Where(e => e.RoleId == RoleId).Select(x => x.UserID).ToList();
            var query = _userRepository.Table.Where(r => !userIds.Contains(r.UserID));
            if (!string.IsNullOrEmpty(UserName))
            {
                query = query.Where(e => e.LoginName.Contains(UserName));
            }
            if (!string.IsNullOrEmpty(FullName))
            {
                query = query.Where(e => e.Name.Contains(FullName));
            }
            if (!string.IsNullOrEmpty(Email))
            {
                query = query.Where(e => e.Email.Contains(Email));
            }
            query = query.OrderByDescending(r => r.UserID);

            return query.ToList();

        }

       

        public IPagedList Query(string keyword, int pageSize = 15, int pageIndex = 0)
        {
            var query = _userRepository.Table.Where(r => !r.IsDeleted);
            if (!string.IsNullOrEmpty(keyword))
            {
                query = query.Where(e=>e.Name.Contains(keyword)||e.Email.Contains(keyword));
            }
            query = query.OrderBy(e=>e.UserID);
            return new PagedList(query, pageIndex, pageSize);
        }

    

        public void Update(User user)
        {
            _userRepository.Update(user);
            _eventPublisher.EntityUpdated(user);
        }
        public void Enable(int UserID,bool stopflag)
        {
            var user = this.GetById(UserID);
            user.StopFlag = stopflag;
            this.Update(user);
        }
        public User ValidateUserPassword(string usernameOrEmail, string password,SysLang lang)
        {
            var user = GetUserByUserNameOrEmail(usernameOrEmail);
            if (user == null || user.IsDeleted)
            {
                var ERR_USER_NOT_EXISTS = _strresStrService.GetStrResourceByName("ERR_USER_NOT_EXISTS", lang);
                throw new MPlatException(ERR_USER_NOT_EXISTS.Label);
            }

            if (user.StopFlag)
            {
                var ERR_USER_STOPED= _strresStrService.GetStrResourceByName("ERR_USER_STOPED", lang);
                throw new MPlatException(ERR_USER_STOPED.Label);
            }


             password = _encryptionService.CreatePasswordHash(password, user.PasswordSalt);

            if (user.LoginPassword != password)
            {
                var ERR_OLD_PASSWORD = _strresStrService.GetStrResourceByName("ERR_OLD_PASSWORD", lang);
                throw new MPlatException(ERR_OLD_PASSWORD.Label);
            }

            return user;
        }
        public List ListRoles(QueryDescriptor conddes)
        {
            var filter = new Filter();
            conddes.GetFilter(filter);
            var query = this._userroleRepository.Table.Where(filter);
            //query = conddes.Page(query);
            var data = query.Select(r => r.Role).ToList();
            return data;
        }
        public void AddMember(UserRole model)
        {
            var roleInDB = _roleRepository.GetById(model.RoleId);
            if (roleInDB == null)
                throw new MPlatException("找不到角色。");

            var userInDB = _userRepository.GetById(model.UserID);
            if (userInDB == null)
                throw new MPlatException("找不到用户。");

            if (userInDB.UserRoles.Where(e => e.RoleId == model.RoleId).Count() > 0)
                throw new MPlatException("角色已经属于指定的用户。");
            _userroleRepository.Insert(model);
            _eventPublisher.EntityInserted(model);
        }
        public void DeleteMember(UserRole model)
        {
            var userroleInDB = _userroleRepository.Table.Where(e => e.RoleId == model.RoleId && e.UserID == model.UserID && !e.IsDeleted).FirstOrDefault();
            if (userroleInDB == null)
                throw new MPlatException("角色已不在该用户中");

            _userroleRepository.Delete(userroleInDB);
            _eventPublisher.EntityInserted(userroleInDB);
        }
    }

public class MenuService : IMenuService
    {
        private readonly IDbContext _dbcontext;
        private readonly IRepository _userRepository;
        private readonly IRepository _rolemenuRepository;
        private readonly IRepository _usermenuRepository;
        private readonly IRepository _menuRepository;
        private readonly IEventPublisher _eventPublisher;
        private readonly UserSettings _userSettings;

        public MenuService(
            IDbContext dbcontext,
            IRepository userRepository,
            IRepository rolemenuRepository,
            IRepository menuRepository,
            IEventPublisher eventPublisher,
            IRepository usermenuRepository,
        UserSettings userSettings
         )
        {
            this._dbcontext = dbcontext;
            this._userRepository = userRepository;
            this._menuRepository = menuRepository;
            this._eventPublisher = eventPublisher;
            this._userSettings = userSettings;
            this._usermenuRepository = usermenuRepository;
            this._rolemenuRepository = rolemenuRepository;
        }
        public void Create(Menu menu)
        {
            if (menu == null)
                throw new ArgumentNullException("menu");

            _menuRepository.Insert(menu);

            _eventPublisher.EntityInserted(menu);
        }

        public void Delete(Menu menu)
        {
            if (menu == null)
                throw new ArgumentNullException("menu");

            Delete(menu.Id);
        }

        public void Delete(int menuId)
        {
            var menuInDb = _menuRepository.GetById(menuId);
            if (menuInDb == null)
                throw new MPlatException("未找该菜单。");
            if (menuInDb.children != null && menuInDb.children.Count > 0)
            {
                throw new MPlatException("该菜单存在子菜单无法删除。");
            }
            if (!menuInDb.IsDeleted)
            {
                _menuRepository.Delete(menuInDb);
                _eventPublisher.EntityDeleted(menuInDb);
            }
        }

        public void Update(Menu menu)
        {
            _menuRepository.Update(menu);

            _eventPublisher.EntityUpdated(menu);
        }

        public Menu Get(int id)
        {
            var menuInDb = _menuRepository.GetById(id);
            return menuInDb;
        }
        public List GetMenuForNode()
        {

            var menu = _menuRepository.TableNoTracking
                .Where(x => x.parentmenuId != null && x.parentmenu.parentmenuId != null && x.parentmenu.parentmenu.parentmenuId == null);

            return menu.ToList();
        }

        public List ListRoleMenu(User user)
        {
            var roleids = user.UserRoles.Where(x => !x.IsDeleted).Select(e => e.RoleId).ToList();
            var menuIds = _rolemenuRepository.TableNoTracking.Where(e => roleids.Contains(e.RoleId)).Select(x => x.MenuId).Distinct().ToList();
            var menus = _menuRepository.TableNoTracking.Where(x => menuIds.Contains(x.Id)).ToList();

            return menus;
        }
        public List ListUserMenu(User user)
        {
            var data = _usermenuRepository.TableNoTracking.Where(r => r.UserId == user.UserID).ToList();
           
           var ids = data.Select(r => r.MenuId).ToList();
           var menus=_menuRepository.TableNoTracking.Where(x => ids.Contains(x.Id)).ToList();
           return menus;
        }
        public List ListMenu()
        {
            var menus = _menuRepository.TableNoTracking.ToList();

            return menus;
        }

        public List GetRoleMenuIds(int roleId)
        {
            return _rolemenuRepository.Table.Where(e => e.RoleId == roleId).Select(x => x.MenuId).ToList();
        }
        public List GetUserMenuIds(int UserId)
        {
            return _usermenuRepository.Table.Where(e => e.UserId == UserId).Select(x => x.MenuId).ToList();
        }
        public List GetRoleMenuIds(User user)
        {
            var roleids = user.UserRoles.Where(x => !x.IsDeleted).Select(e => e.RoleId).ToList();
            var menuIds = _rolemenuRepository.TableNoTracking.Where(e => roleids.Contains(e.RoleId)).Select(x => x.MenuId).Distinct().ToList();
            return menuIds;
        }
        public void CreateRoleMenu(RoleMenu rolemenu)
        {
            if (rolemenu == null)
                throw new ArgumentNullException("rolemenu");

            _rolemenuRepository.Insert(rolemenu);

        }
        public void CreateUserMenu(UserMenu usermenu)
        {
            if (usermenu == null)
                throw new ArgumentNullException("usermenu");

            _usermenuRepository.Insert(usermenu);

        }

        public void DeleteRoleMenu(int menuId, int roleId)
        {
            var rolemenuInDb = _rolemenuRepository.Table.FirstOrDefault(e => e.RoleId == roleId && e.MenuId == menuId);
            if (rolemenuInDb != null)
            {
                if (!rolemenuInDb.IsDeleted)
                {
                    _rolemenuRepository.Delete(rolemenuInDb);
                }
            }
        }
        public void DeleteUserMenu(int menuId, int UserId)
        {
            var rolemenuInDb = _usermenuRepository.Table.FirstOrDefault(e => e.UserId == UserId && e.MenuId == menuId);
            if (rolemenuInDb != null)
            {
                if (!rolemenuInDb.IsDeleted)
                {
                    _usermenuRepository.Delete(rolemenuInDb);

                }
            }
        }
        public bool HasRoleMenu(RoleMenu rolemenus)
        {
            var rolemenuInDb = _rolemenuRepository.Table.FirstOrDefault(e => e.RoleId == rolemenus.RoleId && e.MenuId == rolemenus.MenuId);
            return rolemenuInDb == null ? false : true;
        }
        public bool HasUserMenu(UserMenu usermenus)
        {
            var rolemenuInDb = _usermenuRepository.Table.FirstOrDefault(e => e.UserId == usermenus.UserId && e.MenuId == usermenus.MenuId);
            return rolemenuInDb == null ? false : true;
        }
    }

此处举例两个类，其它业务规则类的写法都是根据GUI界面的业务需求定义相应的方法实现它。下图是系统的业务规则类库图。

业务规则类库

支付宝打赏

微信打赏

系统   EF   WinForm

发表评论

留言与评论（共有 0 条评论） “”

验证码：