oxerpbase.php

Go to the documentation of this file.

<?php

require_once 'oxerpcompatability.php';

abstract class oxERPBase
{
    static $ERROR_USER_WRONG = "ERROR: Could not login";
    static $ERROR_USER_NO_RIGHTS =  "Not sufficient rights to perform operation!";
    static $ERROR_USER_EXISTS = "ERROR: User already exists";
    static $ERROR_NO_INIT = "Init not executed, Access denied!";
    static $ERROR_DELETE_NO_EMPTY_CATEGORY = "Only empty category can be deleated";
    static $ERROR_OBJECT_NOT_EXISTING = "Object does not exist";

    static $MODE_IMPORT = "Import";
    static $MODE_DELETE = "Delete";

    protected $_blInit = false;

    protected $_iLanguage = null;

    protected $_sUserID = null;

    protected $_sSID = null;

    protected static $_sRequestedVersion = '';

    protected static $_aDbLayer2ShopDbVersions = array(
        '1' => '1', '1.1' => '1', '2' => '2',
    );

    public $_aStatistics = array();

    public $_iIdx = 0;

    public function getStatistics()
    {
        return $this->_aStatistics;
    }

    public function getSessionID()
    {
        return $this->_sSID;
    }

    protected abstract function _beforeExport($sType);

    protected abstract function _afterExport($sType);

    protected abstract function _beforeImport();

    protected abstract function _afterImport();

    public abstract function getImportData();

    protected abstract function _getImportType( & $aData );

    protected abstract function _getImportMode( $aData );

    protected abstract function _modifyData( $aData, $oType );

    public function __call( $sMethod, $aArguments )
    {
        throw new Exception( "ERROR: Handler for Object '$sMethod' not implemented!");
    }


    // -------------------------------------------------------------------------
    //
    // public interface
    //
    // -------------------------------------------------------------------------


    public function init( $sUserName, $sPassword, $iShopID = 1, $iLanguage = 0)
    {
        $_COOKIE = array('admin_sid' => false);
        $myConfig = oxConfig::getInstance();
        $myConfig->setConfigParam( 'blAdmin', 1 );
        $myConfig->setAdminMode( true );

        $mySession = oxSession::getInstance();
        $myConfig->oActView = new FakeView();

        // hotfix #2429, #2430 MAFI
        if ($iShopID != 1) {
            $myConfig->setConfigParam('blMallUsers', false);
        }
        $myConfig->setShopId($iShopID);

        $mySession->setVar( "lang", $iLanguage);
        $mySession->setVar( "language", $iLanguage);

        $oUser = oxNew('oxuser');
        try {
            if ( !$oUser->login( $sUserName, $sPassword ) ) {
                $oUser = null;
            }
        } catch( oxUserException $e ) {
            $oUser = null;
        }

        if ( !$oUser || ( isset( $oUser->iError ) && $oUser->iError == -1000 ) ) {
            // authorization error
            throw new Exception( self::$ERROR_USER_WRONG );
        } elseif ( ( $oUser->oxuser__oxrights->value == "malladmin" || $oUser->oxuser__oxrights->value == $myConfig->getShopId() ) ) {
            $this->_sSID        = $mySession->getId();
            $this->_blInit      = true;
            $this->_iLanguage   = $iLanguage;
            $this->_sUserID     = $oUser->getId();
            //$mySession->freeze();
        } else {

            //user does not have sufficient rights for shop
            throw new Exception( self::$ERROR_USER_NO_RIGHTS );
        }

        $this->_resetIdx();

        return $this->_blInit;
    }

    public abstract function loadSessionData( $sSessionID );

    public function exportType( $sType, $sWhere = null,$iStart = null, $iCount = null, $sSortFieldName = null, $sSortType = null)
    {
        $this->_beforeExport($sType);
        $this->_export( $sType, $sWhere, $iStart, $iCount, $sSortFieldName, $sSortType);
        $this->_afterExport($sType);
    }

    public function import()
    {
        $this->_beforeImport();
        while ( $this->_importOne() ) {
        }
        $this->_afterImport();
    }

    protected function _getInstanceOfType( $sType )
    {
        $sClassName = 'oxerptype_'.$sType;
        $sFullPath  = dirname(__FILE__).'/objects/'.$sClassName.'.php';

        if ( !file_exists( $sFullPath ) ) {
            throw new Exception( "Type $sType not supported in ERP interface!");
        }

        require_once $sFullPath;
        return oxNew ($sClassName);
    }

    protected function _export( $sType, $sWhere, $iStart = null, $iCount = null, $sSortFieldName = null, $sSortType = null)
    {
        global $ADODB_FETCH_MODE;

        $myConfig = oxConfig::getInstance();
        // prepare
        $oType = $this->_getInstanceOfType( $sType);
        $sSQL  = $oType->getSQL( $sWhere, $this->_iLanguage, $myConfig->getShopId() );
        $sSQL .= $oType->getSortString( $sSortFieldName, $sSortType );
        $sFnc  = '_Export'.$oType->getFunctionSuffix();

        $save = $ADODB_FETCH_MODE;

        if ( isset( $iCount ) || isset( $iStart ) ) {
            $rs = oxDb::getDb(true)->selectLimit( $sSQL, $iCount, $iStart );
        } else {
            $rs = oxDb::getDb(true)->execute( $sSQL );
        }

        if ( $rs != false && $rs->recordCount() > 0 ) {
            while (!$rs->EOF) {
                $blExport = false;
                $sMessage = '';

                $rs->fields = $oType->addExportData( $rs->fields);

                // check rights
                $this->_checkAccess( $oType, false);

                // export now
                try{
                    $blExport = $this->$sFnc( $rs->fields );
                } catch (Exception $e) {
                    $sMessage = $e->getMessage();

                }

                $this->_aStatistics[$this->_iIdx] = array('r'=>$blExport,'m'=>$sMessage);
                //#2428 MAFI
                $this->_nextIdx();

                $rs->moveNext();
            }
        }
        $ADODB_FETCH_MODE = $save;
    }

    protected function _outputMappingArray( $sTable)
    {
        $aData = getTableDescription( $sTable );

        $iIdx = 0;
        foreach ( $aData as $key => $oADODBField) {
            if ( !( is_numeric( substr( $oADODBField->name, strlen( $oADODBField->name) - 1, 1)) &&  substr( $oADODBField->name, strlen( $oADODBField->name) - 2, 1) == '_' ) ) {
                echo( "'".$oADODBField->name."'\t\t => '".$oADODBField->name."',\n" );
                $iIdx++;
            }
        }
    }

    protected function _getKeyID( $oType, $aData )
    {
        $myConfig = oxConfig::getInstance();
        $aKeyFields = $oType->getKeyFields();

        if ( !is_array($aKeyFields ) ) {
            return false;
        }

        $oDB = oxDb::getDb();
        //$aKeys = array_intersect_key($aData,$aKeyFields);

        $aWhere = array();
        $blAllKeys = true;
        foreach ( $aKeyFields as $sKey ) {
            if ( array_key_exists( $sKey, $aData ) ) {
                $aWhere[] = $sKey.'='.$oDB->qstr( $aData[$sKey] );
            } else {
                $blAllKeys = false;
            }
        }

        if ( $blAllKeys ) {
            $sSelect = 'SELECT OXID FROM '.$oType->getTableName().' WHERE '.implode(' AND ', $aWhere );
            $sOXID = $oDB->getOne($sSelect);

            if ( isset( $sOXID ) ) {
                return $sOXID;
            }
        }

        return oxUtilsObject::getInstance()->generateUID();
    }

    protected function _resetIdx()
    {
        $this->_iIdx = 0;
        if ( count( $this->_aStatistics ) && isset( $this->_aStatistics[$this->_iIdx] ) ) {
            while ( isset( $this->_aStatistics[$this->_iIdx]) && $this->_aStatistics[$this->_iIdx]['r'] ) {
                $this->_iIdx ++;
            }
        }
    }

    protected function _nextIdx()
    {
        $this->_iIdx ++;
        if ( count( $this->_aStatistics ) && isset( $this->_aStatistics[$this->_iIdx] ) ) {
            while ( isset( $this->_aStatistics[$this->_iIdx]) && $this->_aStatistics[$this->_iIdx]['r'] ) {
                $this->_iIdx ++;
            }
        }
    }

    protected function _checkAccess( $oType, $blWrite, $sOxid = null )
    {
        $myConfig = oxConfig::getInstance();
        static $aAccessCache;

        if ( !$this->_blInit ) {
            throw new Exception(self::$ERROR_NO_INIT);
        }

        if ( $blWrite ) {
            //check against Shop id if it exists
            $oType->checkWriteAccess( $sOxid );
        }

        // TODO
        // add R&R check for access
        if ( $myConfig->blUseRightsRoles ) {
            static $aAccessCache;

            $sAccessMode = ( (boolean) $blWrite ) ? '2' : '1';
            $sTypeClass  = get_class($oType);

            if ( !isset( $aAccessCache[$sTypeClass][$sAccessMode] ) ) {

                $oDB = oxDb::getDb();

                //create list of user/group id's
                $aIDs = array( $oDB->qstr($this->_sUserID) );
                $sQUserGroups = 'SELECT oxgroupsid ' .
                                'FROM oxobject2group '.
                                //"WHERE oxshopid = '{$this->_iShopID}' ".
                                "WHERE oxshopid = '{$myConfig->getShopId()}' ".
                                "AND oxobjectid ='{$this->_sUserID}'";

                $rs = $oDB->execute( $sQUserGroups);
                if ($rs != false && $rs->recordCount() > 0) {
                    while (!$rs->EOF) {
                        $aIDs[] = $oDB->qstr($rs->fields[0]);
                        $rs->moveNext();
                    }
                }

                $aRParams = $oType->getRightFields();
                foreach ($aRParams as $sKey => $sParam) {
                    $aRParams[$sKey] = $oDB->qstr($sParam);
                }

                //check user rights...
                $sSelect = 'SELECT count(*) '.
                           'FROM oxfield2role as rr , oxrolefields as rf, oxobject2role as ro, oxroles as rt '.
                           "WHERE rr.OXIDX < {$sAccessMode} ".
                           'AND rr.oxroleid = ro.oxroleid  '.
                           'AND rt.oxid = ro.oxroleid '.
                           'AND rt.oxactive = 1 '.
                           //"AND rt.oxshopid = '{$this->_iShopID}'".
                           "AND rt.oxshopid = '{$myConfig->getShopId()}'".
                           'AND rf.oxparam IN ('.implode(',', $aRParams).') '.
                           'AND ro.oxobjectid IN ('.implode(',', $aIDs).') '.
                           'AND rr.oxfieldid=rf.oxid';

                $iNoAccess = $oDB->getOne($sSelect);
                $aAccessCache[$sTypeClass][$sAccessMode] = $iNoAccess;
            } else {
                $iNoAccess = $aAccessCache[$sTypeClass][$sAccessMode];
            }

            if ( $iNoAccess ) {
                throw new Exception( self::$ERROR_USER_NO_RIGHTS );
            }
        }
    }

    protected function _importOne()
    {
        $blRet = false;

        // import one row/call/object...
        $aData = $this->getImportData();

        if ( $aData ) {
            $blRet = true;
            $blImport = false;
            $sMessage = '';

            $sType  = $this->_getImportType( $aData);
            $sMode = $this->_getImportMode($aData);
            $oType  = $this->_getInstanceOfType( $sType);
            $aData = $this->_modifyData($aData, $oType);

            // import now
            $sFnc   = '_' . $sMode . $oType->getFunctionSuffix();

            if ( $sMode == oxERPBase::$MODE_IMPORT ) {
                $aData = $oType->addImportData( $aData );
            }

            try{
                $blImport = $this->$sFnc( $oType, $aData);
                $sMessage = '';
            }
            catch (Exception $e) {
                $sMessage = $e->getMessage();
            }

            $this->_aStatistics[$this->_iIdx] = array('r'=>$blImport,'m'=>$sMessage);

        }
        //hotfix #2428 MAFI
        $this->_nextIdx();

        return $blRet;
    }


    protected function _save( oxERPType $oType, $aData, $blAllowCustomShopId = false)
    {
        $myConfig = oxConfig::getInstance();

        // check rights
        $this->_checkAccess( $oType, true, $aData['OXID'] );

        if ( $oType->hasKeyFields() && !isset($aData['OXID'] ) ) {
            $sOXID = $this->_getKeyID($oType, $aData);
            if ( $sOXID ) {
                $aData['OXID'] = $sOXID;
            } else {
                $aData['OXID'] = oxUtilsObject::getInstance()->generateUID();
            }
        }

        return $oType->saveObject($aData, $blAllowCustomShopId);
    }

    public static function getRequestedVersion()
    {
        if (!self::$_sRequestedVersion && isset($_GET['version'])) {
            self::$_sRequestedVersion = $_GET['version'];
        }
        if (!isset(self::$_aDbLayer2ShopDbVersions[self::$_sRequestedVersion])) {
            self::$_sRequestedVersion = '';
        }
        if (!self::$_sRequestedVersion) {
            reset(self::$_aDbLayer2ShopDbVersions);
            self::$_sRequestedVersion = key(self::$_aDbLayer2ShopDbVersions);
        }
        return self::$_sRequestedVersion;
    }

    public static function getUsedDbFieldsVersion()
    {
        return self::$_aDbLayer2ShopDbVersions[self::getRequestedVersion()];
    }

    public static function setVersion( $sDbLayerVersion = '' )
    {
        self::$_sRequestedVersion = $sDbLayerVersion;
    }
}


// the following statements and class is just for pretending some error messages in oxconfig
if ( !class_exists( 'FakeView' ) ) {
    class FakeView
    {
        public function addGlobalParams()
        {
        }
    }
}

---