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();

        //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;
        // reset
        $this->_sViewTable = false;
    }

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

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

    public function isMultilingualField( $sFieldName )
    {
        $sFieldName = strtolower( $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);
        // reset
        $this->_sViewTable = false;
        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 getAvailableInLangs()
    {
        $aLanguages = oxRegistry::getLang()->getLanguageNames();

        $aObjFields = $this->_getTableFields(
            getViewName($this->_sCoreTable, -1, -1),
            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;
        }

        // select from non-multilanguage core view (all ml tables joined to one)
        $oDb = oxDb::getDb( oxDb::FETCH_MODE_ASSOC );
        $query = "select * from ".getViewName($this->_sCoreTable, -1, -1)." where oxid = " . $oDb->quote( $this->getId() );
        $rs = $oDb->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;
    }

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

    protected function _getNonCachedFieldNames($blForceFullStructure = false)
    {
        //Tomas
        //TODO: this place could be optimized. please check what we can do.
        $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)
    {
        if ( false === strpos($sFieldName, '_')) {
            return 0;
        }
        if (preg_match('/_(\d{1,2})$/', $sFieldName, $aRegs)) {
            return $aRegs[1];
        } else {
            return 0;
        }
    }

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

        return $sField;
    }

    protected function _getUpdateFieldsForTable( $sTable, $blUseSkipSaveFields = true )
    {
        $sCoreTable = $this->getCoreTableName();

        $blSkipMultilingual = false;
        $blSkipCoreFields = false;

        if ($sTable != $sCoreTable ) {
            $blSkipCoreFields = true;
        }
        if ($this->_blEmployMultilanguage) {
            if ( $sTable != getLangTableName($sCoreTable, $this->getLanguage() ) ) {
                $blSkipMultilingual = true;
            }
        }

        $sSql = '';
        $blSep  = false;
        foreach (array_keys($this->_aFieldNames) as $sKey) {
            $sKeyLowercase = strtolower($sKey);
            if ($sKeyLowercase != 'oxid') {
                if ($this->_blEmployMultilanguage) {
                    if ($blSkipMultilingual && $this->isMultilingualField($sKey)) {
                        continue;
                    }
                    if ($blSkipCoreFields && !$this->isMultilingualField($sKey)) {
                        continue;
                    }
                } else {
                    // need to explicitly check field language
                    $iFieldLang = $this->_getFieldLang($sKey);
                    if ($iFieldLang) {
                        if ($sTable != getLangTableName($sCoreTable, $iFieldLang)) {
                            continue;
                        }
                    } elseif ($blSkipCoreFields) {
                        continue;
                    }
                }
            }

            $sLongName = $this->_getFieldLongName($sKey);
            $oField = $this->$sLongName;

            if ( !$blUseSkipSaveFields || ($blUseSkipSaveFields && !in_array($sKeyLowercase, $this->_aSkipSaveFields)) ) {
                $sKey = $this->getUpdateSqlFieldName($sKey);
                $sSql .= (( $blSep) ? ',':'' ).$sKey." = ".$this->_getUpdateFieldValue($sKey, $oField);
                $blSep = true;
            }
        }

        return $sSql;
    }

    protected function _getUpdateFields( $blUseSkipSaveFields = true )
    {
        return $this->_getUpdateFieldsForTable( $this->getCoreTableName(), $blUseSkipSaveFields );
    }

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

        if ($blRet) {
            //also update multilang table if it is separate
            $aUpdateTables = array();
            if ($this->_blEmployMultilanguage) {
                $sCoreTable = $this->getCoreTableName();
                $sLangTable = getLangTableName($sCoreTable, $this->getLanguage() );
                if ($sCoreTable != $sLangTable) {
                    $aUpdateTables[] = $sLangTable;
                }
            } else {
                $aUpdateTables = $this->_getLanguageSetTables();
            }
            foreach ($aUpdateTables as $sLangTable) {
                $sUpdate= "insert into $sLangTable set ".$this->_getUpdateFieldsForTable( $sLangTable, $this->getUseSkipSaveFields() ) .
                          " on duplicate key update ".$this->_getUpdateFieldsForTable( $sLangTable );

                $blRet = (bool) oxDb::getDb()->execute( $sUpdate);
            }
        }

        // 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
            oxRegistry::get("oxSeoEncoder")->markAsExpired( $this->getId(), null, 1, $this->getLanguage() );
        }

        return $blRet;
    }

    protected function _getLanguageSetTables( $sCoreTableName = null )
    {
        $sCoreTableName = $sCoreTableName ? $sCoreTableName : $this->getCoreTableName();
        return oxNew('oxDbMetaDataHandler')->getAllMultiTables( $sCoreTableName );
    }

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

        if ($blRet) {
            //also insert to multilang tables if it is separate
            foreach ($this->_getLanguageSetTables() as $sTable) {
                $sSq = "insert into $sTable set ".$this->_getUpdateFieldsForTable( $sTable, $this->getUseSkipSaveFields() );
                $blRet = $blRet && (bool) oxDb::getDb()->execute( $sSq );
            }
        }

        return $blRet;
    }

    protected function _getObjectViewName( $sTable, $sShopID = null)
    {
        if (!$this->_blEmployMultilanguage) {
            return parent::_getObjectViewName($sTable, $sShopID);
        }
        return getViewName( $sTable, $this->getLanguage(), $sShopID);
    }

    protected function _getAllFields( $blReturnSimple = false )
    {
        if ( $this->_blEmployMultilanguage ) {
            return parent::_getAllFields( $blReturnSimple );
        } else {
            $sViewName = $this->getViewName();
            if ( !$sViewName ) {
                return array();
            }
            return $this->_getTableFields( $sViewName, $blReturnSimple );
        }
    }

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

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

    protected function _canFieldBeNull( $sFieldName )
    {
        $sFieldName = preg_replace( '/_\d{1,2}$/', '', $sFieldName );
        return parent::_canFieldBeNull( $sFieldName );
    }

    public function delete( $sOXID = null )
    {
        $blDeleted = parent::delete( $sOXID );
        if ( $blDeleted ) {
            $oDB = oxDb::getDb();
            $sOXID = $oDB->quote( $sOXID );

            //delete the record
            foreach ( $this->_getLanguageSetTables() as $sSetTbl ) {
                $oDB->execute( "delete from {$sSetTbl} where oxid = {$sOXID}" );
            }
        }
        return $blDeleted;
    }
}