public void ProductRepository_UpdateProduct_1IfUpdate()
 {
     ProductRepository produtoRepository = new ProductRepository();
     int actual = produtoRepository.Updates(new Product { ProductID = 1, Name = "Gurte IceCream", CategoryID = 1, Code = "200", PurchasePrice = 1, SalePrice = 2, Stock = new Stock { ProductID = 1, ManageStock = true, MaximunQuantity = 200, MinimunQuantity = 20 } });
     //ClearConnection();
     Assert.AreEqual(1, actual);
 }

        // GET: Product
        public ActionResult Index(string sort = "Name", bool sortReverse = false, int pageNumber = 1, string searchFor = "")
        {
            ViewBag.CurrentSort = sortReverse;

            using (var productRep = new ProductRepository())
            {
                ViewBag.OnePageOfProducts = ((List<Product>)productRep.Get(sort, ViewBag.CurrentSort, searchFor)).ToPagedList(pageNumber, 10);
            }

            var allProducts = new List<ProductViewModel>();
            foreach (var item in ViewBag.OnePageOfProducts)
            {
                allProducts.Add(new ProductViewModel()
                {
                    Id = item.Id,
                    Name = item.Name,
                    Description = item.Description,
                    Preco = item.Preco,
                    PhotoOutput = item.Photo == null ? string.Empty : 
                        String.Format("data:image/gif;base64,{0}", Convert.ToBase64String(item.Photo))
                });
            }

            ViewBag.AllProducts = allProducts;

            return View();
        }

 public void ProductRepository_GetAll_1()
 {
     ProductRepository produtoRepository = new ProductRepository();
     int actual = produtoRepository.GetAlls().Count();
     //ClearConnection();
     Assert.AreEqual(0, actual);
 }

 public void ProductRepository_GetByID_GurteIceCream()
 {
     ProductRepository produtoRepository = new ProductRepository();
     Product actual = produtoRepository.GetByIds(1);
     //ClearConnection();
     Assert.AreEqual("Gurte IceCream",actual.Name);
 }

 public SubscriptionController()
 {
     _repo = new VetRepository(new FnRDbContext());
     _subRepo = new SubscriptionRepository(new FnRDbContext());
     _userRepo = new UserRepository(new FnRDbContext());
     _productRepo = new ProductRepository(new FnRDbContext());
 }

 public void ProductRepository_CreateProduct_2IfCreate()
 {
     ProductRepository produtoRepository = new ProductRepository();
     int actual = produtoRepository.Creates(new Product { Name = "Choco IceCream", CategoryID = 1, Code = "200", PurchasePrice = 1, SalePrice = 2, Stock = new Stock { ManageStock = true, MaximunQuantity = 200, MinimunQuantity = 20 } });
        // ClearConnection();
     Assert.AreEqual(2, actual);
 }

		//[TestMethod]
		public void FindAllProducts()
		{
			ProductRepository repository = new ProductRepository();
			var ret = repository.FindAll();
			repository = new ProductRepository();
			ret = repository.FindAll();
		}

        public void SaveProduct_CreateNewProduct_NewProductShouldBeInsertedToDatabase()
        {
            int id = -1;

            var expected = new GGTestProduct
            {
                Name = "Test Product",
                Category = "Test Category",
                IsExpired = true
            };

            using (var repository = new ProductRepository())
            {
                id = repository.SaveProduct(expected);
            }

            // Verify result
            GGTestProduct actual;

            using (var session = NHibernateHelper.OpenSession())
            {
                actual = session.Get<GGTestProduct>(id);
            }

            Assert.AreEqual(expected.Name, actual.Name);
            Assert.AreEqual(expected.Category, actual.Category);
            Assert.AreEqual(expected.IsExpired, actual.IsExpired);
        }

        public static void Clear()
        {
            IRepository<Client> _clientRepository = new ClientRepository();
            IRepository<Product> _productRepository = new ProductRepository();
            IRepository<Manager> _managerRepository = new ManagerRepository();

            IEnumerable<Client> clientRepository = _clientRepository.GetItems();
            IEnumerable<Product> productRepository = _productRepository.GetItems();
            IEnumerable<Manager> managerRepository = _managerRepository.GetItems();

            foreach (var item in clientRepository)
            {
                _clientRepository.Remove(item);
            }

            foreach (var item in productRepository)
            {
                _productRepository.Remove(item);
            }

            foreach (var item in managerRepository)
            {
                _managerRepository.Remove(item);
            }
        }

 // PUT api/products/5
 public IEnumerable<Product> Put(int id, [FromBody]Product value)
 {
     ProductRepository repo = new ProductRepository();
     value.ProductId = id;
     repo.Update(value);
     return repo.Retrieve();
 }

        public void ProductRepositoryAddNewItemSaveItem()
        {
            //Arrange
            var unitOfWork = new MainBCUnitOfWork();
            IProductRepository productRepository = new ProductRepository(unitOfWork);

            var book = new Book()
            {
                Id = IdentityGenerator.NewSequentialGuid(),
                ISBN = "ABC",
                Publisher = "Krasiss Press",
                Title = "The book title",
                UnitPrice = 40,
                Description = "Any book description",
                AmountInStock = 1
            };

            //Act

            productRepository.Add(book);
            productRepository.UnitOfWork.Commit();

            //Assert

            var result = productRepository.Get(book.Id);

            Assert.IsNotNull(result);
            Assert.IsTrue(result.Id == book.Id);
        }

 // GET: Product/Details/5
 public ActionResult Details(int id)
 {
     using (var productRep = new ProductRepository())
     {
         return View(productRep.GetById(id));
     }
 }

        public IHttpActionResult Get(int id)
        {
            try
            {
                Product product;
                var productRepository = new ProductRepository();
                if (id > 0)
                {
                    var products = productRepository.Retrieve();
                    product = products.FirstOrDefault(p => p.ProductId == id);
                    if (product == null)
                    {
                        return NotFound();
                    }
                }
                else
                {
                    product = productRepository.Create();
                }
                return Ok(product);
            }
            catch (Exception ex)
            {

                return InternalServerError(ex);
            }
        }

        public void Update_Product0_name_to_nill()
        {

            
            AutoMapper.Mapper.CreateMap<DataAvail.UralAppModel.Product, Product>()
                .ForMember(p => p.id, opt => opt.MapFrom(p => p.Id))
                .ForMember(p => p.name, opt => opt.MapFrom(p => p.Name));

            AutoMapper.Mapper.CreateMap<Product, DataAvail.UralAppModel.Product>()
                .ForMember(p => p.Id, opt => opt.MapFrom(p => p.id))
                .ForMember(p => p.Name, opt => opt.MapFrom(p => p.name));

            Product product = new Product { id = 0, name = "hip" };

            using (var model = new UralAppModel.Model())
            {
                ProductRepository repo = new ProductRepository();

                repo.SetContext(model);

                repo.GetAll(new Microsoft.Data.Services.Toolkit.QueryModel.ODataQueryOperation());

                repo.Save(product);
            }


            /*
            UralAppServ.DataServiceProvider prr = new UralAppServ.DataServiceProvider(new Uri(@"http://localhost:3360/Service.svc/"));
            var r = prr.Products.Where(p => p.id == 0).First();
            r.name = "nill";
            //prr.AttachTo("Products", r);
            prr.UpdateObject(r);
            prr.SaveChanges();
             */
        }

        public ActionResult Index(int pageNumber = 1)
        {
            using (var productRep = new ProductRepository())
            {
                ViewBag.OnePageOfProducts = productRep.Get().ToPagedList(pageNumber, 8);
            }

            var allProducts = new List<ProductViewModel>();
            foreach (var item in ViewBag.OnePageOfProducts)
            {
                allProducts.Add(new ProductViewModel()
                {
                    Id = item.Id,
                    Name = item.Name,
                    Description = item.Description,
                    Preco = item.Preco,
                    PhotoOutput = item.Photo == null ? string.Empty :
                        String.Format("data:image/gif;base64,{0}", Convert.ToBase64String(item.Photo))
                });
            }

            var countProducts = allProducts.Count();

            ViewBag.FirstRowOfProductList = countProducts.Equals(0) ? null : allProducts.Take(4);
            if (countProducts > 4)
                ViewBag.SecondRowOfProductList = countProducts.Equals(0) ? null : allProducts.GetRange(4, countProducts - 4);

            return View();
        }

 public TradeController()
 {
     this.saleRep = new SaleRepository();
     this.managerRep = new ManagerRepository();
     this.productRep = new ProductRepository();
     formattedSales = new List<FormattedSale>();
 }

        //
        // GET: /Shop/
        public ActionResult Index()
        {
            var rep = new ProductRepository();
            var list = rep.Table.ToList();

            return View();
        }

 public CatalogTasksImplementation(DepartmentRepository department_repository, DepartmentItemMapper departmentItemMapper, ProductRepository product_repository, ProductItemMapper product_item_mapper)
 {
     this.department_repository = department_repository;
     this.product_item_mapper = product_item_mapper;
     this.product_repository = product_repository;
     this.departmentItemMapper = departmentItemMapper;
 }

 public void ShouldUpdateTheStockForProduct()
 {
     var productRepository = new ProductRepository(@"Repository\Products.txt", "Product");
        // productRepository.UpdateStock(2);
     var products = productRepository.GetAll().ToArray();
     Assert.AreEqual(2, products[1].Stock);
 }

        public IEnumerable<Product> Get(string search)
        {
            var productRepository = new ProductRepository();
            var products = productRepository.Retrieve();

            return products.Where(p => p.ProductCode.Contains(search));
        }