C# User.ShouldNotBeNull方法代码示例

 public void Implements_IUser()
 {
     var user = new User() as IUser<int>;
     user.ShouldNotBeNull();
     user.UserName = "test";
     user.UserName.ShouldEqual("test");
 }

        /// <summary>
        /// 지정된 사용자의 모든 <see cref="UserConfig"/> 정보를 삭제합니다.
        /// </summary>
        /// <param name="user">사용자</param>
        public void DeleteAllUserConfigByUser(User user)
        {
            user.ShouldNotBeNull("user");

            if(IsDebugEnabled)
                log.Debug(@"지정된 사용자의 모든 UserConfig 정보를 삭제합니다... " + user);

            Repository<UserConfig>.DeleteAll(BuildQueryOverOfUserConfig(null, user.Company.Code, user.Code));
        }

        /// <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="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="user"></param>
        public void DeleteAllDepartmentMemberByUser(User user)
        {
            user.ShouldNotBeNull("user");

            if(IsDebugEnabled)
                log.Debug("사용자의 모든 부서 소속 정보 삭제를 시작합니다... user=" + user);

            Repository<DepartmentMember>
                .DeleteAll(DetachedCriteria
                               .For<DepartmentMember>()
                               .AddEq("User", user));

            // NOTE: UnitOfWork.TransactionalFlush()를 사용한다.
            //
            //var tx = UnitOfWork.Current.BeginTransaction();
            //try
            //{
            //    var crit = DetachedCriteria.For<DepartmentMember>().AddEq("User", user);
            //    Repository<DepartmentMember>.DeleteAll(crit);
            //    tx.Commit();

            //    if (IsInfoEnabled)
            //        log.Info(@"사용자의 부서 소속 정보를 삭제했습니다. user=" + user);
            //}
            //catch (Exception ex)
            //{
            //    if (IsErrorEnabled)
            //        log.ErrorException(@"사용자의 부서 소속정보를 삭제하는데 실패했습니다. user=" + user, ex);

            //    if (tx != null)
            //        tx.Rollback();
            //    throw;
            //}
        }

        /// <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>
        /// 지정된 직원의 소속 부서를 변경합니다.
        /// </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);
        }

        /// <summary>
        /// 사용자 Login 이력을 DB에 기록합니다. (Sessionless를 사용하므로 함수명이 Insert 로 시작합니다)
        /// </summary>
        /// <param name="product">로그인한 제품 정보</param>
        /// <param name="user">로그인 사용자</param>
        /// <param name="department">로그인 사용자의 부서</param>
        /// <param name="localeKey">로그인 사용자의 Locale 정보</param>
        /// <param name="loginTime">로그인 시각</param>
        /// <param name="exAttr">확장 속성 정보</param>
        public void InsertUserLoginLog(Product product, User user, Department department = null, string localeKey = null, DateTime? loginTime = null, string exAttr = null)
        {
            product.ShouldNotBeNull("product");
            user.ShouldNotBeNull("user");

            var loginLog = new UserLoginLog(product.Code, user.Company.Code, user.LoginId, localeKey, loginTime)
                           {
                               ProductName = product.Name,
                               CompanyName = user.Company.Name,
                               DepartmentCode = (department != null) ? department.Code : null,
                               DepartmentName = (department != null) ? department.Name : null,
                               UserCode = user.Code,
                               UserName = user.Name,
                               ExAttr = exAttr
                           };

            if(log.IsDebugEnabled)
                log.Debug(@"사용자 로그인 이력 정보를 생성합니다... " + loginLog);

            // NOTE : Log 정보를 기록할 때에는 Session에 저장할 필요없고, 성능을 위해서 StatelessSession를 사용합니다.
            //
            loginLog.InsertStateless(Session);
        }

        /// <summary>
        /// UserConfig(사용자 환경설정) 정보를 삭제합니다.
        /// </summary>
        /// <param name="product">제품</param>
        /// <param name="user">사용자</param>
        /// <param name="key">설정 키</param>
        public void DeleteUserConfigById(Product product, User user, string key)
        {
            product.ShouldNotBeNull("product");
            user.ShouldNotBeNull("user");
            key.ShouldNotBeWhiteSpace("key");

            if(IsDebugEnabled)
                log.Debug(@"UserConfig 정보를 삭제합니다... productCode={0}, userCode={1}, key={2}", product.Code, user.Code, key);

            Repository<UserConfig>.DeleteAll(BuildQueryOverOfUserConfig(product.Code, user.Company.Code, user.Code, key));
        }

        /// <summary>
        /// 지정된 사용자의 UserConfig 정보를 Paging 처리해서 로드합니다.
        /// </summary>
        /// <param name="user">사용자</param>
        /// <param name="pageIndex">Page Index (0부터 시작합니다.)</param>
        /// <param name="pageSize">Page Size (보통 10입니다. 0보다 커야 합니다.)</param>
        /// <param name="orders">정렬 순서</param>
        /// <returns></returns>
        public IPagingList<UserConfig> GetPageOfUserConfigByUser(User user, int pageIndex, int pageSize, params INHOrder<UserConfig>[] orders)
        {
            user.ShouldNotBeNull("user");

            if(IsDebugEnabled)
                log.Debug(@"지정된 사용자의 UserConfig 정보를 Paging 처리해서 로드합니다... " +
                          @"user={0}, pageIndex={1}, pagesize={2}, orders={3}",
                          user, pageIndex, pageSize, orders);

            return Repository<UserConfig>.GetPage(pageIndex,
                                                  pageSize,
                                                  BuildQueryOverOfUserConfig(null, user.Company.Code, user.Code),
                                                  orders);
        }

        /// <summary>
        /// 사용자 환경설정 정보를 조회합니다. 없다면, 새로 생성해서 저장 후 반환합니다.
        /// </summary>
        /// <param name="product">제품 정보</param>
        /// <param name="user">사용자 정보</param>
        /// <param name="key">설정 키</param>
        /// <returns></returns>
        public UserConfig GetOrCreateUserConfig(Product product, User user, string key)
        {
            product.ShouldNotBeNull("product");
            user.ShouldNotBeNull("user");
            key.ShouldNotBeWhiteSpace("key");

            var userConfigIdentity = new UserConfigIdentity(product.Code, user.Company.Code, user.Code, key);

            if(IsDebugEnabled)
                log.Debug(@"UserConfig 정보를 조회합니다... " + userConfigIdentity);

            var userConfig = Repository<UserConfig>.Get(userConfigIdentity);

            if(userConfig != null)
                return userConfig;

            if(IsDebugEnabled)
                log.Debug(@"기존 UserConfig 정보가 없습니다. 새로 생성합니다... " + userConfigIdentity);

            // 성능을 위해 StatelessSession을 사용하여 저장합니다.
            lock(_syncLock)
            {
                using(UnitOfWork.Start(UnitOfWorkNestingOptions.CreateNewOrNestUnitOfWork))
                {
                    Repository<UserConfig>.SaveOrUpdate(new UserConfig(userConfigIdentity, null));
                    UnitOfWork.Current.TransactionalFlush();
                }
            }

            userConfig = Repository<UserConfig>.Get(userConfigIdentity);
            userConfig.AssertExists("userConfig");

            if(log.IsInfoEnabled)
                log.Info(@"새로운 UserConfig 정보를 생성했습니다!!! New UserConfig = " + userConfig);

            return userConfig;
        }

        /// <summary>
        /// 지정된 사용자의 모든 UserConfig 정보를 조회합니다.
        /// </summary>
        /// <param name="user">사용자</param>
        /// <returns></returns>
        public IList<UserConfig> FindAllUserConfigByUser(User user)
        {
            user.ShouldNotBeNull("user");

            if(IsDebugEnabled)
                log.Debug(@"지정된 사용자의 모든 UserConfig 정보를 조회합니다... " + user);

            return Repository<UserConfig>.FindAll(BuildQueryOverOfUserConfig(null, user.Company.Code, user.Code));
        }