Example #1
0
        // GET: Categorias
        public async Task <ActionResult> Index(int?page)
        {
            if (!await RedisCacheClient.ExistsAsync("Categoria"))
            {
                await RedisCacheClient.AddAsync("Categoria", "", new TimeSpan(0, 3, 0));

                var categoriaDB = await db.Categorias.ToListAsync();

                foreach (var item in categoriaDB)
                {
                    await RedisCacheClient.AddAsync("Categoria:" + item.CategoriaId.ToString(), item, new TimeSpan(0, 3, 0));
                }
            }

            var categorias = (await RedisCacheClient.SearchKeysAsync("Categoria:*"))
                             .Select(p => RedisCacheClient.Get <Categoria>(p)).OrderBy(x => x.CategoriaId).ToList() ??
                             await db.Categorias.OrderBy(x => x.CategoriaId).ToListAsync();

            var pageNumber = page ?? 1;
            var paginacao  = await categorias.ToPagedListAsync(pageNumber, 25);

            ViewBag.PageCategorias = paginacao;

            return(View());
        }
Example #2
0
        public async Task <JsonResult> PesquisarJson(String termo)
        {
            db.Configuration.ProxyCreationEnabled = false;
            db.Configuration.LazyLoadingEnabled   = false;

            if (String.IsNullOrEmpty(termo))
            {
                return(Json(null, JsonRequestBehavior.AllowGet));
            }

            if (!await RedisCacheClient.ExistsAsync("Agencias"))
            {
                var agenciasBancarias = await db.AgenciasBancarias
                                        // .Where(a => a.Nome.Contains(termo) || termo.Contains(a.CodigoCompensacao.ToString()))
                                        .ToListAsync();

                await RedisCacheClient.AddAsync("Agencias", agenciasBancarias, new TimeSpan(0, 3, 0));
            }

            termo = termo.ToUpper();
            var lista = await RedisCacheClient.GetAsync <List <AgenciaBancaria> >("Agencias");

            return(Json(lista
                        .Where(a => a.Nome.Contains(termo) || termo.Contains(a.CodigoCompensacao.ToString())), JsonRequestBehavior.AllowGet));

            // return Json(agenciasBancarias, JsonRequestBehavior.AllowGet);
        }
Example #3
0
        // GET: Veiculos
        public async Task <ActionResult> Index(int?page)
        {
            if (!await RedisCacheClient.ExistsAsync("Veiculos"))
            {
                await RedisCacheClient.AddAsync("Veiculo", "", new TimeSpan(0, 3, 0));

                var veiculosDB = await db.Veiculos.ToListAsync();

                foreach (var item in veiculosDB)
                {
                    await RedisCacheClient.AddAsync("Veiculo:" + item.VeiculoId.ToString(), item, new TimeSpan(0, 3, 0));
                }
            }

            var veiculos = (await RedisCacheClient.SearchKeysAsync("Veiculo:*"))
                           .Select(p => RedisCacheClient.Get <Veiculo>(p)).OrderBy(x => x.VeiculoId).ToList() ??
                           await db.Veiculos.OrderBy(x => x.VeiculoId).ToListAsync();

            var pageNumber = page ?? 1;
            var paginacao  = await veiculos.ToPagedListAsync(pageNumber, 25);

            ViewBag.PageVeiculos = paginacao;

            return(View());
        }
Example #4
0
        public async Task <ActionResult> BuscarCompromisso(string compromisso)
        {
            if (String.IsNullOrEmpty(compromisso))
            {
                return(Json(null, JsonRequestBehavior.AllowGet));
            }

            if (!await RedisCacheClient.ExistsAsync("Compromissos"))
            {
                var compromissoDB = await db.Compromissos.ToListAsync();

                await RedisCacheClient.AddAsync("Compromissos", compromissoDB, new TimeSpan(0, 3, 0));
            }

            var lista = await RedisCacheClient.GetAsync <List <Compromisso> >("Compromissos");

            return(Json(lista
                        .Where(a => a.Titulo.Contains(compromisso)), JsonRequestBehavior.AllowGet));
        }
 public virtual Task <bool> IsSetAsync(string key)
 {
     return(CacheClient.ExistsAsync(key));
 }