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;
    //session id
    protected   $_sSID          = null;

    protected static $_sRequestedVersion = '';

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

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

    // inline
    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($Data);
    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 new $sClassName;
        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,$this->_iShopID);
        $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() {     }}
}

---