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

        return $aClassChain;
    }

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

        $oModuleCache = oxNew('oxModuleCache', $oModule);
        $oModuleInstaller = oxNew('oxModuleInstaller', $oModuleCache);

        $oModuleInstaller->deactivate($oModule);

    }

    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
                    $blDisableModuleOnError = !oxRegistry::get("oxConfigFile")->getVar("blDoNotDisableModuleOnError");
                    if ($blDisableModuleOnError) {
                        $this->_disableModule($sModule);
                    } else {
                        //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);
                        throw $oEx;
                    }
                    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)) {
            self::$_aModuleVars = null;
        } 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);
            if ($sValue == serialize(false)) {
                return false;
            }

            $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);
    }
}