C# Product.ShouldNotBeNull方法代码示例

        public OrderDetail(Order order, Product product) {
            order.ShouldNotBeNull("order");
            product.ShouldNotBeNull("product");

            Order = order;
            Product = product;
        }

        /// <summary>
        /// 리소스 이름으로 매칭된 리소스 정보를 조회합니다.
        /// </summary>
        /// <param name="product">제품</param>
        /// <param name="nameToMatch">검색하고자 하는 리소스 명</param>
        /// <param name="matchMode">매칭 모드</param>
        /// <returns></returns>
        public IList<Resource> FindAllResourceByNameToMatch(Product product, string nameToMatch, MatchMode matchMode)
        {
            product.ShouldNotBeNull("product");

            if(IsDebugEnabled)
                log.Debug(@"Resource 정보를 Name 매칭 검색으로 조회합니다... product={0}, nameToMatch=[{1}], matchMode={2}",
                          product, nameToMatch, matchMode);

            var query =
                BuildQueryOverOfResource(product)
                    .AddInsensitiveLike(r => r.Name, nameToMatch, matchMode ?? MatchMode.Anywhere);

            return Repository<Resource>.FindAll(query);
        }

        /// <summary>
        /// 새로운 MasterCode를 생성합니다.
        /// </summary>
        /// <param name="product">제품</param>
        /// <param name="code">MasterCode의 코드</param>
        /// <param name="name">MasterCode의 Name</param>
        /// <param name="isActive">사용여부</param>
        /// <param name="description">설명</param>
        /// <param name="exAttr">확장속성</param>
        /// <returns>새로 생성된 MasterCode</returns>
        public MasterCode CreateMasterCode(Product product, string code, string name, bool? isActive, string description, string exAttr)
        {
            product.ShouldNotBeNull("product");
            code.ShouldNotBeWhiteSpace("code");

            if(IsDebugEnabled)
                log.Debug(@"새로운 MasterCode를 생성합니다... " +
                          @"product={0}, code={1}, name={2}, isActive={3}, description={4}, exAttr={5}",
                          product, code, name, isActive, description, exAttr);

            var masterCode = new MasterCode(product, code, name)
                             {
                                 IsActive = isActive,
                                 Description = description,
                                 ExAttr = exAttr
                             };

            return Repository<MasterCode>.SaveOrUpdate(masterCode);
        }

        /// <summary>
        /// Resource 정보를 Name 매칭 검색 결과를 Paging처리해서 로드합니다.
        /// </summary>
        /// <param name="product">제품</param>
        /// <param name="nameToMatch">검색하고자 하는 리소스 명</param>
        /// <param name="matchMode">매칭 모드</param>
        /// <param name="pageIndex">페이지 인덱스 (0부터 시작)</param>
        /// <param name="pageSize">페이지 크기 (0보다 커야 한다. 보통 10)</param>
        /// <param name="orders">정렬 순서</param>
        /// <returns></returns>
        public IPagingList<Resource> GetPageOfResourceByNameToMatch(Product product, string nameToMatch, MatchMode matchMode,
                                                                    int pageIndex, int pageSize, params INHOrder<Resource>[] orders)
        {
            product.ShouldNotBeNull("product");
            pageIndex.ShouldBePositiveOrZero("pageIndex");
            pageSize.ShouldBePositive("pageSize");

            if(IsDebugEnabled)
                log.Debug(@"Resource 정보를 Name 매칭 검색 결과를 Paging처리해서 로드합니다... " +
                          @"product={0}, nameToMatch={1}, matchMode={2}, pageIndex={3}, pagesize={4}, orders={5}",
                          product, nameToMatch, matchMode, pageIndex, pageSize, orders);

            var query =
                BuildQueryOverOfResource(product)
                    .AddInsensitiveLike(r => r.Name, nameToMatch, matchMode ?? MatchMode.Anywhere);

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

        /// <summary>
        /// 제품별 Root Menu 정보 (Parent가 null인) 정보를 조회합니다.
        /// </summary>
        /// <param name="product"></param>
        /// <returns></returns>
        public IList<Menu> FindRootMenuByProduct(Product product)
        {
            product.ShouldNotBeNull("product");

            if(IsDebugEnabled)
                log.Debug(@"제품별 Root Menu 정보를 조회합니다... " + product);

            var query = BuildQueryOverOfMenu(product, null, null, null).AddWhereRestrictionOn(m => m.Parent).IsNull;
            return Repository<Menu>.FindAll(query);
        }

        /// <summary>
        /// 제품에 속한 모든 <see cref="MasterCodeItem"/> 정보를 조회합니다.
        /// </summary>
        /// <param name="product">제품</param>
        /// <param name="orders">정렬순서</param>
        /// <returns></returns>
        public IList<MasterCodeItem> FindAllMasterCodeItemByProduct(Product product, params INHOrder<MasterCodeItem>[] orders)
        {
            product.ShouldNotBeNull("product");

            if(IsDebugEnabled)
                log.Debug(@"제품에 소속된 모든 MasterCodeItem를 조회합니다... product={0}, orders={1}", product, orders.CollectionToString());

            MasterCode @masterCodeAlias = null;
            var query =
                QueryOver.Of<MasterCodeItem>()
                    .JoinAlias(mci => mci.MasterCode, () => @masterCodeAlias)
                    .AddWhere(() => @masterCodeAlias.Product == product)
                    .AddOrders(orders);

            return Repository<MasterCodeItem>.FindAll(query);
        }

        /// <summary>
        /// 제품에 소속된 MasterCodeItem를 Paging 처리해서 로드합니다.
        /// </summary>
        /// <param name="product">제품</param>
        /// <param name="pageIndex">페이지 인덱스 (0부터 시작)</param>
        /// <param name="pageSize">페이지 크기 (0보다 커야 한다. 보통 10)</param>
        /// <param name="orders">정렬 순서</param>
        /// <returns></returns>
        public IPagingList<MasterCodeItem> GetPageOfMasterCodeItemByProduct(Product product, int pageIndex, int pageSize, params INHOrder<MasterCodeItem>[] orders)
        {
            product.ShouldNotBeNull("product");

            if(IsDebugEnabled)
                log.Debug(@"제품에 소속된 MasterCodeItem를 Paging 처리해서 로드합니다... product={0}, pageIndex={1}, pagesize={2}, orders={3}",
                          product, pageIndex, pageSize, orders.CollectionToString());

            MasterCode @masterCodeAlias = null;

            var query =
                QueryOver.Of<MasterCodeItem>()
                    .JoinAlias(mci => mci.MasterCode, () => @masterCodeAlias)
                    .AddWhere(() => @masterCodeAlias.Product == product)
                    .AddOrders(orders);

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

        /// <summary>
        /// 즐겨찾기 생성
        /// </summary>
        /// <param name="product">제품</param>
        /// <param name="company">소유자 회사</param>
        /// <param name="ownerCode">소유자 코드</param>
        /// <param name="ownerKind">소유자 종류</param>
        /// <param name="content">즐겨찾기 내용</param>
        /// <returns></returns>
        public Favorite CreateFavorite(Product product, Company company, string ownerCode, ActorKinds ownerKind, string content)
        {
            product.ShouldNotBeNull("product");
            company.ShouldNotBeNull("company");
            ownerCode.ShouldNotBeWhiteSpace("owernCode");

            if(IsDebugEnabled)
                log.Debug(@"새로운 즐겨찾기 정보를 생성합니다... product={0}, company={1}, ownerCode={2}, ownerKind={3}, content={4}",
                          product, company, ownerCode, ownerKind, content);

            var favorite = new Favorite(product, company, ownerCode, ownerKind, content);
            return Repository<Favorite>.SaveOrUpdate(favorite);
        }

        /// <summary>
        /// 제품에 소속된 모든 MasterCode를 조회합니다.
        /// </summary>
        /// <param name="product">제품</param>
        /// <param name="orders">정렬 순서</param>
        /// <returns></returns>
        public IList<MasterCode> FindAllMasterCodeByProduct(Product product, params INHOrder<MasterCode>[] orders)
        {
            product.ShouldNotBeNull("product");

            if(IsDebugEnabled)
                log.Debug(@"제품에 소속된 모든 MasterCode를 조회합니다... " + product);

            return Repository<MasterCode>.FindAll(BuildQueryOverOfMasterCode(product).AddOrders(orders));
        }

        /// <summary>
        /// 지정된 Id에 해당하는 메뉴 템플릿을 조회합니다. 옵션으로 조상, 자손 메뉴 템플릿도 가져올 수 있도록 합니다.
        /// </summary>
        /// <param name="product">제품 정보</param>
        /// <param name="menuTemplateId">메뉴 템플릿 Id</param>
        /// <param name="hierarchyContainsKinds">메뉴 템플릿의 조상/자손도 포함할 것인가 여부</param>
        public IList<MenuTemplate> FildAllMenuTemplateByHierarchy(Product product, string menuTemplateId, HierarchyContainsKinds hierarchyContainsKinds)
        {
            // NOTE: 현재는 Loop 방식을 사용하여 round-trip이 많이 발생하게끔 되어 있다. Second Cache로 속도를 극복할 수 밖에 없다.
            //
            product.ShouldNotBeNull("product");

            if(IsDebugEnabled)
                log.Debug(@"계층구조에 따른 메뉴 템플릿 정보를 조회합니다. product={0}, code={1}, hierarchyContainsKinds={2}",
                          product, menuTemplateId, hierarchyContainsKinds);

            var results = new HashSet<MenuTemplate>();

            var menuTemplate = FindOneMenuTemplateByCode(product, menuTemplateId);

            if(menuTemplate == null)
                return results.ToList();

            // 1. 현재 메뉴 템플릿의 조상들 추가한다.
            if((hierarchyContainsKinds & HierarchyContainsKinds.Ancestors) > 0)
                menuTemplate.GetAncestors().RunEach(mt => results.Add(mt));

            // 2. 현재 메뉴 템플릿을 추가한다.
            if((hierarchyContainsKinds & HierarchyContainsKinds.Self) > 0)
                results.Add(menuTemplate);

            // 3. 현재 메뉴 템플릿의 자손들을 추가한다.
            if((hierarchyContainsKinds & HierarchyContainsKinds.Descendents) > 0)
                menuTemplate.GetDescendents().RunEach(mt => results.Add(mt));

            return results.ToList();
        }

        /// <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>
        /// Id에 해당하는 Menu를 삭제합니다.
        /// </summary>
        /// <param name="product"></param>
        /// <param name="code"></param>
        public void DeleteMenuByCode(Product product, string code)
        {
            product.ShouldNotBeNull("product");
            code.ShouldNotBeWhiteSpace("code");

            if(IsDebugEnabled)
                log.Debug(@"지정한 Id를 가진 Menu를 삭제합니다... product={0}, code={1}", product, code);

            var menu = FindOneMenuByProductAndCode(product, code);

            if(menu != null)
                DeleteMenu(menu);
        }

        /// <summary>
        /// 지정된 Id 정보를 가진 메뉴 템플릿을 삭제합니다. HBM의 cascade 설정에 따라 cascade-delete가 수행될 수 있습니다.
        /// </summary>
        public void DeleteMenuTemplateByCode(Product product, string code)
        {
            product.ShouldNotBeNull("product");
            code.ShouldNotBeWhiteSpace("code");

            if(IsDebugEnabled)
                log.Debug(@"지정한 MenuTemplate를 삭제합니다... product={0}, code={1}", product, code);

            var menuTemplate = FindOneMenuTemplateByCode(product, code);

            if(menuTemplate != null)
                DeleteMenuTemplate(menuTemplate);
        }

        /// <summary>
        /// 지정된 제품에 소속된 모든 MenuTemplate를 삭제합니다.
        /// </summary>
        /// <param name="product"></param>
        public void DeleteAllMenuTemplateByProduct(Product product)
        {
            product.ShouldNotBeNull("product");

            if(IsDebugEnabled)
                log.Debug(@"제품에 소속된 모든 MenuTemplate를 삭제합니다... " + product);

            Repository<MenuTemplate>.DeleteAll(BuildQueryOverOfMenuTemplate(product, null, null));
        }

        /// <summary>
        /// 새로운 메뉴 템플릿을 생성합니다.
        /// </summary>
        /// <returns></returns>
        public MenuTemplate CreateMenuTemplate(Product product, string code, string name, string menuUrl)
        {
            product.ShouldNotBeNull("product");
            code.ShouldNotBeWhiteSpace("code");

            if(IsDebugEnabled)
                log.Debug(@"새로운 MenuTemplate를 생성합니다. product={0}, code={1}, name={2}, menuUrl={3}", product, code, name, menuUrl);

            var menuTemplate = new MenuTemplate(product, code)
                               {
                                   Name = name ?? code,
                                   MenuUrl = menuUrl
                               };
            menuTemplate.SetParent(null);
            menuTemplate.UpdateNodePosition();

            return Repository<MenuTemplate>.SaveOrUpdate(menuTemplate);
        }