public void OnCategoryDeleted(ICategory category)
 {
     if (CategoryDeleted != null)
     {
         CategoryDeleted(new SingleItemEventArgs<ICategory>(category));
     }        
 }

 public Rule(ICategory applyCategory, IAction action, ICondition condition, string name)
 {
     m_condition = condition;
     m_action = action;
     m_applyCategory = applyCategory;
     m_name = name;
 }

        public IEnumerable<ITemplateBind> GetTemplateBindsForCategory(ICategory category)
        {
            //ITemplateBind bind;

            //bind = this.GetBind(TemplateBindType.CategoryTemplate, category.ID);

            //如果栏目不存在绑定，则查找模块的绑定
            //if (false || bind == null)
            //{
            //    int moduleID = cbll.Get(a => a.ID == categoryID).ModuleID;
            //    bind = GetBind(TemplateBindType.ModuleCategoryTemplate, moduleID.ToString());
            //}

               ITemplateBind bind=  this.GetBind(TemplateBindType.CategoryTemplate, category.Id);

               if (bind != null) yield return bind;
               bind= this.GetBind(TemplateBindType.CategoryArchiveTemplate, category.Id);
               if (bind != null) yield return bind;

            /*

            IDictionary<TemplateBindType, ITemplateBind> templates = new Dictionary<TemplateBindType, ITemplateBind>();
            if (bind != null)
            {
                templates.Add(TemplateBindType.CategoryTemplate, bind);
            }

            if (bindArchive != null)
            {
                templates.Add(TemplateBindType.CategoryArchiveTemplate, bindArchive);
            }
            return templates;
            */
        }

		public void PopulateFrom(ICategory input) {
			this.Description = input.Description;
			this.ParentCategoryId = input.ParentCategoryId;
			this.PictureId = input.PictureId;
			this.DisplayOrder = input.DisplayOrder;
			this.Published = input.Published;
			this.Deleted = input.Deleted;
			this.CreatedOnUtc = input.CreatedOnUtc;
			this.UpdatedOnUtc = input.UpdatedOnUtc;
			this.CategoryTemplateId = input.CategoryTemplateId;
			this.MetaKeywords = input.MetaKeywords;
			this.MetaDescription = input.MetaDescription;
			this.MetaTitle = input.MetaTitle;
			this.PageSize = input.PageSize;
			this.AllowCustomersToSelectPageSize = input.AllowCustomersToSelectPageSize;
			this.PageSizeOptions = input.PageSizeOptions;
			this.PriceRanges = input.PriceRanges;
			this.ShowOnHomePage = input.ShowOnHomePage;
			this.IncludeInTopMenu = input.IncludeInTopMenu;
			this.HasDiscountsApplied = input.HasDiscountsApplied;
			this.SubjectToAcl = input.SubjectToAcl;
			this.LimitedToStores = input.LimitedToStores;
			this.Name = input.Name;
			this.ID = input.ID;
			this.ID = input.ID;
		}

 public HomeController(ICategory catsvc,IProduct prodsvc,ICart cartsvc, ICheckout checkoutsvc, ICommon commonsvc)
 {
     _categoryService = catsvc;
     _productService = prodsvc;
     _cartService = cartsvc;
     _checkoutService = checkoutsvc;
     _commonService = commonsvc;
 }

        private string GetCellValue(ICategory phase)
        {
            if (phase == null || phase.Contributions == null) return string.Empty;

            int count = phase.Contributions.Select(x => x.Contributor).Distinct().Count();
            if (count <= 0) return string.Empty;
            return count.ToString();
        }

        public void AddContribution(ICategory contributionProject)
        {
            var list = (Contributions as List<ICategory>);

            // Don't add duplicates
            if (list.Any(x => x.Name == contributionProject.Name && x.URL == contributionProject.URL)) return;
            list.Add(contributionProject);
        }

 public Post(IUser userRepository, ICategory categoryRepository, ITag tagRepository, IComment commentRepository)
 {
     _postsTable = context.GetTable<PostEntity>();
     _commentRepository = commentRepository;
     _tagRepository = tagRepository;
     _categoryRepository = categoryRepository;
     _userRepository = userRepository;
 }

 public bool Equals(ICategory other)
 {
     if (ReferenceEquals(this, other))
         return true;
     if (other == null)
         return false;
     return this.EventType == other.EventType && this.Name == other.Name;
 }

 public HomeController(IPost postRepository, IUser userRepository, ICategory categoryRepository, ITag tagRepository, ISettings settingsRepository, ICacheService cacheService)
     : base (settingsRepository)
 {
     _postRepository = postRepository;
     _userRepository = userRepository;
     _categoryRepository = categoryRepository;
     _tagRepository = tagRepository;
     _cacheService = cacheService;
 }

 public Item(string name, decimal price, string description, string size, ICategory category, IImage img = null)
 {
     this.Name = name;
     this.Img = img;
     this.Price = price;
     this.Description = description;
     this.Size = size;
     this.Category = category;
 }

        public void Init(ICategory category)
        {
            if (!category.Engine.CanBeClassify)
            {
                throw new CannotBeClassifyException("Class must be prepared to classification firstly.");
            }

            this._category = category;
        }

 public static void InitContext()
 {
     if (InitEvent != null)
     {
             CategoryService = InitEvent(typeof(ICategory)) as ICategory;         
             PostService = InitEvent(typeof(IPost)) as IPost;         
             PostTagMapService = InitEvent(typeof(IPostTagMap)) as IPostTagMap;         
             TagService = InitEvent(typeof(ITag)) as ITag;         
     }
 }

        private static void GetProbabilities(ITargetObject titanicPassenger, ICategory category, out double survivedProbability, out double notSurvivedProbability)
        {
            IClassifer classifer = new Classifer();
            classifer.Init(category);

            Dictionary<string, double> classification = classifer.GetClassification(titanicPassenger);

            survivedProbability = classification["Edible"];
            notSurvivedProbability = classification["Poisonous"];
        }

		public string GetCanonicalUrl(ICategory category)
		{
			var productCategoryUrl = category.UrlName;
			while (category.Parent != null)
			{
				category = category.Parent;
				productCategoryUrl = string.Format("{0}/{1}", category.UrlName, productCategoryUrl);
			}
			return productCategoryUrl;
		}

        public TargetObject(ICategory category, string categoryType)
        {
            this.CategoryType = categoryType;
            this._variablesProbabilityMap = new AttributesCollection();

            foreach (string variableName in category.Attributes)
            {
                this._variablesProbabilityMap.Add(variableName);
            }
        }

        private static void GetProbabilities(ITargetObject snowboardExpensiveFreestyleToClassify, ICategory category, out double beginnerProbability, out double mediumProbability, out double advancedProbability)
        {
            IClassifer classifer = new Classifer();
            classifer.Init(category);

            Dictionary<string, double> classification = classifer.GetClassification(snowboardExpensiveFreestyleToClassify);

            beginnerProbability = classification[category.CategoryTypes[TestCategoryFactory.BeginnerCategory]];
            mediumProbability = classification[category.CategoryTypes[TestCategoryFactory.MediumCategory]];
            advancedProbability = classification[category.CategoryTypes[TestCategoryFactory.AdvancedCategory]];
        }

        public CategoryAdminController(ICategory categoryRepository, IPost postRepository, ISettings settingsRepository)
            : base(settingsRepository)
        {
            _categoryRepository = categoryRepository;
            _postRepository = postRepository;
            ExpectedMasterName = string.Empty;

            _itemsPerPage = settingsRepository.ManageItemsPerPage;

            IsAdminController = true;
        }

        public AdminController(IPost postRepository, IComment commentRepository, ICategory categoryRepository, ITag tagRepository, ISettings settingsRepository, IPathMapper pathMapper, IUser userRepository)
            : base(settingsRepository)
        {
            _postRepository = postRepository;
            _commentRepository = commentRepository;
            _categoryRepository = categoryRepository;
            _tagRepository = tagRepository;
            _pathMapper = pathMapper;
            _userRepository = userRepository;
            ExpectedMasterName = string.Empty;

            IsAdminController = true;
        }

        private static void TestClassifyAllMountainCheapAsBeginnerCategory(ICategory category)
        {
            ITargetObject snowboardCheapAllMountainToClassify = new TargetObject(category, String.Empty);
            snowboardCheapAllMountainToClassify.SetAttributeExist(TestCategoryFactory.CategoryAttributes[TestCategoryFactory.AllMountain]);
            snowboardCheapAllMountainToClassify.SetAttributeExist(TestCategoryFactory.CategoryAttributes[TestCategoryFactory.Cheap]);

            double beginnerProbability, mediumProbability, advancedProbability;

            GetProbabilities(snowboardCheapAllMountainToClassify, category, out beginnerProbability, out mediumProbability, out advancedProbability);

            Assert.IsTrue(beginnerProbability > mediumProbability);
            Assert.IsTrue(beginnerProbability > advancedProbability);
        }