Ejemplo n.º 1
0
        public ActionResult Index()
        {
            var genres = db.Genres.ToList();

            ICacheProvider cache = new DefaultCacheProvider();

            List <Album> newArrivals;

            if (cache.IsSet(Consts.NewItemsCacheKey))
            {
                newArrivals = cache.Get(Consts.NewItemsCacheKey) as List <Album>;
            }
            else
            {
                newArrivals = db.Albums.Where(a => !a.IsHidden).OrderByDescending(a => a.DateAdded).Take(3).ToList();
                cache.Set(Consts.NewItemsCacheKey, newArrivals, 30);
            }


            var bestsellers = db.Albums.Where(a => !a.IsHidden && a.IsBestseller).OrderBy(g => Guid.NewGuid()).Take(3).ToList();

            var vm = new HomeViewModel()
            {
                Bestsellers = bestsellers,

                Genres = genres,

                NewArrivals = newArrivals
            };

            return(View(vm));
        }
        //Shows bestseller items and new ones
        public ActionResult Index()
        {
            var category = db.Categories.ToList();

            var best = db.Items.Where(a => a.Available && a.Bestseller).OrderBy(a => Guid.NewGuid()).Take(4).ToList();

            ICacheProvider cache = new DefaultCacheProvider();
            List <Item>    newOnes;

            if (cache.IsSet(Consts.NewsCacheKey))
            {
                newOnes = cache.Get(Consts.NewsCacheKey) as List <Item>;
            }
            else
            {
                newOnes = db.Items.Where(a => a.Available).OrderByDescending(a => a.AddDate).Take(4).ToList();
                cache.Set(Consts.NewsCacheKey, newOnes, 60);
            }

            var vm = new HomeViewModel()
            {
                Bestseller = best,
                New        = newOnes,
                Categories = category
            };

            return(View(vm));
        }
Ejemplo n.º 3
0
        public HomeViewModel GetBestsellersAndNewsForMainPage()
        {
            ICacheProvider cache = new DefaultCacheProvider();
            List <Product> news  = new List <Product>();


            if (cache.isSet(Consts.NewsCacheKey))
            {
                news = cache.Get(Consts.NewsCacheKey) as List <Product>;
            }
            else
            {
                news = db.Products.OrderByDescending(p => p.AddingDate).Take(3).ToList();
                cache.Set(Consts.NewsCacheKey, news, 1);
            }

            List <Product> bestsellers = new List <Product>();

            if (cache.isSet(Consts.BestsellerCacheKey))
            {
                bestsellers = cache.Get(Consts.BestsellerCacheKey) as List <Product>;
            }
            else
            {
                bestsellers = db.Products.Where(p => p.isBestseller).OrderBy(p => Guid.NewGuid()).Take(3).ToList();
                cache.Set(Consts.BestsellerCacheKey, bestsellers, 60);
            }

            return(new HomeViewModel()
            {
                Bestsellers = bestsellers, New = news
            });
        }
Ejemplo n.º 4
0
        public void TestDefaultConstructor()
        {
            var provider = new DefaultCacheProvider();

            provider.Add("test", "value", DateTimeOffset.MaxValue);
            Assert.That(MemoryCache.Default["test"], Is.EqualTo("value"));
        }
Ejemplo n.º 5
0
        // GET: Home
        public ActionResult Index()
        {
            var categories = db.Categories.ToList();

            //Caching
            ICacheProvider cache = new DefaultCacheProvider();
            List <Game>    newArriwals;

            if (cache.IsSet(Consts.NewItemsCacheKey))
            {
                newArriwals = cache.Get(Consts.NewItemsCacheKey) as List <Game>;
            }
            else
            {
                newArriwals = db.Games.Where(x => !x.IsHidder).OrderByDescending(x => x.DateAdded).Take(3).ToList();
                cache.Set(Consts.NewItemsCacheKey, newArriwals, 30);
            }

            var bestsellers = db.Games.Where(x => !x.IsHidder && x.IsBestseller).OrderBy(y => Guid.NewGuid()).Take(3).ToList(); // order by new Guid to get random bestseller in each time

            var vm = new HomeViewModel()
            {
                Bestsellers = bestsellers,
                NewArrivals = newArriwals,
                Categories  = categories
            };

            return(View(vm));
        }
Ejemplo n.º 6
0
		// GET: Home
		public ActionResult Index()
		{
			var categories = db.Categories;

			ICacheProvider cache = new DefaultCacheProvider();

			List<Course> newArrivals;
			if (cache.IsSet(Consts.NewItemCacheKey))
			{
				newArrivals = cache.Get(Consts.NewItemCacheKey) as List<Course>;
			}
			else
			{
				newArrivals = db.Courses.Where(a => !a.IsHidden).OrderByDescending(a => a.DateAdded).Take(3).ToList();
				cache.Set(Consts.NewItemCacheKey, newArrivals, 30);
			}


			
			var bestVoted = db.Courses.Where(a => !a.IsHidden && a.IsBestVoted).OrderBy(g => Guid.NewGuid()).Take(3).ToList();

			var vm = new HomeViewModel()
			{
				Categories = categories, 
				BestVoted = bestVoted,
				NewArrivals = newArrivals
			};




			return View(vm);
		}
Ejemplo n.º 7
0
        public ActionResult Index()
        {
            ICacheProvider cache = new DefaultCacheProvider();
            List <Produkt> nowosci;

            if (cache.IsSet(Consts.NowosciCacheKey))
            {
                nowosci = cache.Get(Consts.NowosciCacheKey) as List <Produkt>;
            }
            else
            {
                nowosci = db.Produkt.Where(a => !a.Ukryty).OrderByDescending(a => a.DataDodania).Take(6).ToList();
                cache.Set(Consts.NowosciCacheKey, nowosci, 60);
            }

            var kategorie = db.Kategoria.ToList();



            var bestsellery = db.Produkt.Where(a => !a.Ukryty && a.Bestseller).OrderBy(a => Guid.NewGuid()).Take(3).ToList(); //Guid.NewGuid() - sortuje po unikalnym indentyfikatorze za kazdym razem innmy

            var powiazane = db.Produkt.Take(5).ToList();

            var vm = new HomeViewModel()
            {
                Kategorie   = kategorie,
                Nowosci     = nowosci,
                Bestsellery = bestsellery,
                Powiazane   = powiazane
            };

            return(View(vm));
        }
Ejemplo n.º 8
0
 public CommonController()
 {
     Cache          = new DefaultCacheProvider();
     Aply_Appr_Type = new List <string>()
     {
         Ref.AccessProjectFormStatus.A01.ToString(),
             Ref.AccessProjectFormStatus.A02.ToString(),
             Ref.AccessProjectFormStatus.A03.ToString(),
             Ref.AccessProjectFormStatus.A04.ToString(),
             Ref.AccessProjectFormStatus.A05.ToString(),
             Ref.AccessProjectFormStatus.A06.ToString()
     };
     End_Type = new List <string>()
     {
         Ref.AccessProjectFormStatus.E01.ToString(),
             Ref.AccessProjectFormStatus.E02.ToString(),
             Ref.AccessProjectFormStatus.E03.ToString(),
             Ref.AccessProjectFormStatus.E04.ToString()
     };
     Custody_Aply_Appr_Type = new List <string>()
     {
         Ref.AccessProjectFormStatus.B01.ToString(),
             Ref.AccessProjectFormStatus.B02.ToString(),
             Ref.AccessProjectFormStatus.B03.ToString(),
             Ref.AccessProjectFormStatus.B04.ToString()
     };
     TreasuryAccess = new TreasuryAccess();
 }
Ejemplo n.º 9
0
        public ActionResult Index()
        {
            ICacheProvider cache = new DefaultCacheProvider();

            //Categories
            List <Category> categories;

            if (cache.IsSet(Consts.CategoriesCacheKey))
            {
                categories = cache.Get(Consts.CategoriesCacheKey) as List <Category>;
            }
            else
            {
                categories = db.Categories.ToList();
                cache.Set(Consts.CategoriesCacheKey, categories, 60);
            }

            // News
            var news = db.Audiobooks.Where(a => !a.LackAudiobook).OrderByDescending(a => a.DateAdded).Take(3).ToList();


            // Bestseller
            var bestseller = db.Audiobooks.Where(a => !a.LackAudiobook && a.Bestseller).OrderBy(a => Guid.NewGuid()).Take(3).ToList();


            var vm = new HomeViewModel()
            {
                Categories  = categories,
                News        = news,
                Bestsellers = bestseller,
            };

            return(View(vm));
        }
Ejemplo n.º 10
0
        // GET: Home
        public ActionResult Index()
        {
            //HttpContext.Cache.Add() <<< W przypadku korzystania z domyslnego cache-a
            //For diffrent cache use https://www.infoq.com/news/2007/07/memcached/ OR https://docs.microsoft.com/en-us/azure/azure-cache-for-redis/cache-aspnet-session-state-provider

            ICacheProvider cache = new DefaultCacheProvider();


            var categories = new List <Category>();

            if (cache.IsSet(Consts.CategoriesCacheKey))
            {
                categories = cache.Get(Consts.CategoriesCacheKey) as List <Category>;
            }
            else
            {
                categories = db.Categories.ToList();  cache.Set(Consts.CategoriesCacheKey, categories, 60);
            }


            var newBooks = db.Books.Where(a => !a.Hidden).OrderBy(a => a.CategoryId).ToList();
            List <List <Book> > seperatedBooks = new List <List <Book> >();

            if (cache.IsSet(Consts.NewBooksCacheKey))
            {
                seperatedBooks = cache.Get(Consts.NewBooksCacheKey) as List <List <Book> >;
            }
            else
            {
                List <Book> temp = new List <Book>();
                for (int i = 0; i < newBooks.Count; i++)
                {
                    if (i > 0)
                    {
                        if (newBooks.ElementAt(i).CategoryId != newBooks.ElementAt(i - 1).CategoryId)
                        {
                            seperatedBooks.Add(temp);
                            temp = new List <Book>(); temp.Add(newBooks.ElementAt(i));
                        }
                        else
                        {
                            temp.Add(newBooks.ElementAt(i));
                        }
                    }
                    else
                    {
                        temp.Add(newBooks.ElementAt(i));
                    }
                }
                cache.Set(Consts.NewBooksCacheKey, seperatedBooks, 60);
            }

            var vm = new HomeViewModel()
            {
                Categories             = categories,
                NewBooksFromCategories = seperatedBooks
            };

            return(View(vm));
        }
        public ActionResult ClearCache()
        {
            var _cache = new DefaultCacheProvider();

            _cache.Clear();

            return(RedirectToAction("Index"));
        }
        public void TestAddNullWillRemoveFromCache()
        {
            var provider = new DefaultCacheProvider();
            provider.Add("test", "value", DateTimeOffset.MaxValue);
            Assert.That(MemoryCache.Default["test"], Is.EqualTo("value"));

            provider.Add("test", null, DateTimeOffset.MaxValue);
            Assert.That(MemoryCache.Default["test"], Is.EqualTo(null));
        }
Ejemplo n.º 13
0
        public void TestAddNullWillRemoveFromCache()
        {
            var provider = new DefaultCacheProvider();

            provider.Add("test", "value", DateTimeOffset.MaxValue);
            Assert.That(MemoryCache.Default["test"], Is.EqualTo("value"));

            provider.Add("test", null, DateTimeOffset.MaxValue);
            Assert.That(MemoryCache.Default["test"], Is.EqualTo(null));
        }
Ejemplo n.º 14
0
        public ActionResult Index()
        {
            ICacheProvider cache = new DefaultCacheProvider();

            List <Category> categories;

            if (cache.IsSet(Const.CategoriesCacheKey))
            {
                categories = cache.Get(Const.CategoriesCacheKey) as List <Category>;
            }
            else
            {
                //unikalne zawsze, dobiera inne
                categories = db.Category.ToList();
                cache.Set(Const.CategoriesCacheKey, categories, 60);
            }

            List <Equipment> latest;

            if (cache.IsSet(Const.LatestCacheKey))
            {
                latest = cache.Get(Const.LatestCacheKey) as List <Equipment>;
            }
            else
            {
                latest = db.AllEquipment.Where(a => !a.Hidden).OrderByDescending(a => a.DateAdded).Take(3).ToList();
                cache.Set(Const.LatestCacheKey, latest, 60);
            }

            List <Equipment> bestseller;

            if (cache.IsSet(Const.BestsellerCacheKey))
            {
                bestseller = cache.Get(Const.BestsellerCacheKey) as List <Equipment>;
            }
            else
            {
                //uniqe, always selecting different objects
                bestseller = db.AllEquipment.Where(a => !a.Hidden && a.Bestseller).OrderBy(a => Guid.NewGuid()).Take(3).ToList();
                cache.Set(Const.BestsellerCacheKey, bestseller, 60);
            }


            //unikalne zawsze, dobiera inne
            bestseller = db.AllEquipment.Where(a => !a.Hidden && a.Bestseller).OrderBy(a => Guid.NewGuid()).Take(3).ToList();

            var vm = new HomeViewModel()
            {
                Categories  = categories,
                Latest      = latest,
                Bestsellers = bestseller
            };

            return(View(vm));
        }
Ejemplo n.º 15
0
        private double GetExpirationInHours(string key)
        {
            CacheExpiration cacheExpiration = new DefaultCacheProvider().GetExpiration(key);

            if (cacheExpiration != null && cacheExpiration.AbsoluteExpiration != null)
            {
                return(Math.Round(cacheExpiration.AbsoluteExpiration.Value.Subtract(DateTime.Now).TotalHours, 4));
            }

            return(0.0);
        }
Ejemplo n.º 16
0
        private string GetExpiration(string key)
        {
            CacheExpiration cacheExpiration = new DefaultCacheProvider().GetExpiration(key);

            if (cacheExpiration != null && cacheExpiration.AbsoluteExpiration != null)
            {
                return(cacheExpiration.AbsoluteExpiration.Value.Subtract(DateTime.Now).ToString());
            }

            return("");
        }
Ejemplo n.º 17
0
        public ActionResult Index()
        {
            logger.Info("Strona glowna mordo");

            List <Course>   news;
            List <Course>   bestSeller;
            List <Category> listCat;
            ICacheProvider  Cache = new DefaultCacheProvider();

            if (Cache.IsSet(Consts.NewsCacheKey))
            {
                news = Cache.Get(Consts.NewsCacheKey) as List <Course>;
            }

            else
            {
                news = db.Course.Where(a => !a.Hidden).OrderByDescending(a => a.DateAdd).Take(3).ToList();
                Cache.Set(Consts.NewsCacheKey, news, 60);
            }
            if (Cache.IsSet(Consts.CatCacheKey))
            {
                listCat = Cache.Get(Consts.CatCacheKey) as List <Category>;
            }
            else
            {
                listCat = db.Category.ToList();
                Cache.Set(Consts.CatCacheKey, listCat, 60);
            }



            if (Cache.IsSet(Consts.bestSellerCacheKey))
            {
                bestSeller = Cache.Get(Consts.bestSellerCacheKey) as List <Course>;
            }
            else
            {
                bestSeller = db.Course.Where(a => !a.Hidden || a.Bestseller).OrderBy(a => Guid.NewGuid()).Take(3).ToList();
                Cache.Set(Consts.bestSellerCacheKey, bestSeller, 60);
            }


            //guid.new guid generuje unikalny identyfikator za kazdym razem, wiec mozna otrzymac losowe bestsellery

            var vm = new HomeViewModel()
            {
                Bestsellers = bestSeller,
                Cat         = listCat,
                News        = news
            };

            return(View(vm));
        }
        // GET: Home
        public ActionResult Index()
        {
            logger.Info("Jestes na stronie glownej");

            ICacheProvider cache = new DefaultCacheProvider();

            List <Kategoria> kategorie;

            if (cache.IsSet(Consts.KategorieCacheKey))
            {
                kategorie = cache.Get(Consts.KategorieCacheKey) as List <Kategoria>;
            }
            else
            {
                kategorie = db.Kategorie.ToList();
                cache.Set(Consts.KategorieCacheKey, kategorie, 60);
            }
            List <Kurs> nowosci;

            if (cache.IsSet(Consts.NowosciCacheKey))
            {
                nowosci = cache.Get(Consts.NowosciCacheKey) as List <Kurs>;
            }
            else
            {
                nowosci = db.Kursy.Where(a => !a.Ukryty).OrderByDescending(a => a.DataDodania).Take(3).ToList();
                cache.Set(Consts.NowosciCacheKey, nowosci, 1);
            }


            List <Kurs> bestseller;

            if (cache.IsSet(Consts.BestsellerCacheKey))
            {
                bestseller = cache.Get(Consts.BestsellerCacheKey) as List <Kurs>;
            }
            else
            {
                bestseller = db.Kursy.Where(a => !a.Ukryty).OrderByDescending(a => a.DataDodania).Take(3).ToList();
                cache.Set(Consts.BestsellerCacheKey, bestseller, 1);
            }


            var vm = new HomeViewModel()
            {
                Kategorie   = kategorie,
                Nowosci     = nowosci,
                Bestsellery = bestseller
            };


            return(View(vm));
        }
Ejemplo n.º 19
0
        // GET: Home
        public ActionResult Index()
        {
            ICacheProvider cache = new DefaultCacheProvider();

            List <Category> categories;

            if (cache.IsSet(Consts.CategoriesCacheKey))
            {
                categories = cache.Get(Consts.CategoriesCacheKey) as List <Category>;
            }
            else
            {
                categories = _db.Categories.ToList();
                cache.Set(Consts.CategoriesCacheKey, categories, 60);
            }


            List <Product> news;


            //if (cache.IsSet(Consts.NewsCacheKey))
            //{
            //    news = cache.Get(Consts.NewsCacheKey) as List<Product>;
            //}
            //else
            //{
            news = _db.Products.Where(n => !n.Hidden).OrderByDescending(a => a.AddTime).Take(3).ToList();
            cache.Set(Consts.NewsCacheKey, news, 5);
            //}

            List <Product> bestsellers;

            //if (cache.IsSet(Consts.BestsellersCacheKey))
            //{
            //    bestsellers = cache.Get(Consts.BestsellersCacheKey) as List<Product>;
            //}
            //else
            //{
            bestsellers = _db.Products.Where(b => !b.Hidden && b.Bestseller).OrderBy(a => Guid.NewGuid()).Take(3).ToList();
            cache.Set(Consts.BestsellersCacheKey, bestsellers, 5);
            //}


            var viewmodel = new HomeViewModel()
            {
                Categories  = categories,
                News        = news,
                Bestsellers = bestsellers
            };

            return(View(viewmodel));
        }
Ejemplo n.º 20
0
        public ActionResult Index()
        {
            logger.Info("U r on the main page");
            //throw new Exception("ascasca");
            ICacheProvider cache = new DefaultCacheProvider();

            List <Category> categories;

            if (cache.IsSet(Const.CATEGORIES_CACHE_KEY))
            {
                categories = cache.Get(Const.CATEGORIES_CACHE_KEY) as List <Category>;
            }
            else
            {
                categories = db.Categories.ToList();
                cache.Set(Const.CATEGORIES_CACHE_KEY, categories, 60);
            }

            List <Course> brandNews;

            if (cache.IsSet(Const.BRAND_NEWS_CACHE_KEY))
            {
                brandNews = cache.Get(Const.BRAND_NEWS_CACHE_KEY) as List <Course>;
            }
            else
            {
                brandNews = db.Courses.Where(x => !x.Hidden).OrderByDescending(x => x.InsertDate).Take(3).ToList();
                cache.Set(Const.BRAND_NEWS_CACHE_KEY, brandNews, 1);
            }

            List <Course> bestsellers;

            if (cache.IsSet(Const.BESTSELLERS_CACHE_KEY))
            {
                bestsellers = cache.Get(Const.BESTSELLERS_CACHE_KEY) as List <Course>;
            }
            else
            {
                bestsellers = db.Courses.Where(x => x.Bestseller == true && !x.Hidden).OrderBy(x => Guid.NewGuid()).Take(3).ToList();
                cache.Set(Const.BESTSELLERS_CACHE_KEY, bestsellers, 1);
            }

            var vm = new HomeViewModel()
            {
                Categories  = categories,
                BrandNew    = brandNews,
                Bestsellers = bestsellers
            };


            return(View(vm));
        }
Ejemplo n.º 21
0
        public ActionResult Index()
        {
            ICacheProvider cache = new DefaultCacheProvider();

            List <Category> categories;

            if (cache.IsSet(Consts.CategoriesCache))
            {
                categories = cache.Get(Consts.CategoriesCache) as List <Category>;
            }
            else
            {
                categories = db.Categories.ToList();
                cache.Set(Consts.CategoriesCache, categories, 60);
            }

            List <Supplement> newsupplements;

            if (cache.IsSet(Consts.NewSupplementCache))
            {
                newsupplements = cache.Get(Consts.NewSupplementCache) as List <Supplement>;
            }
            else
            {
                newsupplements = db.Supplements.Where(a => !a.Hidden).OrderByDescending(a => a.AddTime).Take(3).ToList();
                cache.Set(Consts.NewSupplementCache, newsupplements, 1);
            }

            List <Supplement> bestsellersupplements;

            if (cache.IsSet(Consts.BestsellerCache))
            {
                bestsellersupplements = cache.Get(Consts.BestsellerCache) as List <Supplement>;
            }
            else
            {
                bestsellersupplements =
                    db.Supplements.Where(a => !a.Hidden && a.Bestseller).OrderBy(a => Guid.NewGuid()).Take(3).ToList(); //Guid - nadaje nowy identyfikator za kazdym razem gdy uruchamiamy aplikacje
                cache.Set(Consts.BestsellerCache, bestsellersupplements, 1);
            }



            var viewmodel = new HomeViewModel()
            {
                Categories            = categories,
                NewSupplements        = newsupplements,
                BestsellerSupplements = bestsellersupplements
            };

            return(View(viewmodel));
        }
Ejemplo n.º 22
0
        public void WhenTheValueIsNotCached_ThenItIsRetrievedUsingTheSpecifiedStrategy()
        {
            var strategyIsUsed = false;
            var cacheProvider = new DefaultCacheProvider(new DefaultRetryPolicy(3), 10);
            var value = cacheProvider.GetValue("TEST", () =>
            {
                strategyIsUsed = true;
                return true;
            });

            Assert.That(strategyIsUsed, Is.True);
            Assert.That(value, Is.True);
        }
Ejemplo n.º 23
0
        public void WhenTheValueIsNotCached_ThenItIsRetrievedUsingTheSpecifiedStrategy()
        {
            var strategyIsUsed = false;
            var cacheProvider  = new DefaultCacheProvider(new DefaultRetryPolicy(3), 10);
            var value          = cacheProvider.GetValue("TEST", () =>
            {
                strategyIsUsed = true;
                return(true);
            });

            Assert.That(strategyIsUsed, Is.True);
            Assert.That(value, Is.True);
        }
Ejemplo n.º 24
0
        public ActionResult Index()
        {
            logger.Info("You are on the Home Page");

            ICacheProvider cache = new DefaultCacheProvider();

            List <Category> categories;

            if (cache.IsSet(Const.CategoryCacheKey))
            {
                categories = cache.Get(Const.CategoryCacheKey) as List <Category>;
            }
            else
            {
                categories = db.Categories.ToList();
                cache.Set(Const.CategoryCacheKey, categories, 60);
            }

            List <Course> newest;

            if (cache.IsSet(Const.NewestCacheKey))
            {
                newest = cache.Get(Const.NewestCacheKey) as List <Course>;
            }
            else
            {
                newest = db.Courses.Where(a => !a.Hidden).OrderByDescending(a => a.DateAdded).Take(3).ToList();
                cache.Set(Const.NewestCacheKey, newest, 60);
            }

            List <Course> bestsellers;

            if (cache.IsSet(Const.BestSellerCacheKey))
            {
                bestsellers = cache.Get(Const.BestSellerCacheKey) as List <Course>;
            }
            else
            {
                bestsellers = db.Courses.Where(a => !a.Hidden && a.Bestseller).OrderBy(a => Guid.NewGuid()).Take(3).ToList();
                cache.Set(Const.BestSellerCacheKey, newest, 60);
            }

            var viewmodel = new HomeViewModel()
            {
                CategoryViewModel     = categories,
                Bestsellers           = bestsellers,
                NewestCourseViewModel = newest
            };

            return(View(viewmodel));
        }
Ejemplo n.º 25
0
        // GET: Home

        //Main view of the application - get products and categories from cache
        public ActionResult Index()
        {
            //Reference to our Cache interface
            ICacheProvider cache = new DefaultCacheProvider();

            List <Category> categories;

            if (cache.IsSet(Consts.CategoriesCacheKey))
            {
                categories = cache.Get(Consts.CategoriesCacheKey) as List <Category>;
            }
            else
            {
                categories = db.Category.ToList();
                cache.Set(Consts.CategoriesCacheKey, categories, 60);
            }

            List <Product> newProducts;

            if (cache.IsSet(Consts.NewProductsCacheKey))
            {
                newProducts = cache.Get(Consts.NewProductsCacheKey) as List <Product>;
            }
            else
            {
                newProducts = db.Product.Where(a => !a.Hidden).OrderByDescending(a => a.DateAdded).Take(3).ToList();
                cache.Set(Consts.NewProductsCacheKey, newProducts, 60);
            }

            List <Product> bestsellers;

            if (cache.IsSet(Consts.BestsellersCacheKey))
            {
                bestsellers = cache.Get(Consts.BestsellersCacheKey) as List <Product>;
            }
            else
            {
                bestsellers = db.Product.Where(a => !a.Hidden && a.Bestseller).OrderBy(a => Guid.NewGuid()).Take(5).ToList();
                cache.Set(Consts.BestsellersCacheKey, bestsellers, 60);
            }

            var viewModel = new HomeViewModel()
            {
                Categories  = categories,
                NewProducts = newProducts,
                Bestsellers = bestsellers
            };

            return(View(viewModel));
        }
Ejemplo n.º 26
0
        public void WhenTheStrategyResultsInAnException_ThenItIsRetriedAConfigurableNumberOfTimes(int retries)
        {
            var attempts = 0;
            var cacheProvider = new DefaultCacheProvider(new DefaultRetryPolicy(retries), 0.1);

            var value = cacheProvider.GetValue<bool>("TEST", () =>
            {
                attempts++;
                if (attempts != retries) throw new Exception();
                return true;
            });

            Assert.That(attempts, Is.EqualTo(retries));
        }
Ejemplo n.º 27
0
        public void WhenTheValueIsAlreadyCached_ThenItIsNotRetrievedASecondTime()
        {
            var strategyIsUsed = false;
            var cacheProvider = new DefaultCacheProvider(new DefaultRetryPolicy(3), 10);
            var value = cacheProvider.GetValue("TEST", () => false);
            value = cacheProvider.GetValue("TEST", () =>
            {
                strategyIsUsed = true;
                return true;
            });

            Assert.That(strategyIsUsed, Is.False);
            Assert.That(value, Is.False);
        }
Ejemplo n.º 28
0
        //
        /// <summary>
        /// Frequency of use: Regularly
        /// Function: Return New url:Image By params
        /// Scope: Every where
        /// </summary>
        /// <param name="url"></param>
        /// <param name="w"></param>
        /// <param name="h"></param>
        /// <param name="watermark"></param>
        /// http://admin.selectgo.vn/external/api/images/get?url=http://storage.selectgo.vn/media/uploads-1/avatar/product/3000x/2020/07/16/venice-1594876195323.png&namespace=/uploads-1/&indicatedate=2020/07/16&w=200&h=200&compression=100&watermark=
        public static string GetResize(string url, int w = -1, int h = -1, string watermark = "", string sizeDefault = "200x200", long compression = 60L)
        {
            if (url == null)
            {
                return("");
            }
            //return url;
            if (url.EndsWith(".gif"))
            {
                return(url);
            }
            if (!url.StartsWith(AppConfigs.LinksMedia))
            {
                return(url);
            }

            var re = (url == "" ? Helper.GetResize("~") : Helper.GetResize(url, w, h, watermark, compression));

            if (_cndProvider == null)
            {
                _cndProvider = new CDNProvider();
            }
            if (_cndProvider.Initialise("*") != false)
            {
                var newLinksMedia = _cndProvider.GetPreferCnd();
                if (newLinksMedia != AppConfigs.LinksMedia)
                {
                    var rex = re.Replace(AppConfigs.LinksMedia, _cndProvider.GetPreferCnd()); // resover

                    // Cache:
                    var key    = "UrlOnline::" + (rex);
                    var vlData = DefaultCacheProvider.Get <string>(key);
                    if (vlData == null)
                    {
                        vlData = _cndProvider.UrlIsOnline(rex) == true ? "OK" : null;
                        DefaultCacheProvider.Add(vlData, key, createFolder: false);
                    }
                    if (vlData == "OK")
                    {
                        re = rex;
                    }
                }
            }

            if (re.Contains("-1x-1"))
            {
                re = re.Replace("-1x-1", sizeDefault);
            }
            return(re);
        }
Ejemplo n.º 29
0
        public ActionResult Index()
        {
            //var categories = db.Categories.ToList();

            ICacheProvider cache = new DefaultCacheProvider();



            List <Category> categories;

            if (cache.IsSet(Consts.CategoriesCacheKey))
            {
                categories = cache.Get(Consts.CategoriesCacheKey) as List <Category>;
            }
            else
            {
                categories = db.Categories.OrderBy(a => a.CategoryName).ToList();

                cache.Set(Consts.CategoriesCacheKey, categories, 120);
            }



            List <Product> recent;

            if (cache.IsSet(Consts.RecentCacheKey))
            {
                recent = cache.Get(Consts.RecentCacheKey) as List <Product>;
            }
            else
            {
                recent = db.Products.OrderByDescending(a => a.DateAdded).Take(6).ToList();
                cache.Set(Consts.RecentCacheKey, recent, 1);
            }



            var vm = new HomeViewModel
            {
                Categories = categories,
                Recent     = recent
            };

            //var ListCategories = db.Categories.ToList();



            return(View(vm));
        }
Ejemplo n.º 30
0
        public ActionResult Index(string searchQuery = null)
        {
            ICacheProvider cache = new DefaultCacheProvider();

            List <Category> categories;

            if (cache.IsSet(Consts.CategoriesCacheKey))
            {
                categories = cache.Get(Consts.CategoriesCacheKey) as List <Category>;
            }
            else
            {
                categories = db.Categories.ToList();
                cache.Set(Consts.CategoriesCacheKey, categories, 24);
            }

            List <Offer> featuredOffers;

            if (cache.IsSet(Consts.FeaturedCacheKey))
            {
                featuredOffers = cache.Get(Consts.FeaturedCacheKey) as List <Offer>;
            }
            else
            {
                featuredOffers = db.Offers.Include("Category").Where(x => x.Featured && x.Status == Models.OfferStatus.Aktywne).OrderBy(x => Guid.NewGuid()).Take(2).ToList();
                cache.Set(Consts.FeaturedCacheKey, featuredOffers, 24);
            }

            //version without search engine
            //var offers = db.Offers.Include("Category").Where(x => x.Status == Models.OfferStatus.Aktywne).OrderBy(x => Guid.NewGuid()).Take(6).ToList();
            var offers = db.Offers.Include("Category").Where(x => searchQuery == null ||
                                                             x.Title.ToLower().Contains(searchQuery.ToLower()) ||
                                                             x.Category.Name.ToLower().Contains(searchQuery.ToLower()) ||
                                                             x.CompanyName.ToLower().Contains(searchQuery.ToLower()) &&
                                                             x.Status == Models.OfferStatus.Aktywne).Take(6).ToList();

            if (Request.IsAjaxRequest())
            {
                return(PartialView("_PartialListOffers", offers));
            }



            var vm = new HomeViewModel {
                FeaturedOffers = featuredOffers, NormalOffers = offers, Categories = categories
            };

            return(View(vm));
        }
Ejemplo n.º 31
0
        public ActionResult Index()
        {
            ICacheProvider cache = new DefaultCacheProvider();

            List <Genre> genres;

            if (cache.IsSet(CacheConst.genres))
            {
                genres = cache.Get(CacheConst.genres) as List <Genre>;
            }
            else
            {
                genres = db.Genres.ToList();
                cache.Set(CacheConst.genres, genres, 180);
            }

            List <Album> newArrivals;

            if (cache.IsSet(CacheConst.newArrivals))
            {
                newArrivals = cache.Get(CacheConst.newArrivals) as List <Album>;
            }
            else
            {
                newArrivals = db.Albums.Where(a => !a.isHidden).OrderByDescending(a => a.DateAdded).Take(3).ToList();
                cache.Set(CacheConst.newArrivals, newArrivals, 30);
            }

            List <Album> bestsellers;

            if (cache.IsSet(CacheConst.bestseller))
            {
                bestsellers = cache.Get(CacheConst.bestseller) as List <Album>;
            }
            else
            {
                bestsellers = db.Albums.Where(a => !a.isHidden && a.IsBestseller).OrderBy(g => Guid.NewGuid()).Take(3).ToList();
                cache.Set(CacheConst.bestseller, bestsellers, 15);
            }

            var vm = new HomeViewModel()
            {
                Bestsellers = bestsellers,
                Genres      = genres,
                NewArrivals = newArrivals
            };

            return(View(vm));
        }
Ejemplo n.º 32
0
        public void WhenTheValueIsAlreadyCached_ThenItIsNotRetrievedASecondTime()
        {
            var strategyIsUsed = false;
            var cacheProvider  = new DefaultCacheProvider(new DefaultRetryPolicy(3), 10);
            var value          = cacheProvider.GetValue("TEST", () => false);

            value = cacheProvider.GetValue("TEST", () =>
            {
                strategyIsUsed = true;
                return(true);
            });

            Assert.That(strategyIsUsed, Is.False);
            Assert.That(value, Is.False);
        }
Ejemplo n.º 33
0
        public ActionResult Index()
        {
            ICacheProvider   cache = new DefaultCacheProvider();
            List <Skarpetki> nowosci;

            if (cache.IsSet(Consts.NowosciCacheKey))
            {
                nowosci = cache.Get(Consts.NowosciCacheKey) as List <Skarpetki>;
            }
            else
            {
                nowosci = db.Skarpetki.Where(a => !a.Ukryty).OrderByDescending(a => a.DataDodania).Take(3).ToList();
                cache.Set(Consts.NowosciCacheKey, nowosci, 60);
            }

            List <Skarpetki> bestseller;

            if (cache.IsSet(Consts.BestsellerCacheKey))
            {
                bestseller = cache.Get(Consts.BestsellerCacheKey) as List <Skarpetki>;
            }
            else
            {
                bestseller = db.Skarpetki.Where(a => !a.Ukryty && a.Bestseller).OrderBy(a => Guid.NewGuid()).Take(3).ToList(); //sortujemy po indywidualnym indentyfikatorze
                cache.Set(Consts.NowosciCacheKey, bestseller, 60);
            }

            List <Kategoria> kategorie;

            if (cache.IsSet(Consts.KategorieCacheKey))
            {
                kategorie = cache.Get(Consts.KategorieCacheKey) as List <Kategoria>;
            }
            else
            {
                kategorie = db.Kategorie.ToList();
                cache.Set(Consts.KategorieCacheKey, kategorie, 60);
            }

            var ViewModel = new HomeViewModel()
            {
                Kategorie   = kategorie,
                Nowosci     = nowosci,
                Bestsellery = bestseller
            };

            return(View(ViewModel));
        }
Ejemplo n.º 34
0
        public ActionResult Index()
        {
            ICacheProvider cache = new DefaultCacheProvider();

            List <Kategoria> kategorie;

            if (cache.IsSet(Consts.KategorieCacheKey))
            {
                kategorie = cache.Get(Consts.KategorieCacheKey) as List <Kategoria>;
            }
            else
            {
                kategorie = db.Kategorie.ToList();
                cache.Set(Consts.KategorieCacheKey, kategorie, 60);
            }

            List <Produkt> nowosci;

            if (cache.IsSet(Consts.NowosciCacheKey))
            {
                nowosci = cache.Get(Consts.NowosciCacheKey) as List <Produkt>;
            }
            else
            {
                nowosci = db.Produkty.Where(a => !a.ukryty).OrderByDescending(a => a.data_dodania).Take(3).ToList();
                cache.Set(Consts.NowosciCacheKey, nowosci, 60);
            }

            List <Produkt> bestseller;

            if (cache.IsSet(Consts.BestsellerCacheKey))
            {
                bestseller = cache.Get(Consts.BestsellerCacheKey) as List <Produkt>;
            }
            else
            {
                bestseller = db.Produkty.Where(a => !a.ukryty && a.bestseller).OrderBy(a => Guid.NewGuid()).Take(3).ToList();
                cache.Set(Consts.BestsellerCacheKey, bestseller, 60);
            }
            var vm = new HomeViewModel()
            {
                Kategorie   = kategorie,
                Nowosci     = nowosci,
                Bestsellery = bestseller,
            };

            return(View(vm));
        }
Ejemplo n.º 35
0
        public void WhenTheCacheExpirationPeriodHasExpired_ThenTheValueIsRetrievedUsingTheStrategy()
        {
            var strategyIsUsed = false;
            var cacheProvider = new DefaultCacheProvider(new DefaultRetryPolicy(3), 0.1);
            var value = cacheProvider.GetValue("TEST", () => false);

            Thread.Sleep(TimeSpan.FromSeconds(10));

            value = cacheProvider.GetValue("TEST", () =>
            {
                strategyIsUsed = true;
                return true;
            });

            Assert.That(strategyIsUsed, Is.True);
            Assert.That(value, Is.True);
        }
Ejemplo n.º 36
0
 public AppSettingsTests()
 {
     var cache = new DefaultCacheProvider();
     _appSettings = new AppSettings(cache);
 }
Ejemplo n.º 37
0
		/// <summary>
		/// Internal constructor.
		/// </summary>
		/// <param name="provider"></param>
		/// <param name="cacheId"></param>
		internal DefaultCacheClient(DefaultCacheProvider provider, string cacheId)
		{
			_provider = provider;
			_cacheId = cacheId;
		}
 public void TestDefaultConstructor()
 {
     var provider = new DefaultCacheProvider();
     provider.Add("test", "value", DateTimeOffset.MaxValue);
     Assert.That(MemoryCache.Default["test"], Is.EqualTo("value"));
 }