oxutils.php

Go to the documentation of this file.

<?php

require_once getShopBasePath() . "core/smarty/Smarty.class.php";

class oxUtils extends oxSuperCfg
{

    protected $_iCurPrecision = null;

    protected $_sPermanentCachePattern = "/c_fieldnames_|c_tbdsc_|_allfields_/";

    protected $_sLanguageCachePattern = "/c_langcache_/i";

    protected $_sMenuCachePattern = "/c_menu_/i";

    protected $_aLockedFileHandles = array();

    protected $_aFileCacheContents = array();

    protected $_blIsSe = null;

    protected $_aStaticCache;

    protected $_blSeoIsActive = null;

    public function strMan($sVal, $sKey = null)
    {
        $oEncryptor = oxNew('oxEncryptor');
        $sKey = $sKey ? $sKey : $this->getConfig()->getConfigParam('sConfigKey');

        return $oEncryptor->encrypt($sVal, $sKey);
    }

    public function strRem($sVal, $sKey = null)
    {
        $oDecryptor = oxNew('oxDecryptor');
        $sKey = $sKey ? $sKey : $this->getConfig()->getConfigParam('sConfigKey');

        return $oDecryptor->decrypt($sVal, $sKey);
    }

    public function getArrFldName($sName)
    {
        return str_replace(".", "__", $sName);
    }

    public function assignValuesFromText($sIn, $dVat = null)
    {
        $aRet = array();
        $aPieces = explode('@@', $sIn);
        while (list($sKey, $sVal) = each($aPieces)) {
            if ($sVal) {
                $aName = explode('__', $sVal);
                if (isset($aName[0]) && isset($aName[1])) {
                    $aRet[] = $this->_fillExplodeArray($aName, $dVat);
                }
            }
        }

        return $aRet;
    }

    public function assignValuesToText($aIn)
    {
        $sRet = "";
        reset($aIn);
        while (list($sKey, $sVal) = each($aIn)) {
            $sRet .= $sKey;
            $sRet .= "__";
            $sRet .= $sVal;
            $sRet .= "@@";
        }

        return $sRet;
    }

    public function currency2Float($sValue)
    {
        $fRet = $sValue;
        $iPos = strrpos($sValue, ".");
        if ($iPos && ((strlen($sValue) - 1 - $iPos) < 2 + 1)) {
            // replace decimal with ","
            $fRet = substr_replace($fRet, ",", $iPos, 1);
        }
        // remove thousands
        $fRet = str_replace(array(" ", "."), "", $fRet);

        $fRet = str_replace(",", ".", $fRet);

        return (float) $fRet;
    }

    public function string2Float($sValue)
    {
        $fRet = str_replace(" ", "", $sValue);
        $iCommaPos = strpos($fRet, ",");
        $iDotPos = strpos($fRet, ".");
        if (!$iDotPos xor !$iCommaPos) {
            if (substr_count($fRet, ",") > 1 || substr_count($fRet, ".") > 1) {
                $fRet = str_replace(array(",", "."), "", $fRet);
            } else {
                $fRet = str_replace(",", ".", $fRet);
            }
        } else {
            if ($iDotPos < $iCommaPos) {
                $fRet = str_replace(".", "", $fRet);
                $fRet = str_replace(",", ".", $fRet);
            }
        }
        // remove thousands
        $fRet = str_replace(array(" ", ","), "", $fRet);

        return (float) $fRet;
    }

    public function isSearchEngine($sClient = null)
    {
        if (is_null($this->_blIsSe)) {
            $this->setSearchEngine(null, $sClient);
        }

        return $this->_blIsSe;
    }

    public function setSearchEngine($blIsSe = null, $sClient = null)
    {
        if (isset($blIsSe)) {
            $this->_blIsSe = $blIsSe;

            return;
        }
        startProfile("isSearchEngine");

        $myConfig = $this->getConfig();
        $blIsSe = false;

        if (!($myConfig->getConfigParam('iDebug') && $this->isAdmin())) {
            $aRobots = $myConfig->getConfigParam('aRobots');
            $aRobots = is_array($aRobots) ? $aRobots : array();

            $aRobotsExcept = $myConfig->getConfigParam('aRobotsExcept');
            $aRobotsExcept = is_array($aRobotsExcept) ? $aRobotsExcept : array();

            $sClient = $sClient ? $sClient : strtolower(getenv('HTTP_USER_AGENT'));
            $blIsSe = false;
            $aRobots = array_merge($aRobots, $aRobotsExcept);
            foreach ($aRobots as $sRobot) {
                if (strpos($sClient, $sRobot) !== false) {
                    $blIsSe = true;
                    break;
                }
            }
        }

        $this->_blIsSe = $blIsSe;

        stopProfile("isSearchEngine");
    }

    public function isValidEmail($sEmail)
    {
        $oMailValidator = oxNew('oxMailValidator');

        return $oMailValidator->isValidEmail($sEmail);
    }

    public function loadAdminProfile($aInterfaceProfiles)
    {
        // improved #533
        // checking for available profiles list
        if (is_array($aInterfaceProfiles)) {
            //checking for previous profiles
            $sPrevProfile = oxRegistry::get("oxUtilsServer")->getOxCookie('oxidadminprofile');
            if (isset($sPrevProfile)) {
                $aPrevProfile = @explode("@", trim($sPrevProfile));
            }

            //array to store profiles
            $aProfiles = array();
            foreach ($aInterfaceProfiles as $iPos => $sProfile) {
                $aProfileSettings = array($iPos, $sProfile);
                $aProfiles[] = $aProfileSettings;
            }
            // setting previous used profile as active
            if (isset($aPrevProfile[0]) && isset($aProfiles[$aPrevProfile[0]])) {
                $aProfiles[$aPrevProfile[0]][2] = 1;
            }

            oxRegistry::getSession()->setVariable("aAdminProfiles", $aProfiles);

            return $aProfiles;
        }

        return null;
    }

    public function fRound($sVal, $oCur = null)
    {
        startProfile('fround');

        //cached currency precision, this saves about 1% of execution time
        $iCurPrecision = null;
        if (!defined('OXID_PHP_UNIT')) {
            $iCurPrecision = $this->_iCurPrecision;
        }

        if (is_null($iCurPrecision)) {
            if (!$oCur) {
                $oCur = $this->getConfig()->getActShopCurrencyObject();
            }

            $iCurPrecision = $oCur->decimal;
            $this->_iCurPrecision = $iCurPrecision;
        }

        // if < 5.3.x this is a workaround for #36008 bug in php - incorrect round() & number_format() result (R)
        static $dprez = null;
        if (!$dprez) {
            $prez = @ini_get("precision");
            if (!$prez || $prez > 12) {
                $prez = 12;
            }
            $dprez = pow(10, -$prez);
        }
        stopProfile('fround');

        return round($sVal + $dprez * ($sVal >= 0 ? 1 : -1), $iCurPrecision);
    }

    public function toStaticCache($sName, $sContent, $sKey = null)
    {
        // if it's an array then we add
        if ($sKey) {
            $this->_aStaticCache[$sName][$sKey] = $sContent;
        } else {
            $this->_aStaticCache[$sName] = $sContent;
        }
    }

    public function fromStaticCache($sName)
    {
        if (isset($this->_aStaticCache[$sName])) {
            return $this->_aStaticCache[$sName];
        }

        return null;
    }

    public function cleanStaticCache($sCacheName = null)
    {
        if ($sCacheName) {
            unset($this->_aStaticCache[$sCacheName]);
        } else {
            $this->_aStaticCache = null;
        }
    }

    public function toPhpFileCache($sKey, $mContents)
    {
        //only simple arrays are supported
        if (is_array($mContents) && ($sCachePath = $this->getCacheFilePath($sKey, false, 'php'))) {

            // setting meta
            $this->setCacheMeta($sKey, array("serialize" => false, "cachepath" => $sCachePath));

            // caching..
            $this->toFileCache($sKey, $mContents);
        }
    }

    public function fromPhpFileCache($sKey)
    {
        // setting meta
        $this->setCacheMeta($sKey, array("include" => true, "cachepath" => $this->getCacheFilePath($sKey, false, 'php')));

        return $this->fromFileCache($sKey);
    }

    public function getCacheMeta($sKey)
    {
        return isset($this->_aFileCacheMeta[$sKey]) ? $this->_aFileCacheMeta[$sKey] : false;
    }

    public function setCacheMeta($sKey, $aMeta)
    {
        // cache meta data
        $this->_aFileCacheMeta[$sKey] = $aMeta;
    }

    public function toFileCache($sKey, $mContents, $iTtl = 0)
    {
        $aCacheData['content'] = $mContents;
        $aMeta = $this->getCacheMeta($sKey);
        if ($iTtl) {
            $aCacheData['ttl'] = $iTtl;
            $aCacheData['timestamp'] = oxRegistry::get("oxUtilsDate")->getTime();
        }
        $this->_aFileCacheContents[$sKey] = $aCacheData;

        // looking for cache meta
        $sCachePath = isset($aMeta["cachepath"]) ? $aMeta["cachepath"] : $this->getCacheFilePath($sKey);

        return ( bool ) $this->_lockFile($sCachePath, $sKey);
    }

    public function fromFileCache($sKey)
    {
        if (!array_key_exists($sKey, $this->_aFileCacheContents)) {
            $sRes = null;

            $aMeta = $this->getCacheMeta($sKey);
            $blInclude = isset($aMeta["include"]) ? $aMeta["include"] : false;
            $sCachePath = isset($aMeta["cachepath"]) ? $aMeta["cachepath"] : $this->getCacheFilePath($sKey);

            // trying to lock
            $this->_lockFile($sCachePath, $sKey, LOCK_SH);

            clearstatcache();
            if (is_readable($sCachePath)) {
                $sRes = $blInclude ? $this->_includeFile($sCachePath) : $this->_readFile($sCachePath);
            }

            if (isset($sRes['ttl']) && $sRes['ttl'] != 0) {
                $iTimestamp = $sRes['timestamp'];
                $iTtl = $sRes['ttl'];

                $iTime = oxRegistry::get("oxUtilsDate")->getTime();
                if ($iTime > $iTimestamp + $iTtl) {
                    return null;
                }
            }
            // release lock
            $this->_releaseFile($sKey, LOCK_SH);

            // caching
            $this->_aFileCacheContents[$sKey] = $sRes;
        }

        return $this->_aFileCacheContents[$sKey]['content'];
    }

    protected function _readFile($sFilePath)
    {
        $sRes = file_get_contents($sFilePath);

        return $sRes ? unserialize($sRes) : null;
    }

    protected function _includeFile($sFilePath)
    {
        $_aCacheContents = null;
        include $sFilePath;

        return $_aCacheContents;
    }

    protected function _processCache($sKey, $mContents)
    {
        // looking for cache meta
        $aCacheMeta = $this->getCacheMeta($sKey);
        $blSerialize = isset($aCacheMeta["serialize"]) ? $aCacheMeta["serialize"] : true;

        if ($blSerialize) {
            $mContents = serialize($mContents);
        } else {
            $mContents = "<?php\n//automatically generated file\n//" . date("Y-m-d H:i:s") . "\n\n\$_aCacheContents = " . var_export($mContents, true) . "\n?>";
        }

        return $mContents;
    }

    public function commitFileCache()
    {
        if (!empty($this->_aLockedFileHandles[LOCK_EX])) {
            startProfile("!__SAVING CACHE__! (warning)");
            foreach ($this->_aLockedFileHandles[LOCK_EX] as $sKey => $rHandle) {
                if ($rHandle !== false && isset($this->_aFileCacheContents[$sKey])) {

                    // #0002931A truncate file once more before writing
                    ftruncate($rHandle, 0);

                    // writing cache
                    fwrite($rHandle, $this->_processCache($sKey, $this->_aFileCacheContents[$sKey]));

                    // releasing locks
                    $this->_releaseFile($sKey);
                }
            }

            stopProfile("!__SAVING CACHE__! (warning)");

            //empty buffer
            $this->_aFileCacheContents = array();
        }
    }

    protected function _lockFile($sFilePath, $sIdent, $iLockMode = LOCK_EX)
    {
        $rHandle = isset($this->_aLockedFileHandles[$iLockMode][$sIdent]) ? $this->_aLockedFileHandles[$iLockMode][$sIdent] : null;
        if ($rHandle === null) {

            $blLocked = false;
            $rHandle = @fopen($sFilePath, "a+");

            if ($rHandle !== false) {

                if (flock($rHandle, $iLockMode | LOCK_NB)) {
                    if ($iLockMode === LOCK_EX) {
                        // truncate file
                        $blLocked = ftruncate($rHandle, 0);
                    } else {
                        // move to a start position
                        $blLocked = fseek($rHandle, 0) === 0;
                    }
                }

                // on failure - closing and setting false..
                if (!$blLocked) {
                    fclose($rHandle);
                    $rHandle = false;
                }
            }

            // in case system does not support file locking
            if (!$blLocked && $iLockMode === LOCK_EX) {

                // clearing on first call
                if (count($this->_aLockedFileHandles) == 0) {
                    clearstatcache();
                }

                // start a blank file to inform other processes we are dealing with it.
                if (!(file_exists($sFilePath) && !filesize($sFilePath) && abs(time() - filectime($sFilePath) < 40))) {
                    $rHandle = @fopen($sFilePath, "w");
                }
            }

            $this->_aLockedFileHandles[$iLockMode][$sIdent] = $rHandle;
        }

        return $rHandle;
    }

    protected function _releaseFile($sIdent, $iLockMode = LOCK_EX)
    {
        $blSuccess = true;
        if (isset($this->_aLockedFileHandles[$iLockMode][$sIdent]) &&
            $this->_aLockedFileHandles[$iLockMode][$sIdent] !== false
        ) {

            // release the lock and close file
            $blSuccess = flock($this->_aLockedFileHandles[$iLockMode][$sIdent], LOCK_UN) &&
                         fclose($this->_aLockedFileHandles[$iLockMode][$sIdent]);
            unset($this->_aLockedFileHandles[$iLockMode][$sIdent]);
        }

        return $blSuccess;
    }

    public function oxResetFileCache()
    {
        $aFiles = glob($this->getCacheFilePath(null, true) . '*');
        if (is_array($aFiles)) {
            // delete all the files, except cached tables field names
            $aFiles = preg_grep($this->_sPermanentCachePattern, $aFiles, PREG_GREP_INVERT);
            foreach ($aFiles as $sFile) {
                @unlink($sFile);
            }
        }
    }

    public function resetTemplateCache($aTemplates)
    {
        $sSmartyDir = oxRegistry::get("oxUtilsView")->getSmartyDir();
        //$aFiles = glob( $this->getCacheFilePath( null, true ) . '*' );
        $aFiles = glob($sSmartyDir . '*');

        if (is_array($aFiles) && is_array($aTemplates) && count($aTemplates)) {
            // delete all template cache files
            foreach ($aTemplates as &$sTemplate) {
                $sTemplate = preg_quote(basename(strtolower($sTemplate), '.tpl'));
            }

            $sPattern = sprintf("/%%(%s)\.tpl\.php$/i", implode('|', $aTemplates));
            $aFiles = preg_grep($sPattern, $aFiles);

            if (is_array($aFiles)) {
                foreach ($aFiles as $sFile) {
                    @unlink($sFile);
                }
            }
        }

    }

    public function resetLanguageCache()
    {
        $aFiles = glob($this->getCacheFilePath(null, true) . '*');
        if (is_array($aFiles)) {
            // delete all language cache files
            $sPattern = $this->_sLanguageCachePattern;
            $aFiles = preg_grep($sPattern, $aFiles);
            foreach ($aFiles as $sFile) {
                @unlink($sFile);
            }
        }
    }

    public function resetMenuCache()
    {
        $aFiles = glob($this->getCacheFilePath(null, true) . '*');
        if (is_array($aFiles)) {
            // delete all menu cache files
            $sPattern = $this->_sMenuCachePattern;
            $aFiles = preg_grep($sPattern, $aFiles);
            foreach ($aFiles as $sFile) {
                @unlink($sFile);
            }
        }
    }

    public function getRemoteCachePath($sRemote, $sLocal)
    {
        clearstatcache();
        if (file_exists($sLocal) && filemtime($sLocal) && filemtime($sLocal) > time() - 86400) {
            return $sLocal;
        }
        $hRemote = @fopen($sRemote, "rb");
        $blSuccess = false;
        if (isset($hRemote) && $hRemote) {
            $hLocal = fopen($sLocal, "wb");
            stream_copy_to_stream($hRemote, $hLocal);
            fclose($hRemote);
            fclose($hLocal);
            $blSuccess = true;
        } else {
            // try via fsockopen
            $aUrl = @parse_url($sRemote);
            if (!empty($aUrl["host"])) {
                $sPath = $aUrl["path"];
                if (empty($sPath)) {
                    $sPath = "/";
                }
                $sHost = $aUrl["host"];

                $hSocket = @fsockopen($sHost, 80, $iErrorNumber, $iErrStr, 5);
                if ($hSocket) {
                    fputs($hSocket, "GET " . $sPath . " HTTP/1.0\r\nHost: $sHost\r\n\r\n");
                    $headers = stream_get_line($hSocket, 4096, "\r\n\r\n");
                    if (($hLocal = @fopen($sLocal, "wb")) !== false) {
                        rewind($hLocal);
                        // does not copy all the data
                        // stream_copy_to_stream($hSocket, $hLocal);
                        fwrite($hLocal, stream_get_contents($hSocket));
                        fclose($hLocal);
                        fclose($hSocket);
                        $blSuccess = true;
                    }
                }
            }
        }
        if ($blSuccess || file_exists($sLocal)) {
            return $sLocal;
        }

        return false;
    }

    public function canPreview()
    {
        $blCan = null;
        if (($sPrevId = oxRegistry::getConfig()->getRequestParameter('preview')) &&
            ($sAdminSid = oxRegistry::get("oxUtilsServer")->getOxCookie('admin_sid'))
        ) {

            $sTable = getViewName('oxuser');
            $oDb = oxDb::getDb();
            $sQ = "select 1 from $sTable where MD5( CONCAT( " . $oDb->quote($sAdminSid) . ", {$sTable}.oxid, {$sTable}.oxpassword, {$sTable}.oxrights ) ) = " . oxDb::getDb()->quote($sPrevId);
            $blCan = (bool) $oDb->getOne($sQ);
        }

        return $blCan;
    }

    public function getPreviewId()
    {
        $sAdminSid = oxRegistry::get("oxUtilsServer")->getOxCookie('admin_sid');
        if (($oUser = $this->getUser())) {
            return md5($sAdminSid . $oUser->getId() . $oUser->oxuser__oxpassword->value . $oUser->oxuser__oxrights->value);
        }
    }

    public function checkAccessRights()
    {
        $myConfig = $this->getConfig();

        $blIsAuth = false;

        $sUserID = oxRegistry::getSession()->getVariable("auth");

        // deleting admin marker
        oxRegistry::getSession()->setVariable("malladmin", 0);
        oxRegistry::getSession()->setVariable("blIsAdmin", 0);
        oxRegistry::getSession()->deleteVariable("blIsAdmin");
        $myConfig->setConfigParam('blMallAdmin', false);
        //#1552T
        $myConfig->setConfigParam('blAllowInheritedEdit', false);

        if ($sUserID) {
            // escaping
            $oDb = oxDb::getDb();
            $sRights = $oDb->getOne("select oxrights from oxuser where oxid = " . $oDb->quote($sUserID));

            if ($sRights != "user") {
                // malladmin ?
                if ($sRights == "malladmin") {
                    oxRegistry::getSession()->setVariable("malladmin", 1);
                    $myConfig->setConfigParam('blMallAdmin', true);

                    //#1552T
                    //So far this blAllowSharedEdit is Equal to blMallAdmin but in future to be solved over rights and roles
                    $myConfig->setConfigParam('blAllowSharedEdit', true);

                    $sShop = oxRegistry::getSession()->getVariable("actshop");
                    if (!isset($sShop)) {
                        oxRegistry::getSession()->setVariable("actshop", $myConfig->getBaseShopId());
                    }
                    $blIsAuth = true;
                } else {
                    // Shopadmin... check if this shop is valid and exists
                    $sShopID = $oDb->getOne("select oxid from oxshops where oxid = " . $oDb->quote($sRights));
                    if (isset($sShopID) && $sShopID) {
                        // success, this shop exists

                        oxRegistry::getSession()->setVariable("actshop", $sRights);
                        oxRegistry::getSession()->setVariable("currentadminshop", $sRights);
                        oxRegistry::getSession()->setVariable("shp", $sRights);

                        // check if this subshop admin is evil.
                        if ('chshp' == oxRegistry::getConfig()->getRequestParameter('fnc')) {
                            // dont allow this call
                            $blIsAuth = false;
                        } else {
                            $blIsAuth = true;

                            $aShopIdVars = array('actshop', 'shp', 'currentadminshop');
                            foreach ($aShopIdVars as $sShopIdVar) {
                                if ($sGotShop = oxRegistry::getConfig()->getRequestParameter($sShopIdVar)) {
                                    if ($sGotShop != $sRights) {
                                        $blIsAuth = false;
                                        break;
                                    }
                                }
                            }
                        }
                    }
                }
                // marking user as admin
                oxRegistry::getSession()->setVariable("blIsAdmin", 1);
            }
        }

        return $blIsAuth;
    }

    public function seoIsActive($blReset = false, $sShopId = null, $iActLang = null)
    {
        if (!is_null($this->_blSeoIsActive) && !$blReset) {
            return $this->_blSeoIsActive;
        }

        $myConfig = $this->getConfig();

        if (($this->_blSeoIsActive = $myConfig->getConfigParam('blSeoMode')) === null) {
            $this->_blSeoIsActive = true;

            $aSeoModes = $myConfig->getconfigParam('aSeoModes');
            $sActShopId = $sShopId ? $sShopId : $myConfig->getActiveShop()->getId();
            $iActLang = $iActLang ? $iActLang : (int) oxRegistry::getLang()->getBaseLanguage();

            // checking special config param for active shop and language
            if (is_array($aSeoModes) && isset($aSeoModes[$sActShopId]) && isset($aSeoModes[$sActShopId][$iActLang])) {
                $this->_blSeoIsActive = (bool) $aSeoModes[$sActShopId][$iActLang];
            }
        }

        return $this->_blSeoIsActive;
    }

    public function isValidAlpha($sField)
    {
        return (boolean) getStr()->preg_match('/^[a-zA-Z0-9_]*$/', $sField);
    }

    protected function _simpleRedirect($sUrl, $sHeaderCode)
    {
        $oHeader = oxNew("oxHeader");
        $oHeader->setHeader($sHeaderCode);
        $oHeader->setHeader("Location: $sUrl");
        $oHeader->setHeader("Connection: close");
        $oHeader->sendHeader();
    }

    public function redirectOffline($iHeaderCode = 302)
    {
        $sUrl = $this->getConfig()->getShopUrl() . 'offline.html';
        $this->redirect($sUrl, false, $iHeaderCode);
    }

    public function redirect($sUrl, $blAddRedirectParam = true, $iHeaderCode = 302)
    {
        //preventing possible cyclic redirection
        //#M341 and check only if redirect parameter must be added
        if ($blAddRedirectParam && oxRegistry::getConfig()->getRequestParameter('redirected')) {
            return;
        }

        if ($blAddRedirectParam) {
            $sUrl = $this->_addUrlParameters($sUrl, array('redirected' => 1));
        }

        $sUrl = str_ireplace("&amp;", "&", $sUrl);

        switch ($iHeaderCode) {
            case 301:
                $sHeaderCode = "HTTP/1.1 301 Moved Permanently";
                break;
            case 500:
                $sHeaderCode = "HTTP/1.1 500 Internal Server Error";
                break;
            case 302:
            default:
                $sHeaderCode = "HTTP/1.1 302 Found";
        }

        $this->_simpleRedirect($sUrl, $sHeaderCode);

        try { //may occur in case db is lost
            $this->getSession()->freeze();
        } catch (oxException $oEx) {
            $oEx->debugOut();
            //do nothing else to make sure the redirect takes place
        }

        if (defined('OXID_PHP_UNIT')) {
            return;
        }

        $this->showMessageAndExit('');
    }

    public function showMessageAndExit($sMsg)
    {
        $this->getSession()->freeze();
        $this->commitFileCache();

        if (defined('OXID_PHP_UNIT')) {
            return;
        }


        exit($sMsg);
    }

    public function setHeader($sHeader)
    {
        header($sHeader);
    }

    protected function _addUrlParameters($sUrl, $aParams)
    {
        $sDelimiter = ((getStr()->strpos($sUrl, '?') !== false)) ? '&' : '?';
        foreach ($aParams as $sName => $sVal) {
            $sUrl = $sUrl . $sDelimiter . $sName . '=' . $sVal;
            $sDelimiter = '&';
        }

        return $sUrl;
    }

    protected function _fillExplodeArray($aName, $dVat = null)
    {
        $myConfig = $this->getConfig();
        $oObject = new stdClass();
        $aPrice = explode('!P!', $aName[0]);

        if (($myConfig->getConfigParam('bl_perfLoadSelectLists') && $myConfig->getConfigParam('bl_perfUseSelectlistPrice') && isset($aPrice[0]) && isset($aPrice[1])) || $this->isAdmin()) {

            // yes, price is there
            $oObject->price = isset($aPrice[1]) ? $aPrice[1] : 0;
            $aName[0] = isset($aPrice[0]) ? $aPrice[0] : '';

            $iPercPos = getStr()->strpos($oObject->price, '%');
            if ($iPercPos !== false) {
                $oObject->priceUnit = '%';
                $oObject->fprice = $oObject->price;
                $oObject->price = substr($oObject->price, 0, $iPercPos);
            } else {
                $oCur = $myConfig->getActShopCurrencyObject();
                $oObject->price = str_replace(',', '.', $oObject->price);
                $oObject->fprice = oxRegistry::getLang()->formatCurrency($oObject->price * $oCur->rate, $oCur);
                $oObject->priceUnit = 'abs';
            }

            // add price info into list
            if (!$this->isAdmin() && $oObject->price != 0) {
                $aName[0] .= " ";

                $dPrice = $this->_preparePrice($oObject->price, $dVat);

                if ($oObject->price > 0) {
                    $aName[0] .= "+";
                }
                //V FS#2616
                if ($dVat != null && $oObject->priceUnit == 'abs') {
                    $oPrice = oxNew('oxPrice');
                    $oPrice->setPrice($oObject->price, $dVat);
                    $aName[0] .= oxRegistry::getLang()->formatCurrency($dPrice * $oCur->rate, $oCur);
                } else {
                    $aName[0] .= $oObject->fprice;
                }
                if ($oObject->priceUnit == 'abs') {
                    $aName[0] .= " " . $oCur->sign;
                }
            }
        } elseif (isset($aPrice[0]) && isset($aPrice[1])) {
            // A. removing unused part of information
            $aName[0] = getStr()->preg_replace("/!P!.*/", "", $aName[0]);
        }

        $oObject->name = $aName[0];
        $oObject->value = $aName[1];

        return $oObject;
    }

    protected function _preparePrice($dPrice, $dVat)
    {
        $blCalculationModeNetto = $this->_isPriceViewModeNetto();

        $oCurrency = $this->getConfig()->getActShopCurrencyObject();

        $blEnterNetPrice = $this->getConfig()->getConfigParam('blEnterNetPrice');
        if ($blCalculationModeNetto && !$blEnterNetPrice) {
            $dPrice = round(oxPrice::brutto2Netto($dPrice, $dVat), $oCurrency->decimal);
        } elseif (!$blCalculationModeNetto && $blEnterNetPrice) {
            $dPrice = round(oxPrice::netto2Brutto($dPrice, $dVat), $oCurrency->decimal);
        }

        return $dPrice;
    }

    protected function _isPriceViewModeNetto()
    {
        $blResult = (bool) $this->getConfig()->getConfigParam('blShowNetPrice');
        $oUser = $this->_getArticleUser();
        if ($oUser) {
            $blResult = $oUser->isPriceViewModeNetto();
        }

        return $blResult;
    }

    protected function _getArticleUser()
    {
        if ($this->_oUser) {
            return $this->_oUser;
        }

        return $this->getUser();
    }

    public function oxMimeContentType($sFileName)
    {
        $sFileName = strtolower($sFileName);
        $iLastDot = strrpos($sFileName, '.');

        if ($iLastDot !== false) {
            $sType = substr($sFileName, $iLastDot + 1);
            switch ($sType) {
                case 'gif':
                    $sType = 'image/gif';
                    break;
                case 'jpeg':
                case 'jpg':
                    $sType = 'image/jpeg';
                    break;
                case 'png':
                    $sType = 'image/png';
                    break;
                default:
                    $sType = false;
                    break;
            }
        }

        return $sType;
    }

    public function logger($sText, $blNewline = false)
    {
        $myConfig = $this->getConfig();

        if ($myConfig->getConfigParam('iDebug') == -2) {
            if (gettype($sText) != 'string') {
                $sText = var_export($sText, true);
            }
            $sLogMsg = "----------------------------------------------\n{$sText}" . (($blNewline) ? "\n" : "") . "\n";
            $this->writeToLog($sLogMsg, "log.txt");
        }

    }

    public function strRot13($sStr)
    {
        $sFrom = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
        $sTo = 'nopqrstuvwxyzabcdefghijklmNOPQRSTUVWXYZABCDEFGHIJKLM';

        return strtr($sStr, $sFrom, $sTo);
    }

    public function getCacheFilePath($sCacheName, $blPathOnly = false, $sExtension = 'txt')
    {

        $sVersionPrefix = 'pe';

        $sPath = realpath($this->getConfig()->getConfigParam('sCompileDir'));

        if (!$sPath) {
            return false;
        }

        return $blPathOnly ? "{$sPath}/" : "{$sPath}/ox{$sVersionPrefix}c_{$sCacheName}." . $sExtension;
    }

    public function getLangCache($sCacheName)
    {
        $aLangCache = null;
        $sFilePath = $this->getCacheFilePath($sCacheName);
        if (file_exists($sFilePath) && is_readable($sFilePath)) {
            include $sFilePath;
        }

        return $aLangCache;
    }

    public function setLangCache($sCacheName, $aLangCache)
    {
        $sCache = "<?php\n\$aLangCache = " . var_export($aLangCache, true) . ";\n?>";
        $blRes = file_put_contents($this->getCacheFilePath($sCacheName), $sCache, LOCK_EX);

        return $blRes;
    }

    public function checkUrlEndingSlash($sUrl)
    {
        if (!getStr()->preg_match("/\/$/", $sUrl)) {
            $sUrl .= '/';
        }

        return $sUrl;
    }

    public function writeToLog($sLogMessage, $sLogFileName)
    {
        $sLogDist = $this->getConfig()->getLogsDir() . $sLogFileName;
        $blOk = false;

        if (($oHandle = fopen($sLogDist, 'a')) !== false) {
            fwrite($oHandle, $sLogMessage);
            $blOk = fclose($oHandle);
        }

        return $blOk;
    }

    public function handlePageNotFoundError($sUrl = '')
    {
        $this->setHeader("HTTP/1.0 404 Not Found");
        if (oxRegistry::getConfig()->isUtf()) {
            $this->setHeader("Content-Type: text/html; charset=UTF-8");
        }

        $sReturn = "Page not found.";
        try {
            $oView = oxNew('oxUBase');
            $oView->init();
            $oView->render();
            $oView->setClassName('oxUBase');
            $oView->addTplParam('sUrl', $sUrl);
            if ($sRet = oxRegistry::get("oxUtilsView")->getTemplateOutput('message/err_404.tpl', $oView)) {
                $sReturn = $sRet;
            }
        } catch (Exception $e) {
        }
        $this->showMessageAndExit($sReturn);
    }

    public function extractDomain($sHost)
    {
        $oStr = getStr();
        if (!$oStr->preg_match('/[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}/', $sHost) &&
            ($iLastDot = strrpos($sHost, '.')) !== false
        ) {
            $iLen = $oStr->strlen($sHost);
            if (($iNextDot = strrpos($sHost, '.', ($iLen - $iLastDot + 1) * -1)) !== false) {
                $sHost = trim($oStr->substr($sHost, $iNextDot), '.');
            }
        }

        return $sHost;
    }
}