C# Department.ShouldNotBeNull方法代码示例

        /// <summary>
        /// 지정된 부서에 소속된 직원들을 반환합니다.
        /// </summary>
        /// <param name="department">부서</param>
        /// <param name="hierarchyContainsKind">부서의 조상/자손도 포함할 것인가 여부</param>
        /// <param name="pageIndex">페이지 인덱스 (0부터 시작)</param>
        /// <param name="pageSize">페이지 크기 (0보다 커야 한다. 보통 10)</param>
        /// <param name="orders">정렬 순서</param>
        /// <returns>부서 소속원 컬렉션을 반환한다.</returns>
        public IPagingList<User> GetPageOfUserByDepartment(Department department,
                                                           HierarchyContainsKinds hierarchyContainsKind,
                                                           int pageIndex,
                                                           int pageSize,
                                                           params INHOrder<User>[] orders)
        {
            department.ShouldNotBeNull("department");
            department.Company.ShouldNotBeNull("company of department");

            var companyCode = department.Company.Code;

            // TODO : 이 함수는 검증해봐야 한다!!!
            // NOTE : 왜 Paging 시에 간단하게 DepartMember로 하지 않고, 직접 User로 해야 되냐면, 겸직인 경우 두번 나오게 된다. 그럼 Paging 처리가 이상하게 된다.););

            if(IsDebugEnabled)
                log.Debug(@"부서 소속 사원 정보를 가져옵니다. 부서의 상위 또는 하위 부서의 소속원들도 포함시킬 수 있습니다." +
                          @"department={0}, hierarchyContainsKind={1}, pageIndex={2}, pageSize={3}, orders={4}",
                          department, hierarchyContainsKind, pageIndex, pageSize, orders.CollectionToString());

            // Department 조회
            var departments = FindAllDepartmentByHierarchy(department, hierarchyContainsKind);

            Company @companyAlias = null;
            Department @departmentAlias = null;
            User @userAlias = null;

            // Department들의 소속부서원 정보의 모든 부서원의 Id 값 조회
            var userIdQuery =
                QueryOver.Of<DepartmentMember>()
                    .JoinAlias(dm => dm.Department, () => @departmentAlias)
                    .JoinAlias(() => @departmentAlias.Company, () => @companyAlias)
                    .AddWhere(() => @companyAlias.Code == companyCode)
                    .AddWhereRestrictionOn(u => u.Department).IsIn(departments.ToArray())
                    .JoinAlias(dm => dm.User, () => @userAlias)
                    .Select(Projections.Group(() => @userAlias.Id));

            // 부서원 Id를 조회하는 서브쿼리에 만족하는 모든 User 조회
            var query =
                QueryOver.Of<User>()
                    .JoinAlias(u => u.Company, () => @companyAlias)
                    .AddWhere(() => @companyAlias.Code == companyCode)
                    .WithSubquery.WhereProperty(u => u.Id).In(userIdQuery);

            return Repository<User>.GetPage(pageIndex, pageSize, query, orders);
        }

        /// <summary>
        /// 부서에 소속된 사용자인가 검사합니다.
        /// </summary>
        /// <param name="department"></param>
        /// <param name="user"></param>
        /// <returns></returns>
        public bool IsDepartmentMember(Department department, User user)
        {
            department.ShouldNotBeNull("department");
            user.ShouldNotBeNull("user");

            if(IsDebugEnabled)
                log.Debug(@"부서에 소속된 사용자인가 검사합니다. department={0}, user={1}", department, user);

            var query = BuildQueryOverOfDepartmentMember(department, user, null, null, null);
            var isMember = Repository<DepartmentMember>.Exists(query);

            if(IsDebugEnabled)
                log.Debug(@"부서에 소속된 사용자인가 검사했습니다!!! department={0}, user={1}, 소속여부:{2}", department, user, isMember);

            return isMember;
        }

        /// <summary>
        /// 지정된 부서에 소속된 직원들을 반환합니다.
        /// </summary>
        /// <param name="department">부서</param>
        /// <param name="hierarchyContainsKind">부서의 조상/자손도 포함할 것인가 여부</param>
        /// <returns>부서 소속원 컬렉션을 반환한다.</returns>
        public IList<User> FindAllUserByDepartment(Department department, HierarchyContainsKinds hierarchyContainsKind)
        {
            department.ShouldNotBeNull("department");

            if(IsDebugEnabled)
                log.Debug(@"부서 소속 사원 정보를 가져옵니다. 부서의 상위 또는 하위 부서의 소속원들도 포함시킬 수 있습니다... " +
                          @"department={0}, hierarchyContainsKind={1}",
                          department, hierarchyContainsKind);

            // 중복 사용자를 피하기 위해 HashedSet을 사용합니다.
            var users = new HashSet<User>();

            // 1. 조상부서에 소속된 직원 정보)
            if((hierarchyContainsKind & HierarchyContainsKinds.Ancestors) > 0)
                department.GetAncestors().RunEach(dept => dept.GetUsers().RunEach(u => users.Add(u)));

            // 2. 현재부서에 소속된 직원 정보
            if((hierarchyContainsKind & HierarchyContainsKinds.Self) > 0)
                department.GetUsers().RunEach(u => users.Add(u));

            // 3. 자손부서에 소속된 직원 정보)
            if((hierarchyContainsKind & HierarchyContainsKinds.Descendents) > 0)
                department.GetDescendents().RunEach(dept => dept.GetUsers().RunEach(u => users.Add(u)));

            return users.ToList();
        }

        /// <summary>
        /// 부서-직원 소속 정보를 제거합니다.
        /// </summary>
        /// <param name="department"></param>
        /// <param name="user"></param>
        /// <returns></returns>
        public bool DeleteDepartmentMember(Department department, User user)
        {
            department.ShouldNotBeNull("department");
            user.ShouldNotBeNull("user");

            if(log.IsDebugEnabled)
                log.Debug(@"부서-직원 소속 정보를 제거합니다...부서={0}, 직원={1}", department, user);

            if(IsDepartmentMember(department, user) == false)
            {
                if(IsDebugEnabled)
                    log.Debug("부서에 소속된 사용자가 아니므로, 소속 정보를 삭제할 것이 없습니다.");

                return false;
            }

            var member = department.Members.Where(m => m.User.Equals(user)).FirstOrDefault();

            if(member != null)
                return DeleteDepartmentMember(member);

            return false;
        }

        /// <summary>
        /// 지정된 부서의 조상 또는 자손의 소속 정보까지 가져올 것인가?  
        /// </summary>
        /// <param name="department">조회할 부서</param>
        /// <param name="hierarchyContainsKinds">부서의 조상/자손도 포함할 것인가 여부</param>
        /// <returns></returns>
        public IEnumerable<DepartmentMember> FindAllDepartmentMemberByDepartmentHierarchy(Department department,
                                                                                          HierarchyContainsKinds hierarchyContainsKinds)
        {
            department.ShouldNotBeNull("department");

            if(IsDebugEnabled)
                log.Debug(@"지정된 부서 및 부서의 조상/자손의 직원 소속 정보를 가져옵니다. department={0}, hierarchyContainsKind={1}",
                          department.Id, hierarchyContainsKinds);

            var departments = FindAllDepartmentByHierarchy(department, hierarchyContainsKinds);

            // 조회한 부서에 대한 부서-직원 소속 정보를 가져온다
            //
            return departments.SelectMany(d => d.Members);
        }

        /// <summary>
        /// 지정한 부서의 부서원 소속 정보를 모두 삭제합니다.
        /// </summary>
        /// <param name="department"></param>
        public void DeleteAllDepartmentMemberByDepartment(Department department)
        {
            department.ShouldNotBeNull("department");

            department.Members.Clear();
            Repository<Department>.SaveOrUpdate(department);
        }

        /// <summary>
        /// 지정된 상위 부서 밑으로 부서를 추가합니다. 이때, 상위부서는 null이면 안됩니다. (최상위 부서는 <see cref="GetOrCreateDepartment"/> 메소드를 사용하세요)
        /// </summary>
        public Department CreateDepartmentOf(Department parent, string childCode)
        {
            parent.ShouldNotBeNull("parent");
            childCode.ShouldNotBeWhiteSpace("childCode");

            if(IsDebugEnabled)
                log.Debug("부서[{0}] 하위로 새로운 부서를 추가합니다. 추가할 부서 Id=[{1}] 입니다.", parent.Code, childCode);

            var child = new Department(parent.Company, childCode);

            child.SetParent(parent);
            child.UpdateNodePosition();

            Repository<Department>.SaveOrUpdate(parent);
            return Repository<Department>.SaveOrUpdate(child);
        }

        /// <summary>
        /// 부서에 직원 소속 정보를 생성합니다.
        /// </summary>
        /// <param name="department">부서</param>
        /// <param name="user">사용자</param>
        /// <param name="employeeTitle">직책 정보</param>
        /// <returns></returns>
        public DepartmentMember CreateDepartmentMember(Department department, User user, EmployeeTitle employeeTitle)
        {
            department.ShouldNotBeNull("department");
            user.ShouldNotBeNull("user");

            DepartmentMember member;

            // 1. 이미 부서에 소속되어 있다면, 정보 갱신만 하고, 반환한다.
            if(IsDepartmentMember(department, user))
            {
                if(log.IsInfoEnabled)
                    log.Info("이미 부서에 소속된 직원이므로, 새로 생성하지 않고 기존 정보를 읽어 반환합니다. department={0}, user={1}", department, user);

                member = department.Members.FirstOrDefault(m => m.User.Equals(user));
                // member = department.Members.Where(m => m.User.Equals(user)).FirstOrDefault();

                if(member != null && member.EmployeeTitle != employeeTitle)
                {
                    member.EmployeeTitle = employeeTitle;
                    Repository<DepartmentMember>.SaveOrUpdate(member);
                }

                return member;
            }

            // 2. 새로운 부서 소속 정보를 생성하고, 저장한 후 반환한다.
            if(IsDebugEnabled)
                log.Debug(@"부서에 새로운 직원을 소속시킵니다. department={0}, user={1}, employeeTitle={2}",
                          department.Id, user.Id, employeeTitle);

            var company = department.Company;
            Guard.Assert(company != null, @"해당 Company 정보를 찾을 수 없습니다. department=[{0}]", department);

            member = new DepartmentMember(department, user)
                     {
                         EmployeeTitle = employeeTitle
                     };

            return Repository<DepartmentMember>.SaveOrUpdate(member);
        }

        /// <summary>
        /// 지정된 child 부서를 newParent의 하위부서로 이동시킨다.
        /// </summary>
        public void ChangeDepartmentParent(Department child, Department newParent)
        {
            child.ShouldNotBeNull("child");

            var oldParent = child.Parent;

            if(Equals(oldParent, newParent))
            {
                if(log.IsWarnEnabled)
                    log.Warn("변경할 부모가 현재 부모와 같으므로, 부모 변경 작업을 수행하지 않습니다.");
                return;
            }

            if(IsDebugEnabled)
                log.Debug("부서의 부모를 변경합니다. child={0}, new parent={1}, old parent={2}",
                          child.Code,
                          (newParent != null) ? newParent.Code : EntityTool.NULL_STRING,
                          (oldParent != null) ? oldParent.Code : EntityTool.NULL_STRING);

            child.ChangeParent(oldParent, newParent);

            Repository<Department>.SaveOrUpdate(child);
        }

        /// <summary>
        /// 지정된 직원의 소속 부서를 변경합니다.
        /// </summary>
        /// <param name="user"></param>
        /// <param name="oldDepartment"></param>
        /// <param name="newDepartment"></param>
        /// <returns></returns>
        public DepartmentMember ChangeDepartmentFor(User user, Department oldDepartment, Department newDepartment)
        {
            user.ShouldNotBeNull("user");
            oldDepartment.ShouldNotBeNull("oldDepartment");
            newDepartment.ShouldNotBeNull("newDepartment");
            Guard.Assert(oldDepartment != newDepartment, "현재 소속된 부서가 변경할 부서와 같습니다.");

            if(IsDebugEnabled)
                log.Debug("사용자[{0}]의 소속 부서를 변경합니다... 기존부서={1}, 신규부서={2}",
                          user.Id, oldDepartment.Id, newDepartment.Id);

            // 1. 기존 부서에 소속된 정보를 제거합니다.
            DeleteDepartmentMember(oldDepartment, user);

            // 2. 변경할 부서에 이미 소속되어 있으므로, 기존 부서 정보만 삭제하고 반환한다.
            if(IsDepartmentMember(newDepartment, user))
            {
                if(log.IsDebugEnabled)
                    log.Debug(@"변경할 부서에 이미 소속되어 있습니다... 기존 부서 소속 정보만 삭제합니다.");

                return newDepartment.Members.Where(m => m.User.Equals(user)).FirstOrDefault();
            }

            return CreateDepartmentMember(newDepartment, user, null);
        }