/// <summary>
 /// Gets the categories for the specified category type.
 /// </summary>
 /// <param name="catType">Type of the cat.</param>
 /// <param name="activeOnly">if set to <c>true</c> [active only].</param>
 /// <returns></returns>
 public override ICollection<LinkCategory> GetCategories(CategoryType catType, bool activeOnly)
 {
     using (IDataReader reader = _procedures.GetCategory(null, null, activeOnly, BlogId, (int)catType))
     {
         return reader.ReadCollection(r => r.ReadLinkCategory());
     }
 }

 public TerrainPaintBrushCatalogResource(int APIversion,
     uint version,
     uint brushVersion,
     Common common,
     BrushOperation normalOperation, BrushOperation oppositeOperation, TGIBlock profileTexture, BrushOrientation orientation,
     float width, float strength, byte baseTextureValue, float wiggleAmount,
     TGIBlock brushTexture,
     TerrainType terrain, CategoryType category
     )
     : base(APIversion,
         version,
         brushVersion,
         common,
         normalOperation,
         oppositeOperation,
         profileTexture,
         orientation,
         width,
         strength,
         baseTextureValue,
         wiggleAmount
     )
 {
     this.brushTexture = (TGIBlock)brushTexture.Clone(OnResourceChanged);
     this.terrain = terrain;
     this.category = category;
 }

       public IList<CategoryInfo> GetCategory(CategoryType categoryType, int categoryID)
       {
           SqlHelper objSqlHelper = new SqlHelper();
           
           List<CategoryInfo> categorys = new List<CategoryInfo>();
           SqlParameter[] objParams = new SqlParameter[2];
           objParams[0] = new SqlParameter("@categoryType", SqlDbType.Int, 4);
           objParams[1] = new SqlParameter("@categoryID", SqlDbType.Int, 4);
           objParams[0].Value = (int)categoryType;
           objParams[1].Value = categoryID;

           SqlDataReader reader = objSqlHelper.ExecuteReader("je_Cat_GetCategory", objParams); ;
           while (reader.Read())
           {
               
               CategoryInfo item = new CategoryInfo();
               item.CategoryID = reader.GetInt32(reader.GetOrdinal("categoryID"));
               item.CategoryName = reader.GetString(reader.GetOrdinal("categoryName"));
               item.ParentID = reader.GetInt32(reader.GetOrdinal("parentID"));
               item.IsMain = reader.GetBoolean(reader.GetOrdinal("IsMain"));
               categorys.Add(item);
           }
           reader.Close();
           objSqlHelper.close();
           
           return categorys;
       }

 public Guid Adjust(Guid userId, decimal amount, CategoryType type, DateTime payDate, string remark)
 {
     var personalAccount = new PersonalAccountDomain(userId);
     var water = new PersonalAccountWaterDomain(personalAccount, amount, type, payDate, remark);
     unitOfWork.Commit();
     return water.Entity.Id;
 }

        public List<CategoryDTO> GetAll(CategoryType type)
        {
            List<CategoryDTO> result = new List<CategoryDTO>();
            List<Category> data = _categoryRepository.GetAll(type);

            return ListToDTO<Category, CategoryDTO>(data);
        }

        public Guid Add(string name, CategoryType type, int? num)
        {
            CategoryDomain domain = new CategoryDomain(name, type, num);
            unitOfWork.Commit();

            return domain.Entity.Id;
        }

        /// <summary>
        /// Basic ctor that recieves an indicator of which category group
        ///  the category is being added to
        /// </summary>
        /// <param name="categoryType">Category group indicator</param>
        public AddCategoryUI(CategoryType categoryType)
        {
            InitializeComponent();
            CategoryType = categoryType;

            _context = new AccountingDataContext();
            _categoryService = new CategoryService(_context);
        }

 public Category(string name, long categoryId, long parentId, CategoryType type, double seqNo)
 {
     this.categoryId = categoryId;
     this.name = name;
     this.parentId = parentId;
     this.type = type;
     this.seqNo = seqNo;
 }

 public long Add(string name, long parentId, CategoryType type)
 {
     string query = QueryBuilder.Insert("categories", GetNameColumnPair(name),
                                                           GetParentIdColumnPair(parentId),
                                                           GetTypeColumnPair(type));
     using (SQLiteCommand insert = new SQLiteCommand(query, m_conn))
         return (long) insert.ExecuteScalar();
 }

 /// <summary>
 /// 
 /// </summary>
 public CategoryFeatureType getCategoryFeature(SiteCodeType site, CategoryType category)
 {
     Hashtable myCategoryMap = (Hashtable)_categoryFeaturesBySite[site];
      if(myCategoryMap != null) {
      return (CategoryFeatureType)myCategoryMap[category];
      }
      return null;
 }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="ID"></param>
 /// <param name="nickName"></param>
 /// <param name="age"></param>
 /// <param name="category"></param>
 /// <param name="gender"></param>
 /// <param name="canFly"></param>
 public Insect(string ID, string nickName, int age, CategoryType category, GenderType gender, bool canFly)
 {
     // TODO: Complete member initialization
     this.ID = ID;
     this.NickName = nickName;
     this.Age = age;
     this.Category = category;
     this.Gender = gender;
     this.canFly = canFly;
 }

 private void Add(CodeBaseActionProxy action, CategoryType categoryType)
 {
     Category category;
     if(_categoriesByType.ContainsKey(categoryType))
         category = _categoriesByType[categoryType];
     else {
         category = new Category(categoryType);
         _categoriesByType[categoryType] = category;
     }
     category.Items.Add(action);
 }

 /// <summary>
 /// Translates the enumerated ValueType into the string prefixed used within the dictionary
 /// </summary>
 /// <param name="valueType">Enumeration value of the type</param>
 /// <returns>Enumerated ValueType into the string prefixed used within the dictionary</returns>
 private static string GetPrefix(CategoryType valueType)
 {
     switch (valueType)
     {
         case CategoryType.AlarmStates:          return AlarmStatesPrefix;
         case CategoryType.FaultCodes:           return FaultCodesPrefix;
         case CategoryType.BooleanTypes:         return BooleanTypesPrefix;
         case CategoryType.ConditionStates:      return ConditionStatePrefix;
         default: return InvalidPrefix;
     }
 }

 /// <summary>
 /// Constructor overloaded
 /// </summary>
 /// <param name="p"></param>
 /// <param name="p_2"></param>
 /// <param name="category"></param>
 /// <param name="gender"></param>
 /// <param name="wingSpan"></param>
 /// <param name="quaranteen"></param>
 /// <param name="numberOfDays"></param>
 public Bird(string p, string p_2, CategoryType category, GenderType gender, double wingSpan, bool quaranteen, int numberOfDays)
 {
     // TODO: Complete member initialization
     this.p = p;
     this.p_2 = p_2;
     this.Category = category;
     this.Gender = gender;
     this.wingSpan = wingSpan;
     this.quaranteen = quaranteen;
     this.NumberOfDays = numberOfDays;
 }

        public List<Product> GetProductByPage(int Page, int PageSize, CategoryType ct, bool IsDESC)
        {
            SqlParameter[] sprms = new SqlParameter[] {
                                        new SqlParameter("@CategoryType", ct.ToString()),
                                        new SqlParameter("@PageNumber",Page),
                                        new SqlParameter("@PageSize",PageSize)
            };

            DataTable dt = _dataAccess.Query("ProductAPI_GetProductsByPage", sprms);
            return EntityHelper<Product>.ConvertToList(dt);
        }

 public CMS(AEvent aDevice, CategoryType type, System.Collections.Hashtable ht, DeviceType devType, System.Collections.Hashtable DevRange, Degree degree)
 {
     Initialize(aDevice, type, ht, devType, DevRange, degree);
     this.GetMessRuleData += new GetMessRuleDataHandler(CMS_GetMessRuleData);
     List<object> messColors = (List<object>)com.select(DBConnect.DataType.MessColor, Command.GetSelectCmd.getMessColor());
     messColorsHT = new System.Collections.Hashtable();
     foreach (object obj in messColors)
     {
         MessColor mess = (MessColor)obj;
         messColorsHT.Add(mess.ID, mess);
     }
 }

        ///////////////////////////////////////////////////////////////////////////////////////////////////
        ////////////BUILD FROM V2.1 SCHEMA                 //////////////////////////////////////////////////
        ///////////////////////////////////////////////////////////////////////////////////////////////////

        /// <summary>
        /// Initializes a new instance of the <see cref="CategoryCore"/> class.
        /// </summary>
        /// <param name="parent">
        /// The parent. 
        /// </param>
        /// <param name="category">
        /// The sdmxObject. 
        /// </param>
        public CategoryCore(IIdentifiableObject parent, CategoryType category)
            : base(category, SdmxStructureType.GetFromEnum(SdmxStructureEnumType.Category), parent)
        {
            this._categories = new List<ICategoryObject>();
            if (category.Item != null)
            {
                foreach (Category currentCat in category.Item)
                {
                    this._categories.Add(new CategoryCore(this, currentCat.Content));
                }
            }
        }

 public static Category BuildCategory(AccountingUser user, CategoryType catType = null, TransactionType transType = null, Category parentCategory = null)
 {
     return new Category
     {
         AccountingUser = user,
         CategoryType = catType == null ? new CategoryType
         {
             Name = "TestCategoryType"
         } : catType,
         ParentCategory = parentCategory,
     };
 }

 internal RssLink CreateCategory(string name, string url, string thumbUrl, CategoryType categoryType, string description, Category parentCategory)
 {
     RssLink category = new RssLink();
     category.Name = name;
     category.Url = url;
     category.Thumb = thumbUrl;
     category.Other = categoryType;
     category.Description = description;
     category.HasSubCategories = categoryType != CategoryType.None;
     category.SubCategoriesDiscovered = false;
     category.ParentCategory = parentCategory;
     return category;
 }

 public static bool IsPositive(CategoryType type)
 {
     switch (type)
     {
         case CategoryType.Expense:
         case CategoryType.TransferOut:
             return false;
         case CategoryType.Income:
         case CategoryType.TransferIn:
             return true;
     }
     Debug.Assert(false);
     return false;
 }