public ProductFactory(Parameters parameters)
            {
                try
                {
                    using (var server = new VentsCad())
                    {
                        switch (parameters.Name)
                        {
                            case "spigot":                                
                                product = new Spigot(parameters.Type.SubType, parameters.Sizes[0].Width, parameters.Sizes[0].Height);
                                break;
                            case "dumper":
                                var material = new string[] { parameters.Materials[0].Value, parameters.Materials[0].Thikness, parameters.Materials[0].Name, parameters.Materials[0].Code };
                                product = new Dumper(parameters.Type.SubType, parameters.Sizes[0].Width, parameters.Sizes[0].Height, true, material);
                                break;
                            case "montageFrame":                                
                                product = new MontageFrame(parameters.Type.SubType, parameters.Sizes[0].Width, parameters.Sizes[0].Lenght, parameters.Sizes[0].Additional1, parameters.Materials[0]);
                                break;
                            default:
                                break;
                        }
                    }
                }
                catch (System.Exception ex)
                {
                    MessageBox.Show(ex.Message + "\n" + ex.StackTrace);
                }

                
            }

        public Product SelectByProductID(int ProductID)
        {
            string query = "select * from Product WHERE ProductID = @ProductID";
            List<SqlParameter> lstParams = new List<SqlParameter>();
            lstParams.Add(new SqlParameter("@ProductID", ProductID));

            DataTable dt = DBUtility.SelectData(query, lstParams);

            Product objProduct = new Product();
            if (dt.Rows.Count > 0)
            {
                objProduct.Name = dt.Rows[0]["Name"].ToString();
                objProduct.CreateDate = Convert.ToDateTime(dt.Rows[0]["CreateDate"]);
                objProduct.DesignFiles = dt.Rows[0]["DesignFiles"].ToString();
                objProduct.Status = dt.Rows[0]["Status"].ToString();
                objProduct.Description = dt.Rows[0]["Description"].ToString();
                objProduct.Size = dt.Rows[0]["Size"].ToString();
                objProduct.Colors = dt.Rows[0]["Colors"].ToString();
                objProduct.Type = dt.Rows[0]["Type"].ToString();
                objProduct.CustomerID = Convert.ToInt32(dt.Rows[0]["CustomerID"]);
                objProduct.ProductID = Convert.ToInt32(dt.Rows[0]["ProductID"]);
              
            }

            return objProduct;
        }

        public SingleProductViewModel(Product p, MerchantTribeApplication mtapp)
        {
            var profiler = MiniProfiler.Current;

            using (profiler.Step("Price Product " + p.ProductName))
            {
                this.UserPrice = mtapp.PriceProduct(p, mtapp.CurrentCustomer, null, mtapp.CurrentlyActiveSales);
            }
            this.IsFirstItem = false;
            this.IsLastItem = false;
            this.Item = p;
            using (profiler.Step("Image Url Product" + p.ProductName))
            {
                this.ImageUrl = MerchantTribe.Commerce.Storage.DiskStorage.ProductImageUrlSmall(
                    mtapp,
                    p.Bvin,
                    p.ImageFileSmall,
                    mtapp.IsCurrentRequestSecure());
            }
            using (profiler.Step("Product Link " + p.ProductName))
            {
                this.ProductLink = UrlRewriter.BuildUrlForProduct(p,
                                                mtapp.CurrentRequestContext.RoutingContext,
                                                string.Empty);
            }
        }

        public ActionResult CreateProduct(Product p, HttpPostedFileBase file)
        {
            string imgPath = "/Content/images/product";
            string path = "";
            if (ModelState.IsValid)
            {
                if (file != null)
                {
                    string pic = System.IO.Path.GetFileName(file.FileName);
                    path = System.IO.Path.Combine(
                                           Server.MapPath("~" + imgPath), pic);
                    // file is uploaded
                    file.SaveAs(path);
                    p.ProductPictureUrl = imgPath + "/" + file.FileName;
                }

                p.CreatedDate = DateTime.Now;
                _productRepository.Add(p);
                _productRepository.Save();
                int i = p.ProductId;
                return Json(i);
            }
            else
            {
                int wrongData = -2;
                return Json(wrongData);
            }
        }

    protected void btnAdd_Click(object sender, EventArgs e)
    {
        selectedProduct = new Product();
        this.selectedProduct.Course_id = course_id.ToString();

        if (Page.IsValid)
        {
            CartItemList cart = CartItemList.GetCart();
            int locCount = cart.Count;
            locCount = locCount + 1;
            this.selectedProduct.assignmentNumber = locCount.ToString();
            this.selectedProduct.aGUID = Guid.NewGuid().ToString();
            this.selectedProduct.Num_Assignment = locCount;
            CartItem cartItem = new CartItem();

            int Num_Assignments=0;
            int assignment = 1; //will be produced from loop according to Num_Assignments
            cart = CartItemList.GetCart();
            cartItem = cart[selectedProduct.Course_id];

            if (cartItem == null)
            {
                cart.AddItem(selectedProduct, Num_Assignments,assignment);
            }
            else
            {
                cart.AddItem(selectedProduct, Num_Assignments, assignment);
                cartItem.AddQuantity(1);
            }
            this.DisplayCart();

        }
    }

        public void AddToCart(Product product, decimal price)
        {
            // Get the matching cart and product instances
            var cartItem = db.CartItems.SingleOrDefault(
                c => c.CartID == ShoppingCartId
                && c.ProductID == product.ProductID);

            if (cartItem == null)
            {
                // Create a new cart item if no cart item exists
                cartItem = new CartItem
                {
                    ProductID = product.ProductID,
                    CartID = ShoppingCartId,
                    Amount = 1,
                    Price = price,
                    Creation = DateTime.Now
                };

                db.CartItems.AddObject(cartItem);
            }
            else
            {
                // If the item does exist in the cart, then add one to the quantity
                cartItem.Amount++;
            }

            // Save changes
            db.SaveChanges();
        }

        public void CanStoreAProduct()
        {
            //Database.SetInitializer(new DropCreateDatabaseAlways<CoffeeShopContext>());
              long id;
              using (var session = sessionFactory.OpenSession())
              using (var tx = session.BeginTransaction())
              {
            var repository = new Repository<Product>(session);
            var product = new Product
                      {
                        Name = "Coffee 1",
                        Price = 10.4m
                      };

            repository.MakePersistent(product);
            id = product.Id;
            tx.Commit();
              }

              using (var session = sessionFactory.OpenSession())
              using (session.BeginTransaction())
              {
            var repository = new Repository<Product>(session);
            Product product = repository.GetById(id);

            product.Satisfy(p => p.Name == "Coffee 1" && p.Price == 10.4m);
              }
        }

        public bool IsSatisfiedBy(Product product)
        {
            if (_sizeIds.Count() > 0 )
                return _sizeIds.Any(s => product.Title.Products.Any(p => p.Size.Id == s));

            return true;
        }

        public static void add(Product product)
        {
            var existingProduct = false;
            Product fetchedProduct;

            if (product.Id != 0)
            {
                throw new
                Exception(@"Posted products cannot
              contain an id");
            }

            try
            {
                fetchedProduct = get(product.Name);
                existingProduct = true;
            }
            catch (Exception)
            {
                //this is actually good that we are here. Means we didn't
                //find an existing product so it is OK to insert;
                product.Id = ProductsRepository.data.Select(x => x.Id).Max() + 1;

                var data = ProductsRepository.data.ToList();
                data.Add(product);
                ProductsRepository.data = data;
            }

            if (existingProduct)
            {
                throw new
                Exception(@"The product name you are
              attempting to insert already exists.");
            }
        }

        public void TestActiveAtSpecification()
        {
            var productSpecification1 = new ProductSpecification
            {
                ActiveFrom = DateTime.Now.AddDays(-3),
                ActiveUntil = DateTime.Now.AddDays(3)
            };

            var productSpecification2 = new ProductSpecification
            {
                ActiveFrom = DateTime.Now.AddDays(-6),
                ActiveUntil = DateTime.Now.AddDays(-3)
            };

            var productSpecification3 = new ProductSpecification
            {
                ActiveFrom = DateTime.Now.AddDays(-9),
                ActiveUntil = DateTime.Now.AddDays(-6)
            };

            var product = new Product
            {
                ProductSpecifications =
                    new Collection<ProductSpecification>
                                  {
                                      productSpecification1,
                                      productSpecification2,
                                      productSpecification3
                                  }
            };

            var actual = product.ActiveAt(DateTime.Now.AddDays(-8));

            Assert.AreEqual(productSpecification3, actual);
        }

 public void deleteProduct(Product p)
 {
     if (db.Products.Contains(p)&& p!=null)
     {
         db.Products.Remove(p);
     }
 }

 public void activeSelect(User _user, Product _product)
 {
     if (_product.Active == false)
     {
         throw new NonActiveProductException(_user, _product);
     }
 }

        internal static void ImportTags(Product product, List<string> tagsList, UploadConfig config)
        {
            TaxonomyManager taxonomyManager = TaxonomyManager.GetManager();
            CatalogManager catalogManager = CatalogManager.GetManager();

            FlatTaxonomy tagsTaxonomy = taxonomyManager.GetTaxonomies<FlatTaxonomy>().Where(t => t.Name == "Tags").SingleOrDefault();

            foreach (var tagString in tagsList)
            {
                try
                {
                    Taxon tag = GetTagIfItExsistsOrCreateOneIfItDoesnt(tagString, tagsTaxonomy, taxonomyManager);

                    SetTagProperties(tag, tagString);

                    taxonomyManager.SaveChanges();

                    if (product.Organizer.TaxonExists("Tags", tag.Id) == true)
                    {
                        continue;        // Product already linked to Tag
                    }

                    product.Organizer.AddTaxa("Tags", tag.Id);

                    catalogManager.SaveChanges();
                }
                catch
                {
                    //catching so even if one fails rest goes on
                }
            }
        }

        public ActionResult EditProduct(Product product)
        {
            products.Update(product);
            products.Commit();

            return RedirectToAction("ProductList");
        }

        private string GetProduct(TextBox txtProductID,
                          ref Product product)
        {
            string result = "";

            try
            {
                int productID = Int32.Parse(txtProductID.Text);
                var client = new ProductServiceClient();
                product = client.GetProduct(productID);

                var sb = new StringBuilder();
                sb.Append("ProductID:" +
                    product.ProductID.ToString() + "\n");
                sb.Append("ProductName:" +
                    product.ProductName + "\n");
                sb.Append("UnitPrice:" +
                    product.UnitPrice.ToString() + "\n");
                sb.Append("RowVersion:");
                foreach (var x in product.RowVersion.AsEnumerable())
                {
                    sb.Append(x.ToString());
                    sb.Append(" ");
                }
                result = sb.ToString();

            }
            catch (Exception ex)
            {
                result = "Exception: " + ex.Message.ToString();
            }

            return result;
        }

        public static List<Product> GetProductsByPartialName(string partialName)
        {
            List<Product> results = new List<Product>(); //empty list

            string query = "SELECT ProductCode, Name " +
                           "FROM Products " +
                           "WHERE Name LIKE @PartialName " +
                           "ORDER BY ProductCode";

            using (SqlConnection con = new SqlConnection(GetConnectionString()))
            {
                using (SqlCommand cmd = new SqlCommand(query, con))
                {
                    cmd.Parameters.AddWithValue("@PartialName", "%" + partialName + "%");

                    con.Open();
                    using (SqlDataReader reader = cmd.ExecuteReader())
                    {
                        while (reader.Read()) //while there is still another record
                        {
                            Product p = new Product();
                            p.ProductCode = reader["ProductCode"].ToString();
                            p.Name = reader["Name"].ToString();
                            results.Add(p); //add to the list
                        }
                    }
                }
            }

            return results;
        }

		public virtual void EmbeddingOfInstanceOfCustomReferenceTypeWithFieldsIsCorrect()
		{
			// Arrange
			var product = new Product
			{
				Name = "Red T-shirt",
				Price = 995.00
			};

			const string updateCode = "product.Price *= 1.15;";

			const string input1 = "product.Name";
			const string targetOutput1 = "Red T-shirt";

			const string input2 = "product.Price";
			const double targetOutput2 = 1144.25;

			// Act
			string output1;
			double output2;

			using (var jsEngine = CreateJsEngine())
			{
				jsEngine.EmbedHostObject("product", product);
				jsEngine.Execute(updateCode);

				output1 = jsEngine.Evaluate<string>(input1);
				output2 = jsEngine.Evaluate<double>(input2);
			}

			// Assert
			Assert.AreEqual(targetOutput1, output1);
			Assert.AreEqual(targetOutput2, output2);
		}

 public AdminProductViewModel(Product product)
 {
     ProductID = product.ProductID;
       BrandID = product.BrandID;
       Condition = product.ProductConditions.FirstOrDefault().ProductConditionID;
       Gender = product.Gender;
       ProductName = product.ProductName;
       ModelName = product.ModelName;
       ModelNumber = product.ModelNumber;
       SerialNumber = product.SerialNumber;
       CaseSize = product.CaseSize;
       CaseMaterial = product.CaseMaterial;
       Bezel = product.Bezel;
       Crystal = product.Crystal;
       DialColour = product.DialColour;
       Movement = product.Movement;
       Functions = product.Functions;
       Strap = product.Strap;
       WaterResistant = product.WaterResistant;
       RetailPrice = product.RetailPrice;
       BoxPapers = product.BoxPapers;
       Warranty = product.Warranty;
       ProductImages = new List<AdminProductImageViewModel>();
       foreach (ProductImage image in product.ProductImages) {
     ProductImages.Add(new AdminProductImageViewModel(image));
       }
       NewArrival = product.NewArrival.GetValueOrDefault();
       HotDeal = product.HotDeal.GetValueOrDefault();
       Sold = product.Sold.GetValueOrDefault();
 }

		public void Init()
		{
			var en = CultureInfo.CreateSpecificCulture("en");

			Thread.CurrentThread.CurrentCulture	= en;
			Thread.CurrentThread.CurrentUICulture = en;

			helper = new FormHelper();

			subscription = new Subscription();
			mock = new MockClass();
			months = new[] {new Month(1, "January"), new Month(1, "February")};
			product = new Product("memory card", 10, (decimal) 12.30);
			user = new SimpleUser();
			users = new[] { new SimpleUser(1, false), new SimpleUser(2, true), new SimpleUser(3, false), new SimpleUser(4, true) };
			mock.Values = new[] { 2, 3 };

			var controller = new HomeController();
			var context = new ControllerContext();

			context.PropertyBag.Add("product", product);
			context.PropertyBag.Add("user", user);
			context.PropertyBag.Add("users", users);
			context.PropertyBag.Add("roles", new[] { new Role(1, "a"), new Role(2, "b"), new Role(3, "c") });
			context.PropertyBag.Add("sendemail", true);
			context.PropertyBag.Add("confirmation", "abc");
			context.PropertyBag.Add("fileaccess", FileAccess.Read);
			context.PropertyBag.Add("subscription", subscription);
			context.PropertyBag.Add("months", months);
			context.PropertyBag.Add("mock", mock);

			helper.SetController(controller, context);
		}

        public ActionResult Add([Bind(Prefix = "AddForm")] ProductsAddForm form)
        {
            var model = new ProductsAddViewModel { AddForm = form };

            if (ModelState.IsValid)
            {
                using (var transaction = _session.BeginTransaction())
                {
                    var product = new Product
                                  {
                                      Name = form.Name,
                                      Description = form.Description ?? string.Empty
                                  };

                    var primaryVariant = new ProductVariant
                                         {
                                             Price = form.Price.Value,
                                             Sku = form.Sku ?? string.Empty,
                                             Product = product
                                         };

                    product.Variants = new[] { primaryVariant };

                    _session.Save(product);
                    transaction.Commit();
                    return RedirectToAction("View", new { id = product.Id });
                }
            }

            SetupAddViewModel(model);
            return View(model);
        }