Esempio n. 1
0
        public async Task <GetPedidoResponse> FindBydId(int id)
        {
            var cacheValor = await _cache.GetCacheFrom <GetPedidoResponse>(CHAVE_CACHE_PARTE_FIXA + id);

            if (cacheValor == null)
            {
                var pedido = await _repository.FindById(id);

                var pedidoToReturn = _mapper.Map <GetPedidoResponse>(pedido);
                await _cache.SaveCache(CHAVE_CACHE_PARTE_FIXA + id, pedidoToReturn, TimeSpan.FromSeconds(30));

                return(await Task.FromResult(pedidoToReturn));
            }

            return(cacheValor);
        }
Esempio n. 2
0
        public async Task <IEnumerable <ListClienteResponse> > List(string nome)
        {
            var cacheValor = await _cache.GetCacheFrom <IEnumerable <ListClienteResponse> >(CHAVE_CACHE_PARTE_FIXA + nome);

            if (cacheValor == null)
            {
                var clientes = await _repository.List(nome);

                var clienteToReturn = _mapper.Map <IEnumerable <ListClienteResponse> >(clientes);
                await _cache.SaveCache(CHAVE_CACHE_PARTE_FIXA + nome, clienteToReturn, TimeSpan.FromSeconds(30));

                return(await Task.FromResult(clienteToReturn));
            }

            return(cacheValor);
        }
Esempio n. 3
0
        public async Task <GetEstadoResponse> FindBydId(string id)
        {
            var cacheValor = await _cache.GetCacheFrom <GetEstadoResponse>(CHAVE_CACHE_PARTE_FIXA + id);

            if (cacheValor == null)
            {
                var estado = await _repository.FindById(id);

                var estadoToReturn = _mapper.Map <GetEstadoResponse>(estado);
                await _cache.SaveCache(CHAVE_CACHE_PARTE_FIXA + id, estadoToReturn);

                return(await Task.FromResult(estadoToReturn));
            }

            return(cacheValor);
        }
Esempio n. 4
0
        public async Task <IEnumerable <ListFaixaResponse> > List()
        {
            var cacheValor = await _cache.GetCacheFrom <IEnumerable <ListFaixaResponse> >(CHAVE_CACHE_PARTE_FIXA);

            if (cacheValor == null)
            {
                var faixas = await _repository.List();

                var faixasToReturn = _mapper.Map <IEnumerable <ListFaixaResponse> >(faixas);
                await _cache.SaveCache(CHAVE_CACHE_PARTE_FIXA, faixasToReturn);

                return(await Task.FromResult(faixasToReturn));
            }

            return(cacheValor);
        }
Esempio n. 5
0
        public async Task <IEnumerable <ListPedidoResponse> > List(int idCliente)
        {
            var cacheValor = await _cache.GetCacheFrom <IEnumerable <ListPedidoResponse> >(CHAVE_CACHE_PARTE_FIXA + idCliente);

            if (cacheValor == null)
            {
                var pedidos = await _repository.List(idCliente);

                var pedidosToReturn = _mapper.Map <IEnumerable <ListPedidoResponse> >(pedidos);
                await _cache.SaveCache(CHAVE_CACHE_PARTE_FIXA + idCliente, pedidosToReturn, TimeSpan.FromSeconds(30));

                return(await Task.FromResult(pedidosToReturn));
            }

            return(cacheValor);
        }
Esempio n. 6
0
        public async Task <GetClienteResponse> FindBydId(int id)
        {
            var cacheValor = await _cache.GetCacheFrom <GetClienteResponse>(CHAVE_CACHE_PARTE_FIXA + id);

            if (cacheValor == null)
            {
                var cliente = await _repository.FindById(id);

                var clienteToReturn = _mapper.Map <GetClienteResponse>(cliente);
                await _cache.SaveCache(CHAVE_CACHE_PARTE_FIXA + id, clienteToReturn);

                return(await Task.FromResult(clienteToReturn));
            }

            return(cacheValor);
        }