/**
  * Handle the command.
  *
  * @param CacheManager       $cache
  * @param FieldMigrator      $fields
  * @param StreamMigrator     $streams
  * @param AssignmentMigrator $assignments
  */
 public function handle(CacheManager $cache, FieldMigrator $fields, StreamMigrator $streams, AssignmentMigrator $assignments)
 {
     $assignments->reset($this->migration);
     $fields->reset($this->migration);
     $streams->reset($this->migration);
     $cache->flush();
 }

 protected function addFileCacheDriver(CacheManager $cacheManager)
 {
     $cacheManager->extend(static::$fileDriverName, function ($app, array $cacheConfig) use($cacheManager) {
         $store = new AlternativeHierarchialFileCacheStore(new Filesystem(static::makeFileCacheAdapter($cacheConfig)), static::getPrefix($cacheConfig));
         return $cacheManager->repository($store);
     });
 }

 /**
  * Perform post-registration booting of services.
  *
  * @return void
  */
 public function boot(CacheManager $cacheManager)
 {
     $cacheManager->extend('dummy', function ($app) {
         $prefix = $app['config']->get('cache.prefix');
         return $app['cache']->repository(new DummyCacheStore($prefix));
     });
 }

 /**
  * Return the cache instance with tags attached
  *
  * @return \Illuminate\Cache\CacheManager
  */
 protected function cache()
 {
     if (!method_exists($this->cache, 'tags')) {
         return $this->cache;
     }
     return $this->cache->tags($this->tag);
 }

 /**
  * Finish installation.
  *
  * @param Dispatcher   $events
  * @param CacheManager $cache
  * @return \Illuminate\View\View
  */
 public function finish(Dispatcher $events, CacheManager $cache)
 {
     $cache->store()->flush();
     $action = 'finish';
     $installers = $this->dispatch(new GetSeeders());
     $events->fire(new StreamsHasInstalled($installers));
     return view('anomaly.module.installer::process', compact('action', 'installers'));
 }

 public static function getStore()
 {
     if (!static::$store) {
         $manager = new CacheManager(new ConfigContainer(array('db' => \DLModel::getConnectionResolver(), 'encrypter' => Encrypter::getInstance(), 'config' => array('cache.driver' => 'database', 'cache.prefix' => 'schema_', 'cache.stores.database' => array('driver' => 'database', 'connection' => 'default', 'table' => 'cache')))));
         static::$store = $manager->driver('database')->getStore();
     }
     return static::$store;
 }

 public static function make()
 {
     if (is_null(self::$instance)) {
         $cacheManager = new CacheManager(array('files' => new FileSystem(), 'config' => array('cache.driver' => 'file', 'cache.path' => path('cache'), 'cache.prefix' => 'wordpress_')));
         $cache = $cacheManager->driver();
         self::$instance = new static($cache);
     }
     return self::$instance;
 }

 /**
  * Return the admin dashboard view.
  *
  * @return \Illuminate\View\View
  */
 public function showDashboard(CacheManager $cache)
 {
     $stats = ['Item stats' => ['Listed' => function ($range) use($cache) {
         return mustard_number($cache->remember('total_items', config('mustard.dashboard_cache'), function () use($range) {
             return Item::totalListed($range);
         }));
     }, 'Watched' => function ($range) use($cache) {
         return mustard_number($cache->remember('total_items', config('mustard.dashboard_cache'), function () use($range) {
             return Item::totalWatched($range);
         }));
     }], 'User stats' => ['Registered' => function ($range) use($cache) {
         return mustard_number($cache->remember('total_users', config('mustard.dashboard_cache'), function () use($range) {
             return User::totalRegistered($range);
         }));
     }, 'Sellers' => function ($range) use($cache) {
         return mustard_number($cache->remember('total_sellers', config('mustard.dashboard_cache'), function () use($range) {
             return User::totalSellers($range);
         }));
     }]];
     if (mustard_loaded('auctions')) {
         $stats['User stats']['Bidders'] = function ($range) use($cache) {
             return mustard_number($cache->remember('total_bidders', config('mustard.dashboard_cache'), function () use($range) {
                 return User::totalBidders($range);
             }));
         };
         $stats['Item stats']['Bids placed'] = function ($range) use($cache) {
             return mustard_number($cache->remember('total_bids_placed', config('mustard.dashboard_cache'), function () use($range) {
                 return \Hamjoint\Mustard\Auctions\Bid::totalPlaced($range);
             }));
         };
         $stats['Item stats']['Average bid amount'] = function ($range) use($cache) {
             return mustard_price($cache->remember('average_bids', config('mustard.dashboard_cache'), function () use($range) {
                 return \Hamjoint\Mustard\Auctions\Bid::averageAmount($range);
             }));
         };
     }
     if (mustard_loaded('commerce')) {
         $stats['User stats']['Buyers'] = function ($range) use($cache) {
             return mustard_number($cache->remember('total_buyers', config('mustard.dashboard_cache'), function () use($range) {
                 return User::totalBuyers($range);
             }));
         };
         $stats['Transaction stats']['Purchases'] = function ($range) use($cache) {
             return mustard_number($cache->remember('total_purchases', config('mustard.dashboard_cache'), function () use($range) {
                 return \Hamjoint\Mustard\Commerce\Purchase::totalCreated($range);
             }));
         };
         $stats['Transaction stats']['Average amount'] = function ($range) use($cache) {
             return mustard_price($cache->remember('average_purchases', config('mustard.dashboard_cache'), function () use($range) {
                 return \Hamjoint\Mustard\Commerce\Purchase::averageAmount($range);
             }));
         };
     }
     $ranges = ['Today' => strtotime('midnight'), 'This week' => strtotime('monday this week'), 'This month' => strtotime('midnight first day of this month'), 'This year' => strtotime(date('Y') . '/01/01'), 'Overall' => 0];
     return view('mustard::admin.dashboard', ['ranges' => $ranges, 'stats' => $stats]);
 }

 public function put($request, $file)
 {
     if ($file) {
         $this->cache->put($this->makeCacheKey($request), $file, Carbon::now()->addMinutes(env('CACHE_EXPIRE_MINUTES')));
     }
     return $this;
 }

 /**
  * Has
  * @param $key
  * @return bool
  */
 public function has($key)
 {
     if ($this->cacheDriver == "file") {
         return $this->cache->has($key);
     }
     return $this->cache->tags($this->tag)->has($key);
 }

 /**
  * Render weather widget.
  *
  * @param  array  $options
  * @return string
  */
 public function generate($options = array())
 {
     // Get options
     $options = array_merge($this->config['defaults'], $options);
     // Unify units
     $options['units'] = strtolower($options['units']);
     if (!in_array($options['units'], array('metric', 'imperial'))) {
         $options['units'] = 'imperial';
     }
     // Create cache key
     $cacheKey = 'Weather.' . md5(implode($options));
     // Check cache
     if ($this->config['cache'] && $this->cache->has($cacheKey)) {
         return $this->cache->get($cacheKey);
     }
     // Get current weather
     $current = $this->getWeather($options['query'], 0, $options['units'], 1);
     if ($current['cod'] !== 200) {
         return 'Unable to load weather';
     }
     // Get forecast
     $forecast = $this->getWeather($options['query'], $options['days'], $options['units']);
     // Render view
     $html = $this->view->make("{$this->config['views']}.{$options['style']}", array('current' => $current, 'forecast' => $forecast, 'units' => $options['units'], 'date' => $options['date']))->render();
     // Add to cache
     if ($this->config['cache']) {
         $this->cache->put($cacheKey, $html, $this->config['cache']);
     }
     return $html;
 }

 /**
  * Execute the console command.
  *
  * @return void
  */
 public function fire()
 {
     $this->laravel['events']->fire('cache:clearing');
     $this->cache->flush();
     $this->laravel['events']->fire('cache:cleared');
     $this->info('Application cache cleared!');
 }

 /**
  * Execute the console command.
  *
  * @return void
  */
 public function fire()
 {
     $this->cache->flush();
     $this->files->delete($this->laravel['config']['app.manifest'] . '/services.json');
     $this->laravel['events']->fire('cache:cleared');
     $this->info('Application cache cleared!');
 }

 /**
  * Execute the console command.
  *
  * @return void
  */
 public function fire()
 {
     $storeName = $this->argument('store');
     $this->laravel['events']->fire('cache:clearing', [$storeName]);
     $this->cache->store($storeName)->flush();
     $this->laravel['events']->fire('cache:cleared', [$storeName]);
     $this->info('Application cache cleared!');
 }

 public function handle()
 {
     $storeName = $this->config->get('laravel-responsecache.cacheStore');
     $this->laravel['events']->fire('responsecache:clearing', [$storeName]);
     $this->cache->store($storeName)->flush();
     $this->laravel['events']->fire('responsecache:cleared', [$storeName]);
     $this->info('Response cache cleared!');
 }

 /**
  * Execute the console command.
  *
  * @return mixed
  */
 public function handle()
 {
     if (null !== ($key = $this->argument('key'))) {
         $this->keys = [$key];
     }
     foreach ($this->keys as $key) {
         $this->cacheManager->store()->forget($key);
     }
     $this->cacheManager->store()->tags(['dbQueryCache'])->flush();
     $this->info('Clear cache successfully!');
 }

 /**
  * Render the homepage view for displaying.
  *
  * @param  string $name
  * @return string
  */
 public function render($name, $subname = 'Home.Content')
 {
     if ($this->cache->has('home.content')) {
         $content = $this->cache->get('home.content');
     } else {
         $slides = App::make('Lib\\Slides\\SlideRepository')->get();
         $news = App::make('Lib\\News\\NewsRepository')->latest(8);
         $content = $this->view->make($subname)->with('slides', $slides)->with('news', $news)->with('categories', $this->getCategories())->render();
         $this->cache->put('home.content', $content, 2880);
     }
     return $this->view->make($name)->with('content', $content);
 }

 /**
  * Lookup an item in the API.
  *
  * @param string $item
  * @param array  $params
  *
  * @return object
  */
 public function lookup($id, $value = null, $params = array())
 {
     $cacheKey = $this->cacheKey('lookup', $this->getLookupParams($id, $value, $params));
     $cacheDuration = $this->iTunesConfig['cache'];
     if ($this->cache->has($cacheKey)) {
         return $this->cache->get($cacheKey);
     } else {
         return $this->cache->remember($cacheKey, $cacheDuration, function () use($id, $value, $params) {
             return json_encode(parent::lookup($id, $value, $params));
         });
     }
 }

 /**
  * Execute the console command.
  *
  * @return void
  */
 public function handle()
 {
     $tags = array_filter(explode(',', $this->option('tags')));
     $cache = $this->cache->store($store = $this->argument('store'));
     $this->laravel['events']->fire('cache:clearing', [$store, $tags]);
     if (!empty($tags)) {
         $cache->tags($tags)->flush();
     } else {
         $cache->flush();
     }
     $this->info('Cache cleared successfully.');
     $this->laravel['events']->fire('cache:cleared', [$store, $tags]);
 }

 /**
  * @param $key
  * @param $value
  * @return bool
  */
 public function set($key, $value)
 {
     $setting = Setting::whereKey($key)->first();
     if (!is_object($setting)) {
         $setting = new Setting();
         $setting->key = $key;
     }
     $setting->value = $value;
     $setting->save();
     if ($this->application->isInstalled()) {
         $this->cache->forget($this->cache_key);
     }
     return true;
 }