Class luya\web\filters\ResponseCache

                public function __call($name, $params)
{
    throw new UnknownMethodException('Calling unknown method: ' . get_class($this) . "::$name()");
}

            

                public function __construct($config = [])
{
    if (!empty($config)) {
        Yii::configure($this, $config);
    }
    $this->init();
}

            

                public function __get($name)
{
    $getter = 'get' . $name;
    if (method_exists($this, $getter)) {
        return $this->$getter();
    } elseif (method_exists($this, 'set' . $name)) {
        throw new InvalidCallException('Getting write-only property: ' . get_class($this) . '::' . $name);
    }
    throw new UnknownPropertyException('Getting unknown property: ' . get_class($this) . '::' . $name);
}

            

                public function __isset($name)
{
    $getter = 'get' . $name;
    if (method_exists($this, $getter)) {
        return $this->$getter() !== null;
    }
    return false;
}

            

                public function __set($name, $value)
{
    $setter = 'set' . $name;
    if (method_exists($this, $setter)) {
        $this->$setter($value);
    } elseif (method_exists($this, 'get' . $name)) {
        throw new InvalidCallException('Setting read-only property: ' . get_class($this) . '::' . $name);
    } else {
        throw new UnknownPropertyException('Setting unknown property: ' . get_class($this) . '::' . $name);
    }
}

            

                public function __unset($name)
{
    $setter = 'set' . $name;
    if (method_exists($this, $setter)) {
        $this->$setter(null);
    } elseif (method_exists($this, 'get' . $name)) {
        throw new InvalidCallException('Unsetting read-only property: ' . get_class($this) . '::' . $name);
    }
}

            

                public function addDynamicPlaceholder($name, $statements)
{
    $this->_dynamicPlaceholders[$name] = $statements;
}

            

                public function afterAction($action, $result)
{
    return $result;
}

            

                public function afterFilter($event)
{
    $event->result = $this->afterAction($event->action, $event->result);
    $this->owner->off(Controller::EVENT_AFTER_ACTION, [$this, 'afterFilter']);
}

            

                public function afterRestoreResponse($data)
{
}

            

                public function attach($owner)
{
    $this->owner = $owner;
    $owner->on(Controller::EVENT_BEFORE_ACTION, [$this, 'beforeFilter']);
}

            

                public function beforeCacheResponse()
{
    return true;
}

            

                public function beforeFilter($event)
{
    if (!$this->isActive($event->action)) {
        return;
    }
    $event->isValid = $this->beforeAction($event->action);
    if ($event->isValid) {
        // call afterFilter only if beforeFilter succeeds
        // beforeFilter and afterFilter should be properly nested
        $this->owner->on(Controller::EVENT_AFTER_ACTION, [$this, 'afterFilter'], null, false);
    } else {
        $event->handled = true;
    }
}

            

                public function cacheResponse()
{
    $this->view->popDynamicContent();
    $beforeCacheResponseResult = $this->beforeCacheResponse();
    if ($beforeCacheResponseResult === false) {
        echo $this->updateDynamicContent(ob_get_clean(), $this->getDynamicPlaceholders());
        return;
    }
    $response = Yii::$app->getResponse();
    $response->off(Response::EVENT_AFTER_SEND, [$this, 'cacheResponse']);
    $data = [
        'cacheVersion' => static::PAGE_CACHE_VERSION,
        'cacheData' => is_array($beforeCacheResponseResult) ? $beforeCacheResponseResult : null,
        'content' => ob_get_clean(),
    ];
    if ($data['content'] === false || $data['content'] === '') {
        return;
    }
    $data['dynamicPlaceholders'] = $this->getDynamicPlaceholders();
    foreach (['format', 'version', 'statusCode', 'statusText'] as $name) {
        $data[$name] = $response->{$name};
    }
    $this->insertResponseHeaderCollectionIntoData($response, $data);
    $this->insertResponseCookieCollectionIntoData($response, $data);
    $this->cache->set($this->calculateCacheKey(), $data, $this->duration, $this->dependency);
    $data['content'] = $this->updateDynamicContent($data['content'], $this->getDynamicPlaceholders());
    echo $data['content'];
}

            

                protected function calculateCacheKey()
{
    $key = [__CLASS__];
    if ($this->varyByRoute) {
        $key[] = Yii::$app->requestedRoute;
    }
    return array_merge($key, (array)$this->variations);
}

            

                public function canGetProperty($name, $checkVars = true)
{
    return method_exists($this, 'get' . $name) || $checkVars && property_exists($this, $name);
}

            

                public function canSetProperty($name, $checkVars = true)
{
    return method_exists($this, 'set' . $name) || $checkVars && property_exists($this, $name);
}

            

                public static function className()
{
    return get_called_class();
}

            

                public function deleteHasCache($key)
{
    if ($this->isCachable()) {
        return Yii::$app->cache->delete($key);
    }
    
    return false;
}

            

                public function detach()
{
    if ($this->owner) {
        $this->owner->off(Controller::EVENT_BEFORE_ACTION, [$this, 'beforeFilter']);
        $this->owner->off(Controller::EVENT_AFTER_ACTION, [$this, 'afterFilter']);
        $this->owner = null;
    }
}

            

                public function events()
{
    return [];
}

            

                public function flushHasCache()
{
    if ($this->isCachable()) {
        return Yii::$app->cache->flush();
    }
    
    return false;
}

            

                protected function getActionId($action)
{
    if ($this->owner instanceof Module) {
        $mid = $this->owner->getUniqueId();
        $id = $action->getUniqueId();
        if ($mid !== '' && strpos($id, $mid) === 0) {
            $id = substr($id, strlen($mid) + 1);
        }
    } else {
        $id = $action->id;
    }
    return $id;
}

            

                public function getDynamicPlaceholders()
{
    return $this->_dynamicPlaceholders;
}

            

                public function getHasCache($key)
{
    if ($this->isCachable()) {
        $data = Yii::$app->cache->get($key);
        
        $enumKey = (is_array($key)) ? implode(",", $key) : $key;
        
        if ($data) {
            Yii::debug("Cacheable trait key '$enumKey' successfully loaded from cache.", __METHOD__);
            return $data;
        }
        Yii::debug("Cacheable trait key '$enumKey' has not been found in cache.", __METHOD__);
    }

    return false;
}

            

                public function getOrSetHasCache($key, \Closure $closure, $duration = null, $dependency = null)
{
    if (($value = $this->getHasCache($key)) !== false) {
        return $value;
    }
    
    $value = call_user_func($closure, $this);
    
    $this->setHasCache($key, $value, $dependency, $duration);
    
    return $value;
}

            

                public function getView()
{
    return $this->view;
}

            

                public function hasMethod($name)
{
    return method_exists($this, $name);
}

            

                public function hasProperty($name, $checkVars = true)
{
    return $this->canGetProperty($name, $checkVars) || $this->canSetProperty($name, false);
}

            

                protected function isActive($action)
{
    $id = $this->getActionId($action);
    if (empty($this->only)) {
        $onlyMatch = true;
    } else {
        $onlyMatch = false;
        foreach ($this->only as $pattern) {
            if (StringHelper::matchWildcard($pattern, $id)) {
                $onlyMatch = true;
                break;
            }
        }
    }
    $exceptMatch = false;
    foreach ($this->except as $pattern) {
        if (StringHelper::matchWildcard($pattern, $id)) {
            $exceptMatch = true;
            break;
        }
    }
    return !$exceptMatch && $onlyMatch;
}

            

                public function isCachable()
{
    if ($this->_cachable === null) {
        $this->_cachable = Yii::$app->has('cache') ? true : false;
    }

    return $this->_cachable;
}

            

                protected function restoreResponse($response, $data)
{
    foreach (['format', 'version', 'statusCode', 'statusText', 'content'] as $name) {
        $response->{$name} = $data[$name];
    }
    foreach (['headers', 'cookies'] as $name) {
        if (isset($data[$name]) && is_array($data[$name])) {
            $response->{$name}->fromArray(array_merge($data[$name], $response->{$name}->toArray()));
        }
    }
    if (!empty($data['dynamicPlaceholders']) && is_array($data['dynamicPlaceholders'])) {
        $response->content = $this->updateDynamicContent($response->content, $data['dynamicPlaceholders'], true);
    }
    $this->afterRestoreResponse(isset($data['cacheData']) ? $data['cacheData'] : null);
}

            

                public function setDynamicPlaceholders($placeholders)
{
    $this->_dynamicPlaceholders = $placeholders;
}

            

                public function setHasCache($key, $value, $dependency = null, $cacheExpiration = null)
{
    if ($this->isCachable()) {
        if (is_array($dependency)) {
            $dependency = Yii::createObject($dependency);
        }
        
        return Yii::$app->cache->set($key, $value, is_null($cacheExpiration) ? $this->_cacheExpiration : $cacheExpiration, $dependency);
    }
    
    return false;
}

            

                protected function updateDynamicContent($content, $placeholders, $isRestoredFromCache = false)
{
    if (empty($placeholders) || !is_array($placeholders)) {
        return $content;
    }
    if (count($this->getView()->getDynamicContents()) === 0) {
        // outermost cache: replace placeholder with dynamic content
        foreach ($placeholders as $name => $statements) {
            $placeholders[$name] = $this->getView()->evaluateDynamicContent($statements);
        }
        $content = strtr($content, $placeholders);
    }
    if ($isRestoredFromCache) {
        $view = $this->getView();
        foreach ($placeholders as $name => $statements) {
            $view->addDynamicPlaceholder($name, $statements);
        }
    }
    return $content;
}