oxdb.php

Go to the documentation of this file.

<?php


// Including main ADODB include
require_once getShopBasePath() . 'core/adodblite/adodb.inc.php';

class oxDb
{
    const FETCH_MODE_NUM = ADODB_FETCH_NUM;

    const FETCH_MODE_ASSOC = ADODB_FETCH_ASSOC;

    public static $configSet = false;

    protected static $_instance = null;

    protected static $_oDB = null;

    protected static $_aTblDescCache = array();

    private static $_dbType = '';

    private static $_dbUser = '';

    private static $_dbPwd  = '';

    private static $_dbName = '';

    private static $_dbHost = '';

    private static $_iDebug = 0;

    private static $_blLogChangesInAdmin = false;

    private static $_iUtfMode = 0;

    private static $_sDefaultDatabaseConnection = null;

    private static $_aSlaveHosts;

    private static $_sAdminEmail;

    private static $_iMasterSlaveBalance;

    private static $_sLocalTimeFormat;

    private static $_sLocalDateFormat;

    public static function setConfig( $oConfig )
    {
        self::$_dbType                     = $oConfig->getVar( 'dbType' );
        self::$_dbUser                     = $oConfig->getVar( 'dbUser' );
        self::$_dbPwd                      = $oConfig->getVar( 'dbPwd' );
        self::$_dbName                     = $oConfig->getVar( 'dbName' );
        self::$_dbHost                     = $oConfig->getVar( 'dbHost' );
        self::$_iDebug                     = $oConfig->getVar( 'iDebug' );
        self::$_blLogChangesInAdmin        = $oConfig->getVar( 'blLogChangesInAdmin' );
        self::$_iUtfMode                   = $oConfig->getVar( 'iUtfMode' );
        self::$_sDefaultDatabaseConnection = $oConfig->getVar( 'sDefaultDatabaseConnection' );
        self::$_aSlaveHosts                = $oConfig->getVar( 'aSlaveHosts' );
        self::$_iMasterSlaveBalance        = $oConfig->getVar( 'iMasterSlaveBalance' );
        self::$_sAdminEmail                = $oConfig->getVar( 'sAdminEmail' );
        self::$_sLocalTimeFormat           = $oConfig->getVar( 'sLocalTimeFormat' );
        self::$_sLocalDateFormat           = $oConfig->getVar( 'sLocalDateFormat' );
    }

    protected static function _getConfigParam( $sConfigName )
    {
        if ( isset( self::$$sConfigName ) ) {
            return self::$$sConfigName;
        }

        return null;
    }

    public static function getInstance()
    {
        // disable caching for test modules
        if ( defined( 'OXID_PHP_UNIT' ) ) {
            self::$_instance = modInstances::getMod( __CLASS__ );
        }

        if ( !self::$_instance instanceof oxDb ) {

            //do not use simple oxNew here as it goes to eternal cycle
            self::$_instance = new oxDb();

            if ( defined( 'OXID_PHP_UNIT' ) ) {
                modInstances::addMod( __CLASS__, self::$_instance);
            }
        }
        return self::$_instance;
    }

    protected function isAdmin()
    {
        return isAdmin();
    }

    protected function _getModules()
    {
        //adding exception handler for SQL errors
        $_iDebug = self::_getConfigParam( '_iDebug' );

        global $ADODB_EXCEPTION;
        $ADODB_EXCEPTION = 'oxAdoDbException';
        include_once getShopBasePath() . 'core/adodblite/adodb-exceptions.inc.php';

        $sModules = '';
        if (  $_iDebug == 2 || $_iDebug == 3 || $_iDebug == 4 || $_iDebug == 7  ) {
            $sModules = 'perfmon';
        }

        // log admin changes ?
        if ( $this->isAdmin() && self::_getConfigParam( '_blLogChangesInAdmin' ) ) {
            $sModules .= ( $sModules ? ':' : '' ) . 'oxadminlog';
        }

        return $sModules;
    }

    protected function _setUp( $oDb )
    {
        $_iDebug = self::_getConfigParam( '_iDebug' );
        if ( $_iDebug == 2 || $_iDebug == 3 || $_iDebug == 4  || $_iDebug == 7 ) {
            try {
                $oDb->execute( 'truncate table adodb_logsql' );
            } catch ( ADODB_Exception $e ) {
                // nothing
            }
            if ( method_exists( $oDb, "logSQL" ) ) {
                $oDb->logSQL( true );
            }
        }

        $oDb->cacheSecs = 60 * 10; // 10 minute caching
        $oDb->execute( 'SET @@session.sql_mode = ""' );

        if ( self::_getConfigParam( '_iUtfMode' ) ) {
            $oDb->execute( 'SET NAMES "utf8"' );
            $oDb->execute( 'SET CHARACTER SET utf8' );
            $oDb->execute( 'SET CHARACTER_SET_CONNECTION = utf8' );
            $oDb->execute( 'SET CHARACTER_SET_DATABASE = utf8' );
            $oDb->execute( 'SET character_set_results = utf8' );
            $oDb->execute( 'SET character_set_server = utf8' );
        } elseif ( ( $sConn = self::_getConfigParam('_sDefaultDatabaseConnection') ) != '' ) {
            $oDb->execute( 'SET NAMES "' . $sConn . '"' );
        }
    }

    protected function _sendMail( $sEmail, $sSubject, $sBody )
    {
        include_once getShopBasePath() . 'core/phpmailer/class.phpmailer.php';
        $oMailer = new phpmailer();
        $oMailer->isMail();

        $oMailer->From = $sEmail;
        $oMailer->AddAddress( $sEmail );
        $oMailer->Subject = $sSubject;
        $oMailer->Body = $sBody;
        return $oMailer->send();
    }

    protected function _notifyConnectionErrors( $oDb )
    {
        // notifying shop owner about connection problems
        if ( ( $sAdminEmail = self::_getConfigParam( '_sAdminEmail' ) ) ) {
            $sFailedShop = isset( $_REQUEST['shp'] ) ? addslashes( $_REQUEST['shp'] ) : 'Base shop';

            $sDate = date( 'l dS of F Y h:i:s A');
            $sScript  = $_SERVER['SCRIPT_NAME'] . '?' . $_SERVER['QUERY_STRING'];
            $sReferer = $_SERVER['HTTP_REFERER'];

            //sending a message to admin
            $sWarningSubject = 'Offline warning!';
            $sWarningBody = "
                Database error in OXID eShop:
                Date: {$sDate}
                Shop: {$sFailedShop}

                mysql error: " . $oDb->errorMsg()."
                mysql error no: " . $oDb->errorNo()."

                Script: {$sScript}
                Referer: {$sReferer}";

            $this->_sendMail( $sAdminEmail, $sWarningSubject, $sWarningBody );
        }

        //only exception to default construction method
        $oEx = new oxConnectionException();
        $oEx->setMessage( 'EXCEPTION_CONNECTION_NODB' );
        $oEx->setConnectionError( self::_getConfigParam( '_dbUser' ) . 's' . getShopBasePath() . $oDb->errorMsg() );
        throw $oEx;
    }

    protected function _onConnectionError( $oDb )
    {
        $sVerPrefix = '';
            $sVerPrefix = '_ce';



        $sConfig = join( '', file( getShopBasePath().'config.inc.php' ) );

        if ( strpos( $sConfig, '<dbHost'.$sVerPrefix.'>' ) !== false &&
             strpos( $sConfig, '<dbName'.$sVerPrefix.'>' ) !== false ) {
            // pop to setup as there is something wrong
            //oxRegistry::getUtils()->redirect( "setup/index.php", true, 302 );
            $sHeaderCode = "HTTP/1.1 302 Found";
            header( $sHeaderCode );
            header( "Location: setup/index.php" );
            header( "Connection: close" );
            exit();
        } else {
            // notifying about connection problems
            $this->_notifyConnectionErrors( $oDb );

        }
    }


    protected function _getDbInstance( $iInstType = false )
    {
        $sHost = self::_getConfigParam( "_dbHost" );
        $sUser = self::_getConfigParam( "_dbUser" );
        $sPwd  = self::_getConfigParam( "_dbPwd" );
        $sName = self::_getConfigParam( "_dbName" );
        $sType = self::_getConfigParam( "_dbType" );

        $oDb = ADONewConnection( $sType, $this->_getModules() );


            try {
                $oDb->connect( $sHost, $sUser, $sPwd, $sName );
            } catch( oxAdoDbException $e ) {
                $this->_onConnectionError( $oDb );
            }

        self::_setUp( $oDb );

        return $oDb;
    }

    public static function getDb( $iFetchMode = oxDb::FETCH_MODE_NUM )
    {
        if ( defined( 'OXID_PHP_UNIT' ) ) {
            if ( isset( modDB::$unitMOD ) && is_object( modDB::$unitMOD ) ) {
                return modDB::$unitMOD;
            }
        }

        if ( self::$_oDB === null ) {

            $oInst = self::getInstance();

            //setting configuration on the first call
            $oInst->setConfig( oxRegistry::get("oxConfigFile") );

             global  $ADODB_SESSION_TBL,
                    $ADODB_SESSION_CONNECT,
                    $ADODB_SESSION_DRIVER,
                    $ADODB_SESSION_USER,
                    $ADODB_SESSION_PWD,
                    $ADODB_SESSION_DB,
                    $ADODB_SESS_LIFE,
                    $ADODB_SESS_DEBUG;

             // session related parameters. don't change.

            //Tomas
            //the default setting is 3000 * 60, but actually changing this will give no effect as now redefinition of this constant
            //appears after OXID custom settings are loaded and $ADODB_SESS_LIFE depends on user settings.
            //You can find the redefinition of ADODB_SESS_LIFE @ oxconfig.php:: line ~ 390.
            $ADODB_SESS_LIFE       = 3000 * 60;
            $ADODB_SESSION_TBL     = "oxsessions";
            $ADODB_SESSION_DRIVER  = self::_getConfigParam( '_dbType' );
            $ADODB_SESSION_USER    = self::_getConfigParam( '_dbUser' );
            $ADODB_SESSION_PWD     = self::_getConfigParam( '_dbPwd' );
            $ADODB_SESSION_DB      = self::_getConfigParam( '_dbName' );
            $ADODB_SESSION_CONNECT = self::_getConfigParam( '_dbHost' );
            $ADODB_SESS_DEBUG      = false;

            $oDb = new oxLegacyDb();
            $oDbInst = $oInst->_getDbInstance();
            $oDb->setConnection( $oDbInst );

            self::$_oDB = $oDb;
        }

        self::$_oDB->setFetchMode( $iFetchMode );

        return self::$_oDB;
    }

    public function quoteArray( $aStrArray )
    {
        $oDb = self::getDb();

        foreach ( $aStrArray as $sKey => $sString ) {
            $aStrArray[$sKey] = $oDb->quote( $sString );
        }
        return $aStrArray;
    }

    public function resetTblDescCache()
    {
        self::$_aTblDescCache = array();
    }

    public function getTableDescription( $sTableName )
    {
        // simple cache
        if ( isset( self::$_aTblDescCache[$sTableName] ) ) {
            return self::$_aTblDescCache[$sTableName];
        }

            $aFields = self::getDb()->MetaColumns( $sTableName );

        self::$_aTblDescCache[$sTableName] = $aFields;

        return $aFields;
    }

    public function convertDBDateTime( $oObject, $blToTimeStamp = false, $blOnlyDate = false )
    {
        return oxRegistry::get('oxUtilsDate')->convertDBDateTime( $oObject, $blToTimeStamp, $blOnlyDate );
    }

    public function convertDBTimestamp( $oObject, $blToTimeStamp = false )
    {
        return oxRegistry::get('oxUtilsDate')->convertDBTimestamp( $oObject, $blToTimeStamp );
    }

    public function convertDBDate( $oObject, $blToTimeStamp = false )
    {
        return oxRegistry::get('oxUtilsDate')->convertDBDate( $oObject, $blToTimeStamp );
    }

    public function isValidFieldName( $sField )
    {
        return ( boolean ) getStr()->preg_match( "#^[\w\d\._]*$#", $sField );
    }

    protected function _setDefaultFormatedValue( $oObject, $sDate, $sLocalDateFormat, $sLocalTimeFormat, $blOnlyDate )
    {
    }

    protected function _defineAndCheckDefaultTimeValues( $blToTimeStamp )
    {
    }

    protected function _defineAndCheckDefaultDateValues( $blToTimeStamp )
    {
    }

    protected function _defaultDatePattern()
    {
    }

    protected function _defaultTimePattern()
    {
    }

    protected function _regexp2ValidateDateInput()
    {
    }

    protected function _regexp2ValidateTimeInput()
    {
    }

    protected function _defineDateFormattingRules()
    {
        // date formatting rules
        $aDFormats  = array("ISO" => array("Y-m-d", array(2, 3, 1), "0000-00-00"),
                            "EUR" => array("d.m.Y", array(2, 1, 3), "00.00.0000"),
                            "USA" => array("m/d/Y", array(1, 2, 3), "00/00/0000")
                           );
        return $aDFormats;
    }

    protected function _defineTimeFormattingRules()
    {
        // time formatting rules
        $aTFormats  = array("ISO" => array("H:i:s",   array(1, 2, 3 ), "00:00:00"),
                            "EUR" => array("H.i.s",   array(1, 2, 3 ), "00.00.00"),
                            "USA" => array("h:i:s A", array(1, 2, 3 ), "00:00:00 AM")
                           );
        return $aTFormats;
    }

    protected function _setDefaultDateTimeValue( $oObject, $sLocalDateFormat, $sLocalTimeFormat, $blOnlyDate )
    {
        $aDFormats  = $this->_defineDateFormattingRules();
        $aTFormats  = $this->_defineTimeFormattingRules();

        $sReturn = $aDFormats[$sLocalDateFormat][2];
        if ( !$blOnlyDate) {
            $sReturn .= " ".$aTFormats[$sLocalTimeFormat][2];
        }

        if ($oObject instanceof oxField) {
            $oObject->setValue(trim($sReturn));
        } else {
            $oObject->value = trim($sReturn);
        }
        // increasing(decreasing) field length
        $oObject->fldmax_length = strlen( $oObject->value);
    }

    protected function _setDate( $oObject, $sDateFormat, $aDFields, $aDateMatches )
    {
        // formatting correct time value
        $iTimestamp = mktime( 0, 0, 0, $aDateMatches[$aDFields[0]],
                              $aDateMatches[$aDFields[1]],
                              $aDateMatches[$aDFields[2]]);

        if ($oObject instanceof oxField) {
            $oObject->setValue(@date( $sDateFormat, $iTimestamp ));
        } else {
            $oObject->value = @date( $sDateFormat, $iTimestamp );
        }
        // we should increase (decrease) field length
        $oObject->fldmax_length = strlen( $oObject->value );
    }

    protected function _formatCorrectTimeValue( $oObject, $sDateFormat, $sTimeFormat, $aDateMatches, $aTimeMatches, $aTFields, $aDFields )
    {
        // formatting correct time value
        $iTimestamp = @mktime( (int) $aTimeMatches[$aTFields[0]],
                               (int) $aTimeMatches[$aTFields[1]],
                               (int) $aTimeMatches[$aTFields[2]],
                               (int) $aDateMatches[$aDFields[0]],
                               (int) $aDateMatches[$aDFields[1]],
                               (int) $aDateMatches[$aDFields[2]] );

        if ($oObject instanceof oxField) {
            $oObject->setValue(trim( @date( $sDateFormat." ".$sTimeFormat, $iTimestamp ) ));
        } else {
            $oObject->value = trim( @date( $sDateFormat." ".$sTimeFormat, $iTimestamp ) );
        }

        // we should increase (decrease) field length
        $oObject->fldmax_length = strlen( $oObject->value );
    }

    protected function _getConnectionId()
    {
        return self::getDb()->getDb()->connectionId;
    }

    public function escapeString( $sString )
    {
        if ( 'mysql' == self::_getConfigParam( "_dbType" )) {
            return mysql_real_escape_string( $sString, $this->_getConnectionId() );
        } elseif ( 'mysqli' == self::_getConfigParam( "_dbType" )) {
            return mysqli_real_escape_string( $this->_getConnectionId(), $sString );
        } else {
            return mysql_real_escape_string( $sString, $this->_getConnectionId() );
        }
    }

    public function updateViews( $aTables = null )
    {
        $oMetaData = oxNew('oxDbMetaDataHandler');
        return $oMetaData->updateViews();
    }
}