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 _setUpdateSeoOnFieldChange($sField)
    {
        parent::_setUpdateSeoOnFieldChange($this->getUpdateSqlFieldName($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->getUpdateSeo() && $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;
    }
}