oxbasketreservation.php

Go to the documentation of this file.

<?php

class oxBasketReservation extends oxSuperCfg
{
    protected $_oReservations = null;

    protected $_aCurrentlyReserved = null;

    protected function _getReservationsId()
    {
        $sId = oxSession::getVar('basketReservationToken');
        if (!$sId) {
            $sId = oxUtilsObject::getInstance()->generateUId();
            oxSession::setVar( 'basketReservationToken', $sId );
        }
        return $sId;
    }

    protected function _loadReservations($sBasketId)
    {
        $oReservations = oxNew( 'oxuserbasket' );
        $aWhere = array( 'oxuserbaskets.oxuserid' => $sBasketId, 'oxuserbaskets.oxtitle' => 'reservations' );

        // creating if it does not exist
        if ( !$oReservations->assignRecord( $oReservations->buildSelectString( $aWhere ) ) ) {
            $oReservations->oxuserbaskets__oxtitle  = new oxField('reservations');
            $oReservations->oxuserbaskets__oxuserid = new oxField($sBasketId);
            // marking basket as new (it will not be saved in DB yet)
            $oReservations->setIsNewBasket();
        }
        return $oReservations;
    }

    public function getReservations()
    {
        if ($this->_oReservations) {
            return $this->_oReservations;
        }

        if (!$sBasketId = $this->_getReservationsId()) {
            return null;
        }

        $this->_oReservations = $this->_loadReservations($sBasketId);

        return $this->_oReservations;
    }

    protected function _getReservedItems()
    {
        if (isset($this->_aCurrentlyReserved)) {
            return $this->_aCurrentlyReserved;
        }

        $oReserved = $this->getReservations();
        if (!$oReserved) {
            return array();
        }

        $this->_aCurrentlyReserved = array();
        foreach ( $oReserved->getItems(false, false) as $oItem ) {
            if (!isset($this->_aCurrentlyReserved[$oItem->oxuserbasketitems__oxartid->value])) {
                $this->_aCurrentlyReserved[$oItem->oxuserbasketitems__oxartid->value] = 0;
            }
            $this->_aCurrentlyReserved[$oItem->oxuserbasketitems__oxartid->value] += $oItem->oxuserbasketitems__oxamount->value;
        }
        return $this->_aCurrentlyReserved;
    }

    public function getReservedAmount($sArticleId)
    {
        $aCurrentlyReserved = $this->_getReservedItems();
        if (isset($aCurrentlyReserved[$sArticleId])) {
            return $aCurrentlyReserved[$sArticleId];
        }
        return 0;
    }

    protected function _basketDifference(oxBasket $oBasket)
    {
        $aDiff = $this->_getReservedItems();
        // refreshing history
        foreach ( $oBasket->getContents() as $oItem ) {
            $sProdId = $oItem->getProductId();
            if (!isset($aDiff[$sProdId])) {
                $aDiff[$sProdId] = -$oItem->getAmount();
            } else {
                $aDiff[$sProdId] -= $oItem->getAmount();
            }
        }
        return $aDiff;
    }

    protected function _reserveArticles($aBasketDiff)
    {
        $blAllowNegativeStock = $this->getConfig()->getConfigParam( 'blAllowNegativeStock' );
        $oDb = oxDb::getDb();

        $oReserved = $this->getReservations();
        foreach ($aBasketDiff as $sId => $dAmount) {
            if ($dAmount != 0) {
                $oArticle = oxNew('oxarticle');
                if ($oArticle->load($sId)) {
                    $oArticle->reduceStock(-$dAmount, $blAllowNegativeStock);
                    $oReserved->addItemToBasket( $sId, -$dAmount );
                }
            }
        }
        $this->_aCurrentlyReserved = null;
    }

    public function reserveBasket(oxBasket $oBasket)
    {
        $this->_reserveArticles( $this->_basketDifference($oBasket) );
    }

    public function commitArticleReservation($sArticleId, $dAmount)
    {
        $dReserved = $this->getReservedAmount($sArticleId);

        if ($dReserved < $dAmount) {
            $dAmount = $dReserved;
        }

        $oArticle = oxNew( 'oxarticle' );
        $oArticle->load( $sArticleId );

        $this->getReservations()->addItemToBasket($sArticleId, -$dAmount);
        $oArticle->beforeUpdate();
        $oArticle->updateSoldAmount( $dAmount );
        $this->_aCurrentlyReserved = null;
    }

    public function discardArticleReservation($sArticleId)
    {
        $dReserved = $this->getReservedAmount($sArticleId);
        if ($dReserved) {
            $oArticle = oxNew('oxarticle');
            if ($oArticle->load($sArticleId)) {
                $oArticle->reduceStock(-$dReserved, true);
                $this->getReservations()->addItemToBasket($sArticleId, 0, null, true);
                $this->_aCurrentlyReserved = null;
            }
        }
    }

    public function discardReservations()
    {
        foreach ( array_keys($this->_getReservedItems()) as $sArticleId) {
            $this->discardArticleReservation($sArticleId);
        }
        if ($this->_oReservations) {
            $this->_oReservations->delete();
            $this->_oReservations = null;
            $this->_aCurrentlyReserved = null;
        }
    }

    public function discardUnusedReservations($iLimit)
    {
        $oDb = oxDb::getDb(true);
        $iStartTime = oxUtilsDate::getInstance()->getTime() - (int) $this->getConfig()->getConfigParam( 'iPsBasketReservationTimeout' );
        $oRs = $oDb->execute("select oxid from oxuserbaskets where oxtitle = 'reservations' and oxupdate <= $iStartTime limit $iLimit");
        if ($oRs->EOF) {
            return;
        }
        $aFinished = array();
        while (!$oRs->EOF) {
            $aFinished[] = $oDb->quote($oRs->fields['oxid']);
            $oRs->MoveNext();
        }
        $oRs = $oDb->execute("select oxartid, oxamount from oxuserbasketitems where oxbasketid in (".implode(",", $aFinished).")");
        while (!$oRs->EOF) {
            $oArticle = oxNew('oxarticle');
            if ($oArticle->load($oRs->fields['oxartid'])) {
                $oArticle->reduceStock(-$oRs->fields['oxamount'], true);
            }
            $oRs->MoveNext();
        }
        $oDb->execute("delete from oxuserbasketitems where oxbasketid in (".implode(",", $aFinished).")");
        $oDb->execute("delete from oxuserbaskets where oxid in (".implode(",", $aFinished).")");

        // cleanup basket history also..
        $oDb->execute("delete from oxuserbaskets where oxtitle = 'savedbasket' and oxupdate <= $iStartTime");

        $this->_aCurrentlyReserved = null;
    }

    public function getTimeLeft()
    {
        $iTimeout = $this->getConfig()->getConfigParam( 'iPsBasketReservationTimeout' );
        if ( $iTimeout > 0 ) {
            $oRev = $this->getReservations();
            if ( $oRev && $oRev->getId() ) {
                $iTimeout -= ( oxUtilsDate::getInstance()->getTime() - (int) $oRev->oxuserbaskets__oxupdate->value );
                oxSession::setVar( "iBasketReservationTimeout", $oRev->oxuserbaskets__oxupdate->value );
            } elseif ( ( $iSessionTimeout = oxSession::getVar( "iBasketReservationTimeout" ) ) ) {
                $iTimeout -= ( oxUtilsDate::getInstance()->getTime() - (int) $iSessionTimeout );
            }

            return $iTimeout < 0 ? 0 : $iTimeout;
        }
        return 0;
    }

    public function renewExpiration()
    {
        if ($oReserved = $this->getReservations()) {
            $iTime = oxUtilsDate::getInstance()->getTime();
            $oReserved->oxuserbaskets__oxupdate = new oxField( $iTime );
            $oReserved->save();

            oxSession::deleteVar( "iBasketReservationTimeout" );
        }
    }
}