| Server IP : 66.29.137.217 / Your IP : 3.135.182.208 Web Server : LiteSpeed System : Linux premium294.web-hosting.com 4.18.0-513.11.1.lve.el8.x86_64 #1 SMP Thu Jan 18 16:21:02 UTC 2024 x86_64 User : gltevjme ( 1095) PHP Version : 7.0.33 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : ON | Sudo : OFF | Pkexec : OFF Directory : /home/gltevjme/cbt.bofirm.com/vendor/intervention/imagecache/src/Intervention/Image/ |
Upload File : |
<?php
namespace Intervention\Image;
use Carbon\Carbon;
use Closure;
use Exception;
use Illuminate\Cache\FileStore;
use Illuminate\Cache\Repository as Cache;
use Illuminate\Cache\Repository;
use Illuminate\Filesystem\Filesystem;
class ImageCache
{
/**
* Cache lifetime in minutes
*
* @var integer
*/
public $lifetime = 5;
/**
* History of name and arguments of calls performed on image
*
* @var array
*/
public $calls = [];
/**
* Additional properties included in checksum
*
* @var array
*/
public $properties = [];
/**
* Processed Image
*
* @var Intervention\Image\Image
*/
public $image;
/**
* Intervention Image Manager
*
* @var Intervention\Image\ImageManager
*/
public $manager;
/**
* Illuminate Cache Manager
*
* @var Illuminate\Cache\CacheManager
*/
public $cache;
/**
* Create a new instance
*/
public function __construct(ImageManager $manager = null, Cache $cache = null)
{
$this->manager = $manager ? $manager : new ImageManager();
if (is_null($cache)) {
// get laravel app
$app = function_exists('app') ? app() : null;
// if laravel app cache exists
if (is_a($app, 'Illuminate\Foundation\Application')) {
$cache = $app->make('cache');
}
if (is_a($cache, 'Illuminate\Cache\CacheManager')) {
// add laravel cache and set custom cache_driver if persist
$cache_driver = config('imagecache.cache_driver');
$this->cache = $cache_driver ? $cache->driver($cache_driver) : $cache;
} else {
// define path in filesystem
if (isset($manager->config['cache']['path'])) {
$path = $manager->config['cache']['path'];
} else {
$path = __DIR__ . '/../../../storage/cache';
}
// create new default cache
$filesystem = new Filesystem();
$storage = new FileStore($filesystem, $path);
$this->cache = new Repository($storage);
}
} else {
$this->cache = $cache;
}
}
/**
* Magic method to capture action calls
*
* @param String $name
* @param Array $arguments
* @return Intervention\Image\ImageCache
*/
public function __call($name, $arguments)
{
$this->registerCall($name, $arguments);
return $this;
}
/**
* Special make method to add modifed data to checksum
*
* @param mixed $data
* @return Intervention\Image\ImageCache
*/
public function make($data)
{
// include "modified" property for any files
if ($this->isFile($data)) {
$this->setProperty('modified', filemtime((string) $data));
}
// register make call
$this->__call('make', [$data]);
return $this;
}
/**
* Checks if given data is file, handles mixed input
*
* @param mixed $value
* @return boolean
*/
protected function isFile($value)
{
$value = strval(str_replace("\0", "", $value));
return strlen($value) <= PHP_MAXPATHLEN && is_file($value);
}
/**
* Set custom property to be included in checksum
*
* @param mixed $key
* @param mixed $value
* @return Intervention\Image\ImageCache
*/
public function setProperty($key, $value)
{
$this->properties[$key] = $value;
return $this;
}
/**
* Returns checksum of current image state
*
* @return string
*/
public function checksum()
{
$properties = serialize($this->properties);
$calls = serialize($this->getSanitizedCalls());
return md5($properties . $calls);
}
/**
* Register static call for later use
*
* @param string $name
* @param array $arguments
* @return void
*/
protected function registerCall($name, $arguments)
{
$this->calls[] = [
'name' => $name,
'arguments' => $arguments,
];
}
/**
* Clears history of calls
*
* @return void
*/
protected function clearCalls()
{
$this->calls = [];
}
/**
* Clears all currently set properties
*
* @return void
*/
protected function clearProperties()
{
$this->properties = [];
}
/**
* Return unprocessed calls
*
* @return array
*/
protected function getCalls()
{
return count($this->calls) ? $this->calls : [];
}
/**
* Replace Closures in arguments with SerializableClosure
*
* @return array
*/
protected function getSanitizedCalls()
{
$calls = $this->getCalls();
foreach ($calls as $i => $call) {
foreach ($call['arguments'] as $j => $argument) {
if (is_a($argument, Closure::class)) {
$calls[$i]['arguments'][$j] = $this->getClosureHash($argument);
}
}
}
return $calls;
}
/**
* Build hash from closure
*
* @param Closure $closure
* @return string
*/
protected function getClosureHash(Closure $closure)
{
return (new HashableClosure($closure))->getHash();
}
/**
* Process call on current image
*
* @param array $call
* @return void
*/
protected function processCall($call)
{
$this->image = call_user_func_array(
[
$this->image,
$call['name']
],
$call['arguments']
);
}
/**
* Process all saved image calls on Image object
*
* @return Intervention\Image\Image
*/
public function process()
{
// first call on manager
$this->image = $this->manager;
// process calls on image
foreach ($this->getCalls() as $call) {
$this->processCall($call);
}
// append checksum to image
$this->image->cachekey = $this->checksum();
// clean-up
$this->clearCalls();
$this->clearProperties();
return $this->image;
}
/**
* Get image either from cache or directly processed
* and save image in cache if it's not saved yet
*
* @param int $lifetime
* @param bool $returnObj
* @return mixed
*/
public function get($lifetime = null, $returnObj = false)
{
$lifetime = is_null($lifetime) ? $this->lifetime : intval($lifetime);
$key = $this->checksum();
// try to get image from cache
$cachedImageData = $this->cache->get($key);
// if imagedata exists in cache
if ($cachedImageData) {
// transform into image-object
if ($returnObj) {
$image = $this->manager->make($cachedImageData);
return (new CachedImage())->setFromOriginal($image, $key);
}
// return raw data
return $cachedImageData;
} else {
// process image data
$image = $this->process();
// encode image data only if image is not encoded yet
$encoded = $image->encoded ? $image->encoded : (string) $image->encode();
// save to cache...
$this->cache->put($key, $encoded, Carbon::now()->addMinutes($lifetime));
// return processed image
return $returnObj ? $image : $encoded;
}
}
}