oxerpbase.php

Go to the documentation of this file.

<?php

abstract class oxERPBase
{
    const ERROR_USER_WRONG                        = "ERROR: Could not login";
    const ERROR_USER_NO_RIGHTS                    = "Not sufficient rights to perform operation!";
    const ERROR_USER_EXISTS                       = "ERROR: User already exists";
    const ERROR_NO_INIT                           = "Init not executed, Access denied!";
    const ERROR_DELETE_NO_EMPTY_CATEGORY          = "Only empty category can be deleated";
    const ERROR_OBJECT_NOT_EXISTING               = "Object does not exist";
    const ERROR_ERP_VERSION_NOT_SUPPORTED_BY_SHOP = "ERROR: shop does not support requested ERP version.";
    const ERROR_SHOP_VERSION_NOT_SUPPORTED_BY_ERP = "ERROR: ERP does not support current shop version.";

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

    protected   $_blInit    = false;
    protected   $_iLanguage = null;
    protected   $_sUserID   = null;
    //session id
    protected   $_sSID      = null;

    protected static $_sRequestedVersion = '';

    protected static $_aDbLayer2ShopDbVersions = array(
        '2.9.0' => '8', // added new fields to oxcategories, oxorderarticle
    );

    protected $_aImportedIds = array();

    protected $_iImportedRowCount = 0;

    public $_aStatistics = array();
    public $_iIdx        = 0;

    public abstract function getImportedRowCount();

    public abstract function setImportedIds( $key );
    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($iIdx = null);

    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)
    {
        ini_set('session.use_cookies', 0);
        $_COOKIE = array('admin_sid' => false);
        $myConfig = oxRegistry::getConfig();
        $myConfig->setConfigParam( 'blForceSessionStart', 1 );
        $myConfig->setConfigParam( 'blSessionUseCookies', 0);
        $myConfig->setConfigParam( 'blAdmin', 1 );
        $myConfig->setAdminMode( true );

        $mySession = oxRegistry::getSession();
        @$mySession->start();


        oxSession::setVar( "lang", $iLanguage);
        oxSession::setVar( "language", $iLanguage);

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

        self::_checkShopVersion();

        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 function loadSessionData( $sSessionID )
    {
        if (!$sSessionID) {
            throw new Exception( "ERROR: Session ID not valid!");
        }
        $_COOKIE = array('admin_sid' => $sSessionID);
        // start session
        $myConfig = oxRegistry::getConfig();
        $myConfig->setConfigParam( 'blAdmin', 1 );
        $myConfig->setAdminMode( true );
        $mySession = oxRegistry::getSession();

        // change session if needed
        if ($sSessionID != session_id()) {
            if (session_id()) {
                session_write_close();
            }
            session_id($sSessionID);
            session_start();
        }

        $sAuth = $mySession->getVar('auth');

        if (!isset($sAuth) || !$sAuth) {
            throw new Exception( "ERROR: Session ID not valid!");
        }

        $this->_iLanguage   = $mySession->getVar('lang');
        $this->_sUserID     = $sAuth;


        $this->_blInit      = true;
    }

    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!");
        }

        include_once $sFullPath;

        //return new $sClassName;
        return oxNew ($sClassName);
    }

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

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

        $save = $ADODB_FETCH_MODE;

        $oDb = oxDb::getDb( oxDb::FETCH_MODE_ASSOC );
        if (isset($iCount) || isset($iStart)) {
            $rs = $oDb->selectLimit( $sSQL, $iCount, $iStart );
        } else {
            $rs = $oDb->select( $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)
    {
        $sOXID = $oType->getOxidFromKeyFields($aData);
        if (isset($sOXID)) {
            // note: also pass false here
            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 = oxRegistry::getConfig();
        static $aAccessCache;

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

    }

    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 {
                $iId = $this->$sFnc($oType, $aData);
                if ( !$iId )
                    $blImport = false;
                else {
                    $this->setImportedIds( $iId );
                    $blImport = true;
                }
                $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 = oxRegistry::getConfig();

        // check rights
        $sOxid = null;
        if (isset($aData['OXID'])) {
            $sOxid = $aData['OXID'];
        }
        $this->_checkAccess($oType, true, $sOxid);

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

    protected static function _checkShopVersion()
    {
        $myConfig = oxRegistry::getConfig();
        if ( method_exists($myConfig, 'getSerial') ) {
            if ($myConfig->getSerial() instanceof oxSerial) {
                return;
            }
        }
        throw new Exception(self::ERROR_SHOP_VERSION_NOT_SUPPORTED_BY_ERP);
    }

    protected static function _checkRequestedVersion()
    {
        return true;
    }

    public static function getRequestedVersion()
    {
        if (!self::$_sRequestedVersion) {
            self::setVersion();
        }
        return self::$_sRequestedVersion;
    }

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

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

    public function createPluginObject($sId)
    {
        $sClassName = preg_replace('/[^a-z0-9_]/i', '', $sId);
        if (preg_match('/(.*)Plugin$/i', $sClassName, $m)) {
            // fix possible case changes
            $sClassName = $m[1].'Plugin';
        } else {
            throw new Exception("Plugin handler class has to end with 'Plugin' word (GOT '$sClassName').");
        }

        $sFileName = dirname(__FILE__).'/plugins/'.strtolower($sClassName).'.php';
        if (!is_readable($sFileName)) {
            $sFileName = basename($sFileName);
            throw new Exception("Can not find the requested plugin file ('$sFileName').");
        }
        include_once dirname(__FILE__).'/plugins/oxerppluginbase.php';
        include_once $sFileName;
        if (!class_exists($sClassName)) {
            throw new Exception("Can not find the requested plugin class.");
        }
        $o = new $sClassName();
        if ($o instanceof oxErpPluginBase) {
            return $o;
        }
        throw new Exception("Plugin does not extend oxErpPluginBase class.");
    }
}