oxbase.php

Go to the documentation of this file.

<?php

DEFINE('ACTION_NA', 0);
DEFINE('ACTION_DELETE', 1);
DEFINE('ACTION_INSERT', 2);
DEFINE('ACTION_UPDATE', 3);
DEFINE('ACTION_UPDATE_STOCK', 4);

class oxBase extends oxSuperCfg
{
    protected $_sOXID = null;

    protected $_iShopId = null;

    protected $_blIsSimplyClonable = true;

    protected $_aErrors = array();

    protected $_sClassName = 'oxbase';

    protected $_sCoreTable = null;

    protected $_sViewTable  = null;


    protected $_aFieldNames = array('oxid' => 0);

    protected $_blIsNewCache = false;

    protected $_sCacheKey = null;

    protected $_blUseLazyLoading = false;

    protected $_aSkipSaveFields = array();

    protected $_sExistKey = "oxid";

    protected $_blIsDerived = null;

    protected static $_blDisableFieldCaching = array();

    protected $_blIsSeoObject = false;

    protected $_blReadOnly = false;

    protected $_blIsInList = false;

    protected $_isLoaded = false;

    public function __construct()
    {
        // set active shop
        $myConfig = $this->getConfig();
        $this->_sCacheKey = $this->getViewName();
        if ( $this->_blUseLazyLoading ) {
            $this->_sCacheKey .= $myConfig->getActiveView()->getClassName();
        } else {
            $this->_sCacheKey .= "allviews";
        }

        //do not cache for admin?
        if ( $this->isAdmin() ) {
            $this->_sCacheKey = null;
        }

        $this->setShopId( $myConfig->getShopId() );
    }

    public function __set($sName, $sValue)
    {
        $this->$sName = $sValue;
        if ( $this->_blUseLazyLoading && strpos( $sName, $this->_sCoreTable . "__" ) === 0 ) {
            $sFieldName = str_replace( $this->_sCoreTable . "__", '', $sName );
            if ($sFieldName != 'oxnid' && !$this->_aFieldNames[$sFieldName]) {
                $aAllFields = $this->_getAllFields(true);
                if (isset($aAllFields[strtolower($sFieldName)])) {
                    $iFieldStatus = $this->_getFieldStatus($sFieldName);
                    $this->_addField($sFieldName, $iFieldStatus);
                }
            }
        }
    }

    public function __get( $sName )
    {
        switch ($sName) {
            case 'blIsDerived':
                return $this->isDerived();
                break;
            case 'sOXID':
                return $this->getId();
                break;
            case 'blReadOnly':
                return $this->isReadOnly();
                break;
        }

        // implementing lazy loading fields
        // This part of the code is slow and normally is called before field cache is built.
        // Make sure it is not called after first page is loaded and cache data is fully built.
        if ( $this->_blUseLazyLoading && strpos( $sName, $this->_sCoreTable . "__" ) === 0 ) {

            //lazy load it
            $sFieldName = str_replace($this->_sCoreTable . "__", '', $sName);
            //$sFieldName = $this->getSqlFieldName($sFieldName);
            $iFieldStatus = $this->_getFieldStatus($sFieldName);

            $sSqlFieldName = $sFieldName;
            if ($iFieldStatus && $this->isMultilang() ) {
                $sSqlFieldName =  $sFieldName.oxLang::getInstance()->getLanguageTag( $this->getLanguage() );
            }

            if ( $this->getId() ) {
                $oDb = oxDb::getDb();
                $sQ = "select $sSqlFieldName from " . $this->_sCoreTable . " where oxid = " . $oDb->quote($this->getId());

                try {
                    //$sValue = $oDb->getOne( $sQ );
                    $rs = $oDb->execute( $sQ );
                    if ( $rs === false ) {
                        return null;
                    }

                    $this->_addField($sFieldName, $iFieldStatus);
                    $sValue = $rs->fields[0];
                    $this->_setFieldData( $sFieldName, $sValue );

                    //save names to cache for next loading
                    if ($this->_sCacheKey) {
                        $myUtils = oxUtils::getInstance();
                        $sCacheKey = 'fieldnames_' . $this->_sCoreTable . "_" . $this->_sCacheKey;
                        $aFieldNames = $myUtils->fromFileCache($sCacheKey);
                        $aFieldNames[$sFieldName] = $iFieldStatus;
                        $myUtils->toFileCache($sCacheKey, $aFieldNames);
                    }

                } catch ( Exception $e ) {
                    return null;
                }

                //do not use field cache for this page
                //as if we use it for lists then objects are loaded empty instead of lazy lodaing.
                self::$_blDisableFieldCaching[get_class($this)] = true;
            }

            /*
            //save names to cache for next loading
            if ($this->_sCacheKey) {
                $sCacheKey = 'fieldnames_' . $this->_sCoreTable . "_" . $this->_sCacheKey;
                $aFieldNames = oxUtils::getInstance()->fromFileCache($sCacheKey);
                $aFieldNames[$sFieldName] = $iFieldStatus;
                oxUtils::getInstance()->toFileCache($sCacheKey, $aFieldNames);
            }*/

            oxUtilsObject::getInstance()->resetInstanceCache(get_class($this));
        }

        //returns oxStdClass implementing __toString() method due to uknown scenario where this var should be used.
        if (!isset( $this->$sName ) ) {
            $this->$sName = null;
        }

        return $this->$sName;
    }

    public function __isset($mVar)
    {
        return isset($this->$mVar);
    }

    public function __clone()
    {
        if (!$this->_blIsSimplyClonable) {
            foreach ( $this->_aFieldNames as $sField => $sVal ) {
                $sLongName = $this->_getFieldLongName( $sField );
                if ( is_object($this->$sLongName)) {
                    $this->$sLongName = clone $this->$sLongName;
                }
            }
        }
    }

    public function oxClone($oObject)
    {
        $aClasVars = get_object_vars( $oObject);
        while (list($name, $value) = each($aClasVars)) {
            if ( is_object( $oObject->$name ) ) {
                $this->$name = clone $oObject->$name;
            } else {
                $this->$name = $oObject->$name;
            }
        }
    }

    public function init( $sTableName = null, $blForceAllFields = false)
    {

        if ( !$sTableName ) {
            $sTableName = $this->_sCoreTable;
        } else {
            $this->_sCoreTable = $sTableName;
        }

        $this->_sViewTable = getViewName( $this->_sCoreTable );

        //do not use views?

        if ( count( $this->_aFieldNames ) <= 1 ) {
            $this->_initDataStructure( $blForceAllFields );
        }
    }

    public function assign( $dbRecord )
    {
        if ( !is_array( $dbRecord ) ) {
            return;
        }


        reset($dbRecord );
        while ( list( $sName, $sValue ) = each( $dbRecord ) ) {

            // patch for IIS
            //TODO: test it on IIS do we still need it
            //if( is_array($value) && count( $value) == 1)
            //    $value = current( $value);

            $this->_setFieldData( $sName, $sValue );
        }

        $sOxidField = $this->_getFieldLongName( 'oxid' );
        $this->_sOXID = $this->$sOxidField->value;

    }

    public function getClassName()
    {
        return $this->_sClassName;
    }

    public function getCoreTableName()
    {
        return $this->_sCoreTable;
    }

    public function getId()
    {
        return $this->_sOXID;
    }

    public function setId($sOXID = null)
    {
        if ( $sOXID ) {
            $this->_sOXID = $sOXID;
        } else {
            $this->_sOXID = oxUtilsObject::getInstance()->generateUID();
        }

        $sIdVarName = $this->_sCoreTable . "__oxid";
        $this->$sIdVarName = new oxField($this->_sOXID, oxField::T_RAW);

        return $this->_sOXID;
    }

    public function setShopId($iShopId)
    {
        $this->_iShopId = $iShopId;
    }

    public function getShopId()
    {
        return $this->_iShopId;
    }

    public function getViewName()
    {
        return $this->_sViewTable;
    }

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

    public function disableLazyLoading()
    {
        $this->_blUseLazyLoading = false;
        $this->_initDataStructure(true);
    }


    public function isDerived()
    {

        return $this->_blIsDerived;
    }

    public function setIsDerived($blVal)
    {
        $this->_blIsDerived = $blVal;
    }

    public function isMultilang()
    {
        return false;
    }

    public function load( $sOXID)
    {
        /*
        if( !isset($oxID)){
            $oEx = oxNew('oxObjectException','core');
            $oEx->setMessage('EXCEPTION_OBJECT_OXIDNOTSET');
            $oEx->setObject($this);
            throw $oEx;
        }*/

        //getting at least one field before lazy loading the object
        $this->_addField('oxid', 0);

        $sSelect = $this->buildSelectString( array( $this->getViewName().".oxid" => $sOXID));

        return $this->_isLoaded = $this->assignRecord( $sSelect );
    }

    public function isLoaded()
    {
        return $this->_isLoaded;
    }

    public function buildSelectString( $aWhere = null)
    {
        $oDB = oxDb::getDb(true);
        $myUtils = oxUtils::getInstance();

        $sGet = $this->getSelectFields();
        $sSelect = "select $sGet from " . $this->_sViewTable . " where 1 ";

        if ( $aWhere) {
            reset($aWhere);
            while (list($name, $value) = each($aWhere)) {
                $sSelect .=  " and " . $name.' = '.$oDB->quote($value);
            }
        }

        // add active shop

        //echo( "<br><br>$sSelect <br><br>\n\n\n");

        return $sSelect;
    }

    public function assignRecord( $sSelect)
    {
        $blRet = false;

        $oDB = oxDb::getDb(true);

        $rs = $oDB->execute( $sSelect);
        if ($rs != false && $rs->recordCount() > 0) {
            $blRet = true;
            $this->assign( $rs->fields);
        }

        return $blRet;
    }

    public function getFieldData( $sFieldName)
    {
        $sLongFieldName = $this->_getFieldLongName($sFieldName);
        return $this->$sLongFieldName->value;
    }

    public function getSelectFields()
    {
        $aSelectFields = array();

        foreach ( $this->_aFieldNames as $sKey => $sField ) {
            $sRealField = $this->getSqlFieldName($sKey);
            $sSelectSufix = "";
            if ( $sRealField !== $sKey ) {
                $sSelectSufix = " as $sKey";
            }
            $aSelectFields[] = $this->_sViewTable . '.' . $sRealField . $sSelectSufix;
        }

        $sSelectFields = join( ", ", $aSelectFields );
        return $sSelectFields;
    }

    public function delete( $sOXID = null)
    {
        if ( !$sOXID ) {
            $sOXID = $this->getId();

            //do not allow derived deletion
            if ( !$this->allowDerivedDelete() ) {
                return false;
            }
        }

        if ( !$sOXID ) {
            return false;
        }


        $oDB = oxDb::getDb(true);
        $sDelete = "delete from $this->_sCoreTable where oxid = ".$oDB->quote( $sOXID );
        $rs = $oDB->execute( $sDelete );
        if ( $blDelete = ( bool ) $oDB->affected_Rows() ) {
            $this->onChange(ACTION_DELETE, $sOXID);
        }

        return $blDelete;
    }


    public function save()
    {
        if ( !is_array( $this->_aFieldNames ) ) {
            return false;
        }

        $blRet = false;

        // #739A - should be executed here because of date/time formatting feature
        if ( $this->isAdmin() && !$this->getConfig()->getConfigParam( 'blSkipFormatConversion' ) ) {
            foreach ($this->_aFieldNames as $sName => $sVal) {
                $sLongName = $this->_getFieldLongName($sName);
                if ( isset($this->$sLongName->fldtype) && $this->$sLongName->fldtype == "datetime" ) {
                    oxDb::getInstance()->convertDBDateTime( $this->$sLongName, true );
                } elseif ( isset($this->$sLongName->fldtype) && $this->$sLongName->fldtype == "timestamp" ) {
                    oxDb::getInstance()->convertDBTimestamp( $this->$sLongName, true);
                } elseif ( isset($this->$sLongName->fldtype) && $this->$sLongName->fldtype == "date" ) {
                    oxDb::getInstance()->convertDBDate( $this->$sLongName, true);
                }
            }
        }

        if ( $this->exists() ) {

            //do not allow derived update
            if ( !$this->allowDerivedUpdate() ) {
                return false;
            }

            $blRet = $this->_update();
            $sAction = ACTION_UPDATE;
        } else {
            $blRet = $this->_insert();
            $sAction = ACTION_INSERT;
        }

        $this->onChange($sAction);

        if ( $blRet ) {
            return $this->getId();
        } else {
            return false;
        }
    }

    public function allowDerivedUpdate()
    {
        return !$this->isDerived();
    }

    public function allowDerivedDelete()
    {
        return !$this->isDerived();
    }

    public function exists( $sOXID = null)
    {
        if ( !$sOXID ) {
            $sOXID = $this->getId();
        }
        if ( !$sOXID ) {
            return false;
        }

        $sViewName = $this->getViewName();
        $oDB = oxDb::getDb( true );
        $sSelect= "select {$this->_sExistKey} from {$sViewName} where {$this->_sExistKey} = ".$oDB->quote( $sOXID );
        return ( bool ) $oDB->getOne( $sSelect );
    }

    public function getSqlFieldName($sField)
    {
        return $sField;
    }

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

        // has 'active' field ?
        if ( 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;
    }

    public function validate()
    {
        $this->_aErrors = array();
        foreach ($this->_aFieldNames as $fName => $iVal) {

            $fName = $this->_getFieldLongName($fName);

            if ( method_exists ( $this, "validate_$fName")) {
                $validatorMethod = "validate_$fName";
                if ( $error = $this->$validatorMethod()) {
                    $this->_aErrors[$fName] = $error;
                }
            }
        }
        return !$this->hasErrors();
    }

    public function beforeUpdate( $sOXID = null )
    {
    }

    public function onChange( $iAction = null, $sOXID = null)
    {
    }


    public function hasErrors()
    {
        return count($this->_aErrors) > 0;
    }

    public function getErrors()
    {
        return $this->_aErrors;
    }

    public function getError( $sField)
    {
        if (isset($this->_aErrors[$sField])) {
            return $this->_aErrors[$sField];
        }

        //T2007-10-19
        //return array();
        return null;
    }

    public function getHtmlError( $sField)
    {
        if ( $error = $this->getError($sField) ) {
            return $error;
        }
    }

    public function setInList()
    {
        $this->_blIsInList = true;
    }

    protected function _isInList()
    {
        return $this->_blIsInList;
    }

    protected function _getObjectViewName( $sTable, $sShopID = null)
    {
            return $sTable;

    }


    protected function _getAllFields($blReturnSimple = false)
    {
        $myUtils = oxUtils::getInstance();

        if (!$this->_sCoreTable) {
            return array();
        }

        //T2008-09-04
        //The cache here saves almost 7% of execution time
        //But it seems that oxeec_tbdsc_oxarticles.txt and oxeec_oxarticles_allfields.txt tmp files are identical.
        //TODO: Check what's up with that.
        $sCacheKey   = $this->_sCoreTable . "_allfields_" . $blReturnSimple;
        $aMetaFields = $myUtils->fromFileCache( $sCacheKey );

        if ($aMetaFields) {
            return $aMetaFields;
        }

        $aMetaFields = oxDb::getInstance()->getTableDescription( $this->_sCoreTable );

        if ( !$blReturnSimple ) {
            $myUtils->toFileCache( $sCacheKey, $aMetaFields );
            return $aMetaFields;
        }

        //returning simple array
        $aRet = array();
        if (is_array($aMetaFields)) {
            foreach ( $aMetaFields as $oVal ) {
                $aRet[strtolower( $oVal->name )] = 0;
            }
        }

        $myUtils->toFileCache( $sCacheKey, $aRet);

        return $aRet;
    }

    protected function _initDataStructure($blForceFullStructure = false)
    {
        $myUtils = oxUtils::getInstance();

        //get field names from cache
        $aFieldNames = null;
        $sFullCacheKey = 'fieldnames_' .$this->_sCoreTable . "_" . $this->_sCacheKey;
        if ($this->_sCacheKey && !$this->_isDisabledFieldCache()) {
            $aFieldNames = $myUtils->fromFileCache($sFullCacheKey);
        }

        if (!$aFieldNames) {
            $aFieldNames = $this->_getNonCachedFieldNames($blForceFullStructure);
            if ($this->_sCacheKey && !$this->_isDisabledFieldCache()) {
                $myUtils->toFileCache($sFullCacheKey, $aFieldNames);
            }
        }

        if ( $aFieldNames !== false ) {
            foreach ( $aFieldNames as $sField => $sStatus ) {
                $this->_addField($sField, $sStatus);
            }
        }
    }

    protected function _getNonCachedFieldNames($blForceFullStructure = false)
    {
        //T2008-02-22
        //so if this method is executed on cached version we see it when profiling
        startProfile("!__CACHABLE__!");

        //case 1. (admin)
        if ($this->isAdmin()) {
            $aMetaFields = $this->_getAllFields();
            foreach ( $aMetaFields as $oField ) {
                if ( $oField->max_length == -1 ) {
                    $oField->max_length = 10;      // double or float
                }

                if ( $oField->type == "datetime" ) {
                    $oField->max_length = 20;
                }

                $this->_addField( $oField->name, $this->_getFieldStatus($oField->name), $oField->type, $oField->max_length );
            }
            stopProfile("!__CACHABLE__!");
            return false;
        }

        //case 2. (just get all fields)
        if ( $blForceFullStructure || !$this->_blUseLazyLoading ) {
            $aMetaFields = $this->_getAllFields(true);
            /*
            foreach ( $aMetaFields as $sFieldName => $sVal) {
                $this->_addField( $sFieldName, $this->_getFieldStatus($sFieldName));
            }*/
            stopProfile("!__CACHABLE__!");
            return $aMetaFields;
        }

        //case 3. (get only oxid field, so we can fetch the rest of the fields over lazy loading mechanism)
        stopProfile("!__CACHABLE__!");
        return array("oxid" => 0);
    }

    protected function _getFieldStatus($sFieldName)
    {
        return 0;
    }

    protected function _addField($sName, $iStatus, $sType = null, $sLength = null)
    {
        //preparation
        $sName = strtolower($sName);

        //adding field names element
        $this->_aFieldNames[$sName] = $iStatus;

        //allready set?
        $sLongName = $this->_getFieldLongName($sName);
        if ( isset($this->$sLongName) ) {
            return;
        }

        //defining the field
        $oField = false;

        if (isset($sType)) {
            $oField = new oxField();
            $oField->fldtype = $sType;
            //T2008-01-29
            //can't clone as the fields are objects and are not fully cloned
            $this->_blIsSimplyClonable = false;
        }

        if (isset($sLength)) {
            if (!$oField) {
                $oField = new oxField();
            }
            $oField->fldmax_length = $sLength;
            $this->_blIsSimplyClonable = false;
        }

        $this->$sLongName = $oField;
    }

    protected function _getFieldLongName( $sFieldName)
    {
        //trying to avoid strpos call as often as possible
        if ($sFieldName[2] == $this->_sCoreTable[2] && strpos($sFieldName, $this->_sCoreTable."__") === 0) {
            return $sFieldName;
        }

        $sLongName = $this->_sCoreTable."__".strtolower( $sFieldName);
        return $sLongName;
    }

    protected function _setFieldData( $sFieldName, $sValue, $iDataType = oxField::T_TEXT)
    {


        $sLongFieldName = $this->_getFieldLongName( $sFieldName);
        //$sLongFieldName = $this->_sCoreTable . "__" . strtolower($sFieldName);

        //T2008-03-14
        //doing this because in lazy loaded lists on first load it is harmful to have initilised fields but not yet set
        //situation: only first article is loaded fully for "select oxid from oxarticles"
        /*
        if ($this->_blUseLazyLoading && !isset($this->$sLongFieldName))
            return;*/

        //in non lazy loading case we just add a field and do not care about it more
        if (!$this->_blUseLazyLoading && !isset($this->$sLongFieldName)) {
            $aFields = $this->_getAllFields(true);
            if ( isset( $aFields[strtolower($sFieldName)] ) ) {
                $this->_addField($sFieldName, $this->_getFieldStatus($sFieldName));
            }
        }
        // if we have a double field we replace "," with "." in case somebody enters it in european format
        if (isset($this->$sLongFieldName) && isset($this->$sLongFieldName->fldtype) && $this->$sLongFieldName->fldtype == "double") {
            $sValue = str_replace( ",", ".", $sValue );
        }

        // isset is REQUIRED here not to use getter
        if (isset($this->$sLongFieldName) && is_object($this->$sLongFieldName)) {
            $this->$sLongFieldName->setValue($sValue, $iDataType);
        } else {
            $this->$sLongFieldName = new oxField($sValue, $iDataType);
        }

    }

    protected function _getUpdateFieldValue($sFieldName, $oField)
    {
        $blPassNullValue = false;
        if ($oField instanceof oxField) {
            $value = $oField->getRawValue();
        } else {
            $value = $oField->value;
        }
        // R. check if this field value is null AND it can be null according to table description
        if (null === $value) {
            $aMetaData = $this->_getAllFields();
            foreach ($aMetaData as $oMetaInfo) {
                if (!strcasecmp($oMetaInfo->name, $sFieldName)) {
                    $blPassNullValue = !$oMetaInfo->not_null;
                    break;
                }
            }
        }
        if ($blPassNullValue) {
            return 'null';
        } else {
            return oxDb::getDb()->quote( $value );
        }
    }

    protected function _getUpdateFields( $blUseSkipSaveFields = true )
    {
        $sSql = '';
        $blSep  = false;
        foreach (array_keys($this->_aFieldNames) as $sKey) {
            $sLongName = $this->_getFieldLongName($sKey);
            $oField = $this->$sLongName;


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

        return $sSql;
    }

    protected function _update()
    {
        //do not allow derived item update
        if ( !$this->allowDerivedUpdate() ) {
            return false;
        }


        if ( !$this->getId() ) {
            $oEx = oxNew( 'oxObjectException' );
            $oEx->setMessage( 'EXCEPTION_OBJECT_OXIDNOTSET' );
            $oEx->setObject($this);
            throw $oEx;
        }

        $sIDKey = oxUtils::getInstance()->getArrFldName( $this->_sCoreTable.".oxid");
        $this->$sIDKey = new oxField($this->getId(), oxField::T_RAW);

        $sUpdate= "update {$this->_sCoreTable} set ".$this->_getUpdateFields()
                 ." where {$this->_sCoreTable}.oxid = '".$this->getId()."' ";

        //echo         $sUpdate."\n\n\n";

        //trigger event
        $this->beforeUpdate();

        $blRet = (bool) oxDB::getDb()->execute( $sUpdate);
        $this->_rebuildCache();

        return $blRet;
    }

    protected function _insert()
    {

        $oDB      = oxDb::getDb(true);
        $myConfig = $this->getConfig();
        $myUtils  = oxUtils::getInstance();

        // let's get a new ID
        if ( !$this->getId()) {
            $this->setId();
        }

        $sIDKey = $myUtils->getArrFldName( $this->_sCoreTable.".oxid");
        $this->$sIDKey = new oxField($this->getId(), oxField::T_RAW);
        $sInsert= "Insert into {$this->_sCoreTable} set ";

        //setting oxshopid
        $sShopField = $myUtils->getArrFldName($this->_sCoreTable.".oxshopid");
        if (isset($this->$sShopField) && !$this->$sShopField->value)
            $this->$sShopField = new oxField($myConfig->getShopId(), oxField::T_RAW);
        $sInsert .= $this->_getUpdateFields( false );

        $blRet = (bool) $oDB->execute( $sInsert);

        $this->_rebuildCache();

        return $blRet;

    }

    protected function _rebuildCache()
    {
        if ( !$this->_blIsNewCache) {
            oxUtils::getInstance()->rebuildCache();
            $this->_blIsNewCache = true;
        }
    }

    protected function _setRecordNumber( $sMaxField, $aWhere = null, $iMaxTryCnt = 5 )
    {
        // filtering
        $sWhere = "";
        if ( is_array( $aWhere ) && count( $aWhere ) > 0) {
            $sWhere = implode(" and ", $aWhere).' and ';
        }

        // SQL to set record number
        $sUpdate = "update {$this->getViewName()} as t1, (select (max($sMaxField)+1) as t2max from {$this->getViewName()} where $sWhere 1) as t2 set t1.$sMaxField=t2.t2max where t1.oxid = '".$this->getId()."'";

        // SQL to check record number dublicates
        //this should not happen normally but we prefer to take extra care in this case due to parallel script execution etc.
        $sMaxSelect = "select $sMaxField from ".$this->getViewName()." where oxid='".$this->getId()."' ";
        $sCheck = "select count(oxid) from ".$this->getViewName()." where $sMaxField = ($sMaxSelect) and $sWhere 1 ";

        do {
            if ( oxDb::getDb(true)->Execute( $sUpdate ) === false ) {
                return false;
            }

            $iChkCnt = oxDb::getDb(true)->GetOne( $sCheck );
        } while ( ( $iChkCnt > 1 ) && $iMaxTryCnt-- );

        $sFieldName = $this->getViewName().'__'.$sMaxField;
        $this->$sFieldName = new oxField(oxDb::getDb(true)->GetOne( $sMaxSelect ), oxField::T_RAW);//int value

        return ( $iChkCnt == 1 );
    }

    protected function _isDisabledFieldCache()
    {
        $sClass = get_class($this);
        if (isset(self::$_blDisableFieldCaching[$sClass]) && self::$_blDisableFieldCaching[$sClass]) {
            return true;
        }

        return false;
    }

    public function isOx()
    {
        $sOxId = $this->getId();
        if ( $sOxId[0] == 'o' && $sOxId[1] == 'x' ) {
            return true;
        }
        return false;
    }

    public function isReadOnly()
    {
        return $this->_blReadOnly;
    }

    public function setReadOnly( $blReadOnly )
    {
        $this->_blReadOnly = $blReadOnly;
    }

}