oxdynimggenerator.php

Go to the documentation of this file.

<?php

require_once dirname(__FILE__) . "/../bootstrap.php";

// Checks if base path getter does not exist
if (!function_exists("getShopBasePath")) {
    function getShopBasePath()
    {
        return realpath(dirname(__FILE__) . '/..') . '/';
    }
}


// disables admin
if (!function_exists('isAdmin')) {
    function isAdmin()
    {
        return false;
    }
}

// starts shop framework and returns config instance
if (!function_exists("getConfig")) {
    function getConfig()
    {
        // custom functions file
        include_once getShopBasePath() . 'modules/functions.php';

        // Generic utility method file
        include_once getShopBasePath() . 'core/oxfunctions.php';

        // initializes singleton config class
        return oxRegistry::getConfig();
    }
}

// Checks if instance name getter does not exist
if (!function_exists("getGeneratorInstanceName")) {
    function getGeneratorInstanceName()
    {
        return "oxdynimggenerator";
    }
}

// checks if GD library version getter does not exist
if (!function_exists("getGdVersion")) {
    function getGdVersion()
    {
        static $iVersion = null;

        if ($iVersion === null) {
            $iVersion = false;
            if (function_exists("gd_info")) {
                // extracting GD version from php
                $aInfo = gd_info();
                if (isset($aInfo["GD Version"])) {
                    $iVersion = version_compare(preg_replace("/[^0-9\.]/", "", $aInfo["GD Version"]), 1, '>') ? 2 : 1;
                }
            }

        }

        return $iVersion;
    }
}

// checks if image utils file loader does not exist
if (!function_exists("includeImageUtils")) {
    function includeImageUtils()
    {
        include_once getShopBasePath() . "core/utils/oxpicgenerator.php";
    }
}

class oxDynImgGenerator
{

    protected static $_oInstance = null;

    protected $_aHeaders = array();

    protected $_aAllowedImgTypes = array("jpg", "jpeg", "png", "gif");

    protected $_sImageInfoSep = "_";

    protected $_hLockHandle = null;

    protected $_sImageUri = null;

    protected $_aConfParamToPath = array( // ** product
        "sIconsize"             => '/.*\/generated\/product\/(icon|\d+)\/\d+\_\d+\_\d+$/', // Icon size
        "sThumbnailsize"        => '/.*\/generated\/product\/(thumb|\d+)\/\d+\_\d+\_\d+$/', // Thumbnail size
        "sZoomImageSize"        => '/.*\/generated\/product\/\d+\/\d+\_\d+\_\d+$/', // Zoom picture size
        "aDetailImageSizes"     => '/.*\/generated\/product\/\d+\/\d+\_\d+\_\d+$/', // Product picture size

        // ** manufacturer/vendor
        "sManufacturerIconsize" => '/.*\/generated\/(manufacturer|vendor)\/icon\/\d+\_\d+\_\d+$/', // Manufacturer's|brand logo size

        // ** category
        "sCatThumbnailsize"     => '/.*\/generated\/category\/thumb\/\d+\_\d+\_\d+$/', // Category picture size
        "sCatIconsize"          => '/.*\/generated\/category\/icon\/\d+\_\d+\_\d+$/', // Size of a subcategory's picture
        "sCatPromotionsize"     => '/.*\/generated\/category\/promo_icon\/\d+\_\d+\_\d+$/' // Category picture size for promotion on startpage
    );

    public static function getInstance()
    {
        if (self::$_oInstance === null) {
            $sInstanceName = getGeneratorInstanceName();
            self::$_oInstance = new $sInstanceName();
        }

        return self::$_oInstance;
    }

    public function __call($sMethod, $aArgs)
    {
        if (defined('OXID_PHP_UNIT')) {
            if (substr($sMethod, 0, 4) == "UNIT") {
                $sMethod = str_replace("UNIT", "_", $sMethod);
            }
            if (method_exists($this, $sMethod)) {
                return call_user_func_array(array(& $this, $sMethod), $aArgs);
            }
        }

        throw new oxSystemComponentException("Function '$sMethod' does not exist or is not accessible! (" . get_class($this) . ")" . PHP_EOL);
    }

    protected function _getShopBasePath()
    {
        return getConfig()->getConfigParam("sShopDir");
    }

    protected function _getImageUri()
    {
        if ($this->_sImageUri === null) {

            $this->_sImageUri = "";
            $sReqPath = "out/pictures/generated";


            $sReqImg = isset($_SERVER["REQUEST_URI"]) ? urldecode($_SERVER["REQUEST_URI"]) : "";
            $sReqImg = str_replace('//', '/', $sReqImg);
            if (($iPos = strpos($sReqImg, $sReqPath)) !== false) {
                $this->_sImageUri = substr($sReqImg, $iPos);
            }

            $this->_sImageUri = trim($this->_sImageUri, "/");
        }

        return $this->_sImageUri;
    }

    protected function _getImageName()
    {
        return basename($this->_getImageUri());
    }

    protected function _getImageMasterPath()
    {
        $sUri = $this->_getImageUri();
        $sPath = false;

        if ($sUri && ($sPath = dirname(dirname($sUri)))) {
            $sPath = preg_replace("/\/([^\/]*)\/([^\/]*)\/([^\/]*)$/", "/master/\\2/\\3/", $sPath);
        }

        return $sPath;
    }

    protected function _getImageInfo()
    {
        $aInfo = array();
        if (($sUri = $this->_getImageUri())) {
            $aInfo = explode($this->_sImageInfoSep, basename(dirname($sUri)));
        }

        return $aInfo;
    }

    protected function _getImageTarget()
    {
        return $this->_getShopBasePath() . $this->_getImageUri();
    }

    protected function _getNopicImageTarget()
    {
        $sPath = $this->_getShopBasePath() . $this->_getImageUri();

        return str_replace($this->_getImageName(), "nopic.jpg", $sPath);
    }

    protected function _getImageType()
    {
        $sType = preg_replace("/.*\.(png|jp(e)?g|gif)$/", "\\1", $this->_getImageName());
        $sType = (strcmp($sType, "jpg") == 0) ? "jpeg" : $sType;

        return in_array($sType, $this->_aAllowedImgTypes) ? $sType : false;
    }

    protected function _generatePng($sSource, $sTarget, $iWidth, $iHeight)
    {
        return resizePng($sSource, $sTarget, $iWidth, $iHeight, @getimagesize($sSource), getGdVersion(), null);
    }

    protected function _generateJpg($sSource, $sTarget, $iWidth, $iHeight, $iQuality)
    {
        return resizeJpeg($sSource, $sTarget, $iWidth, $iHeight, @getimagesize($sSource), getGdVersion(), null, $iQuality);
    }

    protected function _generateGif($sSource, $sTarget, $iWidth, $iHeight)
    {
        $aImageInfo = @getimagesize($sSource);

        return resizeGif($sSource, $sTarget, $iWidth, $iHeight, $aImageInfo[0], $aImageInfo[1], getGdVersion());
    }

    protected function _isTargetPathValid($sPath)
    {
        $blValid = true;
        $sDir = dirname(trim($sPath));

        // first time folder access?
        if (!is_dir($sDir) && ($blValid = $this->_isValidPath($sDir))) {
            // creating missing folders
            $blValid = $this->_createFolders($sDir);
        }

        return $blValid;
    }

    protected function _createFolders($sDir)
    {
        $oConfig = getConfig();
        $sPicFolderPath = dirname($oConfig->getMasterPictureDir());

        $blDone = false;
        if ($sPicFolderPath && is_dir($sPicFolderPath)) {

            // if its in main path..
            if (strcmp($sPicFolderPath, substr($sDir, 0, strlen($sPicFolderPath))) == 0) {
                // folder does not exist yet?
                if (!($blDone = file_exists($sDir))) {
                    clearstatcache();
                    // in case creation did not succeed, maybe another process allready created folder?
                    $iMode = 0755;
                    if (defined('OXID_PHP_UNIT')) {
                        $iMode = 0777;
                    }
                    $blDone = mkdir($sDir, $iMode, true) || file_exists($sDir);
                }
            }
        }

        return $blDone;
    }

    protected function _isValidPath($sPath)
    {
        $blValid = false;

        list($iWidth, $iHeight, $sQuality) = $this->_getImageInfo();
        if ($iWidth && $iHeight && $sQuality) {

            $oConfig = getConfig();
            $oDb = oxDb::getDb(oxDb::FETCH_MODE_ASSOC);

            // parameter names
            $sNames = '';
            foreach ($this->_aConfParamToPath as $sParamName => $sPathReg) {
                if (preg_match($sPathReg, $sPath)) {
                    if ($sNames) {
                        $sNames .= ", ";
                    }
                    $sNames .= $oDb->quote($sParamName);

                    if ($sParamName == "sManufacturerIconsize" || $sParamName == "sCatIconsize") {
                        $sNames .= ", " . $oDb->quote("sIconsize");
                    }
                }
            }

            // any name matching path?
            if ($sNames) {

                $sDecodeField = $oConfig->getDecodeValueQuery();

                // selecting shop which image quality matches user given
                $sQ = "select oxshopid from oxconfig where oxvarname = 'sDefaultImageQuality' and
                       {$sDecodeField} = " . $oDb->quote($sQuality);

                $aShopIds = $oDb->getAll($sQ);

                // building query:
                // shop id
                $sShopIds = '';
                foreach ($aShopIds as $aShopId) {

                    // probably here we can resolve and check shop id to shorten check?


                    if ($sShopIds) {
                        $sShopIds .= ", ";
                    }
                    $sShopIds .= $oDb->quote($aShopId["oxshopid"]);
                }

                // any shop matching quality
                if ($sShopIds) {

                    //
                    $sCheckSize = "$iWidth*$iHeight";

                    // selecting config variables to check
                    $sQ = "select oxvartype, {$sDecodeField} as oxvarvalue from oxconfig
                           where oxvarname in ( {$sNames} ) and oxshopid in ( {$sShopIds} ) order by oxshopid";

                    $aValues = $oDb->getAll($sQ);
                    foreach ($aValues as $aValue) {
                        $aConfValues = (array) $oConfig->decodeValue($aValue["oxvartype"], $aValue["oxvarvalue"]);
                        foreach ($aConfValues as $sValue) {
                            if (strcmp($sCheckSize, $sValue) == 0) {
                                $blValid = true;
                                break;
                            }
                        }
                    }
                }
            }
        }

        return $blValid;
    }

    protected function _generateImage($sImageSource, $sImageTarget)
    {
        $sPath = false;
        $fileExtensionSource = strtolower(pathinfo($sImageSource, PATHINFO_EXTENSION));

        if (getGdVersion() !== false && $this->_isTargetPathValid($sImageTarget) && ($sImageType = $this->_getImageType())) {

            // including generator files
            includeImageUtils();

            // in case lock file creation failed should check if another process did not created image yet
            if ($this->_lock($sImageTarget)) {

                // extracting image info - size/quality
                list($iWidth, $iHeight, $iQuality) = $this->_getImageInfo();
                switch ($fileExtensionSource) {
                    case "png":
                        $sPath = $this->_generatePng($sImageSource, $sImageTarget, $iWidth, $iHeight);
                        break;
                    case "jpeg":
                    case "jpg":
                        $sPath = $this->_generateJpg($sImageSource, $sImageTarget, $iWidth, $iHeight, $iQuality);
                        break;
                    case "gif":
                        $sPath = $this->_generateGif($sImageSource, $sImageTarget, $iWidth, $iHeight);
                        break;
                }

                // releasing..
                if ($sPath) {
                    $this->_unlock($sImageTarget);
                }
            } else {
                // assuming that image was created by another process
                $sPath = file_exists($sImageTarget) ? $sImageTarget : false;
            }
        }

        return $sPath;
    }

    protected function _getLockName($sName)
    {
        return "$sName.lck";
    }

    protected function _lock($sSource)
    {
        $blLocked = false;
        $sLockName = $this->_getLockName($sSource);

        // creating lock file
        $this->_hLockHandle = @fopen($this->_getLockName($sSource), "w");
        if ($this->_hLockHandle) {
            if (!($blLocked = flock($this->_hLockHandle, LOCK_EX))) {
                // on failure - closing
                fclose($this->_hLockHandle);
            }
        }

        // in case system does not support file lockings
        if (!$blLocked) {
            // start a blank file to inform other processes we are dealing with it.
            if (!(file_exists($this->_getLockName($sSource)) && abs(time() - filectime($this->_getLockName($sSource)) < 40))) {
                if ($this->_hLockHandle = @fopen($this->_getLockName($sSource), "w")) {
                    $blLocked = true;
                }
            }
        }

        return $blLocked;
    }

    protected function _unlock($sSource)
    {
        if ($this->_hLockHandle) {
            flock($this->_hLockHandle, LOCK_UN);
            fclose($this->_hLockHandle);
            unlink($this->_getLockName($sSource));
        }
    }

    public function getImagePath($sAbsPath = false)
    {
        if ($sAbsPath) {
            $this->_sImageUri = str_replace($this->_getShopBasePath(), "", $sAbsPath);
        }

        $sImagePath = false;
        $sMasterPath = $this->_getImageMasterPath();

        // building base path + extracting image name + extracting master image path
        $sMasterImagePath = $this->_getShopBasePath() . $sMasterPath . $this->_getImageName();

        if (file_exists($sMasterImagePath)) {
            $sGenImagePath = $this->_getImageTarget();
        } else {
            // nopic master path
            $sMasterImagePath = $this->_getShopBasePath() . dirname(dirname($sMasterPath)) . "/nopic.jpg";
            $sGenImagePath = $this->_getNopicImageTarget();

            // 404 header for nopic
            $this->_setHeader("HTTP/1.0 404 Not Found");
        }

        // checking if master image is accessible
        if (file_exists($sGenImagePath)) {
            $sImagePath = $sGenImagePath;
        } elseif (file_exists($sMasterImagePath)) {
            // generating image
            $sImagePath = $this->_generateImage($sMasterImagePath, $sGenImagePath);
        }

        if ($sImagePath) {
            // image type header
            $this->_setHeader("Content-Type: image/" . $this->_getImageType());
        } else {
            // unable to output any file
            $this->_setHeader("HTTP/1.0 404 Not Found");
        }

        return $sImagePath;
    }

    public function outputImage()
    {
        $blBuffer = true;
        if (defined('OXID_PHP_UNIT')) {
            $blBuffer = false;
        }

        // starting output buffering
        if ($blBuffer) {
            ob_start();
        }

        //
        $sImgPath = $this->getImagePath();

        // cleaning extra output
        if ($blBuffer) {
            ob_clean();
        }

        // outputting headers
        $aHeaders = $this->_getHeaders();
        foreach ($aHeaders as $sHeader) {
            header($sHeader);
        }

        // sending headers
        if ($blBuffer) {
            ob_end_flush();
        }

        // file is generated?
        if ($sImgPath) {
            // outputting file
            @readfile($sImgPath);
        }
    }

    protected function _setHeader($sHeader)
    {
        $this->_aHeaders[] = $sHeader;
    }

    protected function _getHeaders()
    {
        return $this->_aHeaders;
    }
}