oxdynimggenerator.php

Go to the documentation of this file.

<?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 oxConfig::getInstance();
    }
}

// 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"] ) ? $_SERVER["REQUEST_URI"] : "";
            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;

        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 ( $sImageType ) {
                    case "png":
                        $sPath = $this->_generatePng( $sImageSource, $sImageTarget, $iWidth, $iHeight );
                        break;
                    case "jpeg":
                        $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( $rHandle );
             }
        }

        // 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;
    }
}