oxutilsobject.php

Go to the documentation of this file.

<?php

class oxUtilsObject
{

    const CACHE_FILE_PREFIX = "config";

    protected $_aClassNameCache = array();

    protected static $_aLoadedArticles = array();

    protected static $_aInstanceCache = array();

    protected static $_aModuleVars = array();

    protected static $_aClassInstances = array();

    private static $_instance = null;

    public static function getInstance()
    {
        // disable caching for test modules
        if ( defined( 'OXID_PHP_UNIT' ) ) {
            self::$_instance = null;
        }

        if ( !self::$_instance instanceof oxUtilsObject ) {

            // allow modules
            $oUtilsObject = new oxUtilsObject();
            self::$_instance = $oUtilsObject->oxNew( 'oxUtilsObject' );
        }
        return self::$_instance;
    }

    public static function setClassInstance( $sClassName, $oInstance )
    {
        $sClassName = strtolower( $sClassName );
        self::$_aClassInstances[$sClassName] = $oInstance;
    }

    public static function resetClassInstances()
    {
        self::$_aClassInstances = array();
    }

    public static function resetModuleVars()
    {
        self::$_aModuleVars = array();

        $sMask = oxRegistry::get("oxConfigFile")->getVar("sCompileDir") . "/" . self::CACHE_FILE_PREFIX . ".*.txt" ;
        $aFiles = glob( $sMask );
        if ( is_array( $aFiles ) ) {
            foreach ( $aFiles as $sFile ) {
                if (is_file($sFile)) {
                    @unlink($sFile);
                }
            }
        }
    }

    public function oxNew( $sClassName )
    {
        $aArgs = func_get_args();
        array_shift( $aArgs );
        $iArgCnt = count( $aArgs );
        $blCacheObj = $iArgCnt < 2;
        $sClassName = strtolower( $sClassName );

        if ( isset( self::$_aClassInstances[$sClassName] ) ) {
            return self::$_aClassInstances[$sClassName];
        }
        if ( !defined( 'OXID_PHP_UNIT' ) && $blCacheObj ) {
            $sCacheKey  = ( $iArgCnt )?$sClassName.md5( serialize( $aArgs ) ):$sClassName;
            if ( isset( self::$_aInstanceCache[$sCacheKey] ) ) {
                return clone self::$_aInstanceCache[$sCacheKey];
            }
        }

        // performance
        if ( !defined( 'OXID_PHP_UNIT' ) && isset( $this->_aClassNameCache[$sClassName] ) ) {
            $sActionClassName = $this->_aClassNameCache[$sClassName];
        } else {
            $sActionClassName = $this->getClassName( $sClassName );
            //expect __autoload() (oxfunctions.php) to do its job when class_exists() is called
            if ( !class_exists( $sActionClassName ) ) {
                $oEx = oxNew( "oxSystemComponentException" );
                $oEx->setMessage('EXCEPTION_SYSTEMCOMPONENT_CLASSNOTFOUND');
                $oEx->setComponent($sClassName);
                $oEx->debugOut();
                throw $oEx;
            }
            // performance
            $this->_aClassNameCache[$sClassName] = $sActionClassName;
        }

        $oActionObject = $this->_getObject( $sActionClassName, $iArgCnt, $aArgs );
        if ( $blCacheObj && $oActionObject instanceof oxBase ) {
            self::$_aInstanceCache[$sCacheKey] = clone $oActionObject;
        }

        return $oActionObject;
    }

    protected function _getObject( $sClassName, $iArgCnt, $aParams )
    {
        // dynamic creation (if parameter count < 4) gives more performance for regular objects
        switch( $iArgCnt ) {
            case 0:
                $oObj = new $sClassName();
                break;
            case 1:
                $oObj = new $sClassName( $aParams[0] );
                break;
            case 2:
                $oObj = new $sClassName( $aParams[0], $aParams[1] );
                break;
            case 3:
                $oObj = new $sClassName( $aParams[0], $aParams[1], $aParams[2] );
                break;
            default:
                try {
                    // unlimited constructor arguments support
                    $oRo = new ReflectionClass( $sClassName );
                    $oObj = $oRo->newInstanceArgs( $aParams );
                } catch ( ReflectionException $oRefExcp ) {
                    // something went wrong?
                    $oEx = oxNew( "oxSystemComponentException" );
                    $oEx->setMessage( $oRefExcp->getMessage() );
                    $oEx->setComponent( $sClassName );
                    $oEx->debugOut();
                    throw $oEx;
                }
        }

        return $oObj;
    }

    public function oxNewArticle( $sOxID, $aProperties = array())
    {
        if ( $sOxID && isset( self::$_aLoadedArticles[$sOxID] ) ) {
            return self::$_aLoadedArticles[$sOxID];
        }

        $oActionObject = $this->oxNew( 'oxarticle' );

        // adding object prioperties
        foreach ( $aProperties as $sPropertyName => $sPropertyVal ) {
            $oActionObject->$sPropertyName = $sPropertyVal;
        }

        $oActionObject->load( $sOxID );

        self::$_aLoadedArticles[$sOxID] = $oActionObject;
        return $oActionObject;
    }

    public function resetInstanceCache($sClassName = null)
    {
        if ($sClassName && isset(self::$_aInstanceCache[$sClassName])) {
            unset(self::$_aInstanceCache[$sClassName]);
            return;
        }

        //looping due to possible memory "leak".
        if (is_array(self::$_aInstanceCache)) {
            foreach (self::$_aInstanceCache as $sKey => $oInstance) {
                unset(self::$_aInstanceCache[$sKey]);
            }
        }

        self::$_aInstanceCache = array();
    }

    public function generateUId()
    {
        return /*substr( $this->getSession()->getId(), 0, 3 ) . */ substr( md5( uniqid( '', true ).'|'.microtime() ), 0, 32 );
    }



    public function getClassName( $sClassName )
    {
        //$aModules = $this->getConfig()->getConfigParam( 'aModules' );
        $aModules = $this->getModuleVar('aModules');
        $aClassChain = array();


        if (is_array( $aModules )) {

            $aModules = array_change_key_case( $aModules );

            if ( array_key_exists( $sClassName, $aModules ) ) {
                //multiple inheritance implementation
                //in case we have multiple modules:
                //like oxoutput => sub/suboutput1&sub/suboutput2&sub/suboutput3
                $aClassChain = explode( "&", $aModules[$sClassName] );
                $aClassChain = $this->_getActiveModuleChain( $aClassChain );
            }

            if (count($aClassChain)) {
                $sParent = $sClassName;

                //security: just preventing string termination
                $sParent = str_replace(chr(0), '', $sParent);

                //building middle classes if needed
                $sClassName = $this->_makeSafeModuleClassParents( $aClassChain, $sParent );
            }
        }

        // check if there is a path, if yes, remove it
        $sClassName = basename( $sClassName );

        return $sClassName;
    }

    protected function _getActiveModuleChain( $aClassChain )
    {
        $aDisabledModules = $this->getModuleVar( 'aDisabledModules' );
        $aModulePaths     = $this->getModuleVar( 'aModulePaths' );

        if (is_array( $aDisabledModules ) && count($aDisabledModules) > 0) {
            foreach ($aDisabledModules as $sId) {
                $sPath = $aModulePaths[$sId];
                if (!isset($sPath)) {
                    $sPath = $sId;
                }
                foreach ( $aClassChain as $sKey => $sModuleClass ) {
                    if ( strpos($sModuleClass, $sPath."/" ) === 0 ) {
                        unset( $aClassChain[$sKey] );
                    }
                    // If module consists of one file without own dir (getting module.php as id, instead of module)
                    elseif ( strpos( $sPath, "."  ) ) {
                        if ( strpos( $sPath, strtolower( $sModuleClass ) ) === 0 ) {
                            unset( $aClassChain[$sKey] );
                        }
                    }
                }
            }
        }

        return $aClassChain;
    }

    protected function _disableModule( $sModule )
    {
        $oModule = oxNew("oxModule");
        $sModuleId = $oModule->getIdByPath($sModule);
        $oModule->deactivate($sModuleId);
    }

    protected function _makeSafeModuleClassParents( $aClassChain, $sBaseModule )
    {
        $sParent = $sBaseModule;
        $sClassName = $sBaseModule;

        //building middle classes if needed
        foreach ($aClassChain as $sModule) {
            //creating middle classes
            //e.g. class suboutput1_parent extends oxoutput {}
            //     class suboutput2_parent extends suboutput1 {}
            //$sModuleClass = $this->getClassName($sModule);

            //security: just preventing string termination
            $sModule = str_replace(chr(0), '', $sModule);

            //get parent and module class names from sub/suboutput2
            $sModuleClass = basename($sModule);

            if ( !class_exists( $sModuleClass, false ) ) {
                $sParentClass       = basename($sParent);
                $sModuleParentClass = $sModuleClass."_parent";

                //initializing middle class
                if (!class_exists($sModuleParentClass, false)) {
                    // If possible using alias instead if eval (since php 5.3).
                    if (function_exists('class_alias')) {
                        class_alias($sParentClass, $sModuleParentClass);
                    } else {
                        eval("abstract class $sModuleParentClass extends $sParentClass {}");
                    }
                }
                $sParentPath = oxRegistry::get( "oxConfigFile" )->getVar( "sShopDir" ) . "/modules/".$sModule.".php";

                //including original file
                if ( file_exists( $sParentPath ) ) {
                    include_once $sParentPath;
                } elseif ( !class_exists( $sModuleClass ) ) {
                    // special case is when oxconfig class is extended: we cant call "_disableModule" as it requires valid config object
                    // but we can't create it as module class extending it does not exist. So we will use orginal oxConfig object instead.
                    if ( $sParentClass == "oxconfig" ) {
                        $oConfig = $this->_getObject( "oxconfig", 0, null );
                        oxRegistry::set( "oxconfig", $oConfig );
                    }

                    // disable module if extended class is not found
                    $this->_disableModule( $sModule );

                    //to avoid problems with unitest and only throw a exception if class does not exists MAFI
                    $oEx = oxNew( "oxSystemComponentException" );
                    $oEx->setMessage('EXCEPTION_SYSTEMCOMPONENT_CLASSNOTFOUND');
                    $oEx->setComponent($sModuleClass);
                    continue;
                }
            }
            $sParent = $sModule;
            $sClassName = $sModule;
        }

        //returning the last module from the chain
        return $sClassName;
    }

    public function getShopId()
    {
            return 'oxbaseshop';
    }

    public function getModuleVar( $sModuleVarName )
    {
        //static cache
        if ( isset(self::$_aModuleVars[$sModuleVarName]) ) {
            return self::$_aModuleVars[$sModuleVarName];
        }

        //first try to get it from cache
        //we do not use any of our cache APIs, as we want to prevent any class dependencies here
        $aValue = $this->_getFromCache( $sModuleVarName );

        if ( is_null( $aValue ) ) {
            $aValue = $this->_getModuleVarFromDB($sModuleVarName);
            $this->_setToCache( $sModuleVarName, $aValue);
        }

        //static cache
        self::$_aModuleVars[$sModuleVarName] = $aValue;

        return $aValue;
    }

    public function setModuleVar( $sModuleVarName, $aValues )
    {
        if ( is_null( $aValues) ) {
            unset( self::$_aModuleVars );
        } else {
            self::$_aModuleVars[$sModuleVarName] = $aValues ;
        }

        $this->_setToCache($sModuleVarName, $aValues);
    }

    protected function _getConfKey()
    {
        $sFileName = dirname( __FILE__ ) . "/oxconfk.php";
        $sCfgFile = new oxConfigFile( $sFileName );
        return $sCfgFile->getVar("sConfigKey");
    }

    protected function _getShopUrlMap( )
    {

        //get from static cache
        if (isset( self::$_aModuleVars["urlMap"] )) {
            return self::$_aModuleVars["urlMap"];
        }

        //get from file cache
        $aMap = $this->_getFromCache("urlMap", false);
        if (!is_null($aMap)) {
            self::$_aModuleVars["urlMap"] = $aMap;
            return $aMap;
        }

        $aMap = array();

        $oDb = oxDb::getDb();
        $sConfKey = $this->_getConfKey();

        $sSelect = "SELECT oxshopid, oxvarname, DECODE( oxvarvalue , ".$oDb->quote($sConfKey)." ) as oxvarvalue ".
                   "FROM oxconfig WHERE oxvarname in ('aLanguageURLs','sMallShopURL','sMallSSLShopURL')";

        $oRs = $oDb->select($sSelect, false, false);

        if ( $oRs && $oRs->recordCount() > 0) {
            while ( !$oRs->EOF ) {
                $iShp = (int) $oRs->fields[0];
                $sVar = $oRs->fields[1];
                $sURL = $oRs->fields[2];

                if ($sVar == 'aLanguageURLs') {
                    $aUrls = unserialize($sURL);
                    if (is_array($aUrls) && count($aUrls)) {
                        $aUrls = array_filter($aUrls);
                        $aUrls = array_fill_keys($aUrls, $iShp);
                        $aMap  = array_merge($aMap, $aUrls);
                    }
                } elseif ($sURL) {
                    $aMap[$sURL] = $iShp;
                }

                $oRs->moveNext();
            }
        }

        //save to cache
        $this->_setToCache("urlMap", $aMap, false);
        self::$_aModuleVars["urlMap"] = $aMap;

        return $aMap;
    }

    protected function _getCacheDir()
    {
        $sDir = oxRegistry::get("oxConfigFile")->getVar("sCompileDir");
        return $sDir;
    }

    protected function _getCacheFileName($sModuleVarName, $sShopId = null)
    {
        if (is_null($sShopId)) {
            $sShopId = $this->getShopId();
        }

        $sDir = $this->_getCacheDir();
        $sVar  = strtolower( basename ($sModuleVarName) );
        $sShop = strtolower( basename ($sShopId) );

        $sFileName = $sDir . "/" . self::CACHE_FILE_PREFIX . "." . $sShop . '.' . $sVar . ".txt";

        return $sFileName;
    }

    protected function _getModuleVarFromDB( $sModuleVarName )
    {
        $oDb = oxDb::getDb();

        $sShopId  = $this->getShopId();
        $sConfKey = $this->_getConfKey();

        $sSelect = "SELECT DECODE( oxvarvalue , ".$oDb->quote($sConfKey)." ) FROM oxconfig ".
                   "WHERE oxvarname = ".$oDb->quote( $sModuleVarName )." AND oxshopid = ".$oDb->quote($sShopId);

        $sModuleVarName = $oDb->getOne($sSelect, false, false);

        $sModuleVarName = unserialize( $sModuleVarName );

        return $sModuleVarName;
    }

    protected function _getFromCache( $sModuleVarName, $blSubshopSpecific = true )
    {
        $sShopId = null;
        if ( !$blSubshopSpecific ) {
            $sShopId = "all";
        }

        $sFileName = $this->_getCacheFileName($sModuleVarName, $sShopId);
        $sValue = null;
        if ( is_readable( $sFileName ) ) {
            $sValue = file_get_contents( $sFileName );
            $sValue = unserialize( $sValue );
            if ( $sValue === false ) {
                $sValue = null;
            }
        }

        return $sValue ;
    }

    protected function _setToCache( $sVarName, $sValue,  $blSubshopSpecific = true )
    {
        $sShopId = null;
        if ( !$blSubshopSpecific ) {
            $sShopId = "all";
        }

        $sFileName = $this->_getCacheFileName($sVarName, $sShopId);
        file_put_contents( $sFileName, serialize($sValue), LOCK_EX );
    }

}