oxi18n.php

Go to the documentation of this file.

<?php

class oxI18n extends oxBase
{

    protected $_sClassName = 'oxI18n';

    protected $_iLanguage = null;

    protected $_blEmployMultilanguage = true;

    public function __construct()
    {
        parent::__construct();

        // set default language
        //$this->setLanguage();

        //T2008-02-22
        //lets try to differentiate cache keys for oxI18n and oxBase
        //in order not to load cached structure for the instances of oxbase classe called on same table
        if ($this->_sCacheKey) {
            $this->_sCacheKey .= "_i18n";
        }
    }

    public function setLanguage( $iLang = null )
    {
        $this->_iLanguage = (int) $iLang;
    }

    public function getLanguage()
    {
        if ( $this->_iLanguage === null ) {
            $this->_iLanguage = oxLang::getInstance()->getBaseLanguage();
        }
        return $this->_iLanguage;
    }

    public function setEnableMultilang( $blEmployMultilanguage )
    {
        if ($this->_blEmployMultilanguage != $blEmployMultilanguage) {
            $this->_blEmployMultilanguage = $blEmployMultilanguage;
            if (!$blEmployMultilanguage) {
                //#63T
                $this->modifyCacheKey("_nonml");
            }
            if (count($this->_aFieldNames) > 1) {
                $this->_initDataStructure();
            }
        }
    }

    public function isMultilingualField($sFieldName)
    {
        if (isset($this->_aFieldNames[$sFieldName])) {
            return (bool) $this->_aFieldNames[$sFieldName];
        }

        //not inited field yet
        //and note that this is should be called only in first call after tmp dir is empty
        startProfile('!__CACHABLE2__!');
        $blIsMultilang = (bool) $this->_getFieldStatus($sFieldName);
        stopProfile('!__CACHABLE2__!');
        return (bool) $blIsMultilang;
    }

    public function isMultilang()
    {
        return true;
    }

    public function loadInLang( $iLanguage, $sOxid)
    {
        // set new lang to this object
        $this->setLanguage($iLanguage);
        return $this->load( $sOxid);
    }

    public function modifyCacheKey( $sCacheKey, $blOverride = false )
    {
        if ($blOverride) {
            $this->_sCacheKey = $sCacheKey."|i18n";
        } else {
            $this->_sCacheKey .= $sCacheKey;
        }

        if (!$sCacheKey) {
            $this->_sCacheKey = null;
        }
    }

    public function assign($dbRecord)
    {
        $oLang = oxLang::getInstance();
        $oLang->getBaseLanguage();
        $sLangTag = $oLang->getLanguageTag($this->getLanguage());
        if ($this->_blEmployMultilanguage && $sLangTag) {
            foreach ($dbRecord as $sField => $sVal) {
                //handling multilang
                if (isset($dbRecord[$sField . $sLangTag])) {
                    $dbRecord[$sField] = $dbRecord[$sField . $sLangTag];
                }
            }
        }

        return parent::assign($dbRecord);
    }

    public function getAvailableInLangs()
    {
        $aLanguages = oxLang::getInstance()->getLanguageNames();

        $aObjFields = $this->_getAllFields(true);
        $aMultiLangFields = array();

        //selecting all object multilang fields
        foreach ($aObjFields as $sKey => $sValue ) {

            //skipping oxactive field
            if ( preg_match('/^oxactive(_(\d{1,2}))?$/', $sKey) ) {
                continue;
            }

            $iFieldLang = $this->_getFieldLang( $sKey );

            //checking, if field is multilanguage
            if ( $this->isMultilingualField($sKey) || $iFieldLang >  0 ) {
                $sNewKey = preg_replace('/_(\d{1,2})$/', '', $sKey);
                $aMultiLangFields[$sNewKey][] = (int) $iFieldLang;
            }
        }

        // if no multilanguage fields, return default languages array
        if ( count($aMultiLangFields) < 1 ) {
            return $aLanguages;
        }

        $query = "select * from {$this->_sCoreTable} where oxid = '" . $this->getId() . "'";
        $rs = oxDb::getDb( true )->getAll($query);

        $aNotInLang = $aLanguages;

        // checks if object field data is not empty in all available languages
        // and formats not available in languages array
        if ( is_array($rs) && count($rs[0]) ) {
            foreach ( $aMultiLangFields as $sFieldId => $aMultiLangIds ) {

                foreach ( $aMultiLangIds as $sMultiLangId ) {
                    $sFieldName = ( $sMultiLangId == 0 ) ? $sFieldId : $sFieldId.'_'.$sMultiLangId;
                    if ( $rs['0'][strtoupper($sFieldName)] ) {
                        unset( $aNotInLang[$sMultiLangId] );
                        continue;
                    }
                }
            }
        }

        $aIsInLang = array_diff( $aLanguages, $aNotInLang );

        return $aIsInLang;
    }

    public function getSqlFieldName($sField)
    {
        $iLang = $this->getLanguage();
        if ($iLang && $this->_blEmployMultilanguage && $this->isMultilingualField($sField)) {
            $sField .= "_" . $iLang;
        }

        return $sField;
    }

    public function getSqlActiveSnippet( $blForceCoreTable = false )
    {
        $sQ = '';
            $sTable = $this->getCoreTableName();

        // has 'active' or 'active_x' field ?
        if ( $this->isMultilingualField( 'oxactive' ) ) {
            $sQ = " $sTable.oxactive".oxLang::getInstance()->getLanguageTag( $this->getLanguage() )." = 1 ";
        } elseif ( isset( $this->_aFieldNames['oxactive'] ) ) {
            $sQ = " $sTable.oxactive = 1 ";
        }

        // has 'activefrom'/'activeto' fields ?
        if ( isset( $this->_aFieldNames['oxactivefrom'] ) && isset( $this->_aFieldNames['oxactiveto'] ) ) {

            $sDate = date( 'Y-m-d H:i:s', oxUtilsDate::getInstance()->getTime() );

            $sQ = $sQ?" $sQ or ":'';
            $sQ = "( $sQ ( $sTable.oxactivefrom < '$sDate' and $sTable.oxactiveto > '$sDate' ) ) ";
        }

        return $sQ;
    }

    protected function _getFieldStatus($sFieldName)
    {
        $aAllField = $this->_getAllFields(true);
        if (isset($aAllField[$sFieldName."_1"])) {
            return 1;
        }
        return 0;
    }

    protected function _getNonCachedFieldNames($blForceFullStructure = false)
    {
        //Tomas
        //TODO: clean this
        $aFields = parent::_getNonCachedFieldNames($blForceFullStructure);

        if (!$this->_blEmployMultilanguage) {
            return $aFields;
        }

        //lets do some pointer manipulation
        if ($aFields) {
            //non admin fields
            $aWorkingFields = &$aFields;
        } else {
            //most likely admin fields so we remove another language
            $aWorkingFields = &$this->_aFieldNames;
        }

        //we have an array of fields, lets remove multilanguage fields
        foreach ($aWorkingFields as $sName => $sVal) {
            if ($this->_getFieldLang($sName)) {
                unset($aWorkingFields[$sName]);
            } else {
                $aWorkingFields[$sName] = $this->_getFieldStatus($sName);
            }
        }

        return $aWorkingFields;
    }

    protected function _getFieldLang($sFieldName)
    {
        startProfile('_getFieldLang');
        $oStr = getStr();
        if ( !$oStr->strstr($sFieldName, '_')) {
            return 0;
        }
        if (preg_match('/_(\d{1,2})$/', $sFieldName, $aRegs)) {
            $sRes = $aRegs[1];
        } else {
            $sRes = 0;
        }

        stopProfile('_getFieldLang');
        return $sRes;
    }

    protected function _update()
    {
        $blRet = parent::_update();

        // currently only multilanguage objects are SEO
        // if current object is managed by SEO and SEO is ON
        if ( $blRet && $this->_blIsSeoObject && $this->isAdmin() ) {
            // marks all object db entries as expired
            oxSeoEncoder::getInstance()->markAsExpired( $this->getId() );
        }

        return $blRet;
    }

    /*
    protected function _addField($sName, $sStatus, $sType = null, $sLength = null)
    {
        if ($this->_blEmployMultilanguage && $this->_getFieldLang($sName))
            return;

        return parent::_addField($sName, $sStatus, $sType, $sLength);
    }*/
}

---