public static Product FindProduct(ProductType type, string product, string version, string revision)
        {
            var products = type == ProductType.Standalone ? ProductManager.StandaloneProducts : ProductManager.Modules;
              if (!string.IsNullOrEmpty(product))
              {
            products = products.Where(x => x.Name.Equals(product, StringComparison.OrdinalIgnoreCase));
              }

              if (!string.IsNullOrEmpty(version))
              {
            products = products.Where(x => x.Version == version);
              }
              else
              {
            products = products.OrderByDescending(x => x.Version);
              }

              if (!string.IsNullOrEmpty(revision))
              {
            products = products.Where(x => x.Revision == revision);
              }
              else
              {
            products = products.OrderByDescending(x => x.Revision);
              }

              var distributive = products.FirstOrDefault();
              return distributive;
        }

        public int CreateUpdateProductTypeServices(ProductType ud)
        {
            int ProductTypeID = 0;
            using (FDBEntities db = new FDBEntities())
            {
                if (ud.ProductTypeID > 0)
                {
                    ProductType temp = db.ProductTypes.Where(u => u.ProductTypeID == ud.ProductTypeID).FirstOrDefault();

                    if (temp != null)
                    {
                        temp.Description = ud.Description;
                    }
                }
                else
                {
                    db.ProductTypes.Add(ud);
                }

                int x = db.SaveChanges();
                if (x > 0)
                {
                    ProductTypeID = ud.ProductTypeID;
                }
            }

            return ProductTypeID;
        }

    private ProductType createProductType() {
        ProductType p = new ProductType();

        p.Name = txtName.Text;

        return p;
    }

 public InappProductStrings(string pdtId, ProductType pdtType, string shortName)
 {
     DefaultProductId = pdtId;
     DefaultProductType = pdtType;
     DefaultProductShortName = shortName;
     //OverrideIdsByStore = new Dictionary<string, List<string>>();
 }

 private void LoadCB()
 {
     ProductType product = new ProductType();
     typeCB.DataSource = product.GetAllProductTypeQuery();
     typeCB.DisplayMember = "Name";
     typeCB.ValueMember = "ID";
 }

 // Dependency to ensure product have necessary values.
 public Product(string code, string name, ProductType type, float price)
 {
     Code = code;
     Name = name;
     Type = type;
     Price = price;
 }

        /// <summary>
        /// Creates a new LineItem
        /// </summary>
        /// <param name="title">A title describing the product </param>
        /// <param name="price">The product price in the currency matching the one used in the whole order and set in the "Currency" field</param>
        /// <param name="quantityPurchased">Quantity purchased of the item</param>
        /// <param name="productId">The Product ID number (optional)</param>
        /// <param name="sku">The stock keeping unit of the product (optional)</param>
        public LineItem(string title,
            double price,
            int quantityPurchased,
            //optional
            string productId = null,
            string sku = null,
            string condition = null,
            bool? requiresShipping = null,
            Seller seller = null,
            DeliveredToType? deliveredTo = null,
            DateTime? delivered_at = null,
            ProductType? productType = null,
            string brand = null,
            string category = null,
            string subCategory = null)
        {
            Title = title;
            Price = price;
            QuantityPurchased = quantityPurchased;

            // optional
            ProductId = productId;
            Sku = sku;
            Condition = condition;
            RequiresShipping = requiresShipping;
            Seller = seller;
            DeliveredTo = deliveredTo;
            ProductType = productType;
            Category = category;
            SubCategory = subCategory;
            DeliveredAt = delivered_at;
            Brand = brand;
        }

 public ProductTypeRowModel(ProductType type)
 {
     this.Id = type.Id;
     this.Name = type.Name;
     this.SkuAlias = type.SkuAlias;
     this.IsEnabled = type.IsEnabled;
 }

        public static Product Create(ProductType productType)
        {
            Product product = null;

            switch (productType)
            {
                case ProductType.Apple:
                    {
                        product = new AppleProduct();
                        break;
                    }
                case ProductType.Berry:
                    {
                        product = new BerryProduct();
                        break;
                    }
                case ProductType.Cherry:
                    {
                        product = new CherryProduct();
                        break;
                    }
            }

            return product;
        }

 private ProductType createProductType()
 {
     //access productType db
     ProductType p = new ProductType();
     p.TypeDescreption = TextBoxProductDesc.Text;
     return p;
 }

        private ProductType CreateProductType()
        {
            ProductType p = new ProductType();
            p.TName = txtbox_TName.Text;

            return p;
        }

    /// <summary>
    /// Submit button click event
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void btnSubmit_Click(object sender, EventArgs e)
    {
        ProductTypeAdmin prodTypeAdmin = new ProductTypeAdmin();
        ProductType prodType = new ProductType();
        prodType.ProductTypeId = ItemId;
        prodType.PortalId  = ZNodeConfigManager.SiteConfig.PortalID ;
        prodType.Name = Name.Text;
        prodType.Description = Description.Text;
        prodType.DisplayOrder = Convert.ToInt32(DisplayOrder.Text);

        bool check = false;

        if (ItemId > 0)
        {

            check = prodTypeAdmin.Update(prodType);
        }
        else
        {
            check = prodTypeAdmin.Add(prodType);
        }

        if (check)
        {
            //redirect to main page
            Response.Redirect("list.aspx");
        }
        else
        {
            //display error message
            lblError.Text = "An error occurred while updating. Please try again.";
        }
    }

        private ProductType CreateProductType()
        {
            ProductType item = new ProductType();
            item.Name = CategoryName.Text;

            return item;
        }

 public Product(string productCode, string productName, string quotaType, ProductType productType, int quantity)
 {
     this.ProductName = productName;
     this.Quantity = quantity;
     this.ProductCode = productCode;
     this.QuotaType = quotaType;
     this.ProdType = productType;
 }

 protected FarmUnit(string id, int health, int productionQuantity, 
     ProductType productType, int healthEffect)
     : base(id)
 {
     this.Health = health;
     this.ProductionQuantity = productionQuantity;
     this.ProductType = productType;
     this.healthEffect = healthEffect;
 }

        public List<ImportErrorMessage> InsertImportPriceListRecord(CanonDataContext db)
        {
            List<ImportErrorMessage> warnings = new List<ImportErrorMessage>();

            // CanonDataContext db = Cdb.Instance;

            // Create Product Group if it doesn't exist yet
            ProductGroup productGroup = db.ProductGroups.FirstOrDefault(pg => pg.Code == this.ProductCategory);
            if (productGroup == null)
            {
                productGroup = new ProductGroup();
                productGroup.Code = this.ProductCategory;
                productGroup.FileAs = "Nová_" + this.ProductCategory;

                db.ProductGroups.InsertOnSubmit(productGroup);
            }

            // create Product type if it doesn't exist in DB yet
            ProductType pType = db.ProductTypes.FirstOrDefault(pt => pt.Type == this.ProductType);
            if (pType == null)
            {
                pType = new ProductType();
                pType.Type = this.ProductType;

                db.ProductTypes.InsertOnSubmit(pType);
            }

            // update product
            Product product = db.Products.FirstOrDefault(p => p.ProductCode == this.ProductCode);
            if (product == null)
            {
                product = new Product();
                product.IsActive = true;

                db.Products.InsertOnSubmit(product);
            }

            product.ProductCode = this.ProductCode;
            product.ProductName = this.ProductName;
            product.ProductGroup = productGroup;
            product.CurrentPrice = this.ListPrice;
            product.ProductType = pType;

            // insert ImportPriceListRecord
            ImportPriceListRecord record = new ImportPriceListRecord();
            record.IDImportPriceList = this.ImportPriceList.ID;
            record.ListPrice = this.ListPrice;
            record.ProductCode = this.ProductCode;
            record.ProductName = this.ProductName;
            record.ProductCategory = this.ProductCategory;
            record.ProductType = this.ProductType;

            db.ImportPriceListRecords.InsertOnSubmit(record);
            db.SubmitChanges();

            return warnings;
        }

        public void Update(ProductType productType)
        {
            //Fetch object from db
            ProductType p = db.ProductTypes.Find(productType.ID);

            p.Name = productType.Name;

            db.SaveChanges();
        }

 public BuyCommand(Guid id, Guid tradingDayId, Tso tso, ProductType productType, DateTime begin, decimal volume)
 {
     Id = id;
     TradingDayId = tradingDayId;
     Tso = tso;
     ProductType = productType;
     Begin = begin;
     Volume = volume;
 }

 protected FarmUnit(string id, int health, int productionQuantity, ProductType productType)
     : base(id)
 {
     this.productId = id + "Product";
     this.Health = health;
     this.ProductionQuantity = productionQuantity;
     this.productType = productType;
     this.isAlive = true;
 }

 public void CalcSalesTaxTest()
 {
     ProductType productType = new ProductType(); // TODO: Initialize to an appropriate value
     Decimal expected = 110.0m;
     Decimal actual;
     actual = Class1.CalcSalesTax(productType);
     Assert.AreEqual(expected, actual);
     Assert.Inconclusive("Verify the correctness of this test method.");
 }