oxvoucher.php

Go to the documentation of this file.

<?php

class oxVoucher extends oxBase
{

    protected $_oSerie = null;

    protected $_blDisableShopCheck = true;

    protected $_sClassName = 'oxvoucher';

    public function __construct()
    {
        parent::__construct();
        $this->init( 'oxvouchers' );
    }

    public function getVoucherByNr( $sVoucherNr, $aVouchers = array(), $blCheckavalability = false )
    {
        $oRet = null;
        if ( !is_null( $sVoucherNr ) ) {

            $sViewName = $this->getViewName();
            $sSeriesViewName = getViewName( 'oxvoucherseries' );
            $oDb = oxDb::getDb();

            $sQ  = "select {$sViewName}.* from {$sViewName}, {$sSeriesViewName} where
                        {$sSeriesViewName}.oxid = {$sViewName}.oxvoucherserieid and
                        {$sViewName}.oxvouchernr = " . $oDb->quote( $sVoucherNr ) . " and ";

            if ( is_array( $aVouchers ) ) {
                foreach ( $aVouchers as $sVoucherId => $sSkipVoucherNr ) {
                    $sQ .= "{$sViewName}.oxid != " . $oDb->quote( $sVoucherId ) . " and ";
                }
            }
            $sQ .= "( {$sViewName}.oxorderid is NULL || {$sViewName}.oxorderid = '' ) ";
            $sQ .= " and ( {$sViewName}.oxdateused is NULL || {$sViewName}.oxdateused = 0 ) ";

            //voucher timeout for 3 hours
            if ( $blCheckavalability ) {
                $iTime = time() - $this->_getVoucherTimeout();
                $sQ .= " and {$sViewName}.oxreserved < '{$iTime}' ";
            }

            $sQ .= " limit 1";

            if ( ! ( $oRet = $this->assignRecord( $sQ ) ) ) {
                $oEx = oxNew( 'oxVoucherException' );
                $oEx->setMessage( 'ERROR_MESSAGE_VOUCHER_NOVOUCHER' );
                $oEx->setVoucherNr( $sVoucherNr );
                throw $oEx;
            }
        }

        return $oRet;
    }

    public function markAsUsed( $sOrderId, $sUserId, $dDiscount )
    {
        //saving oxreserved field
        if ( $this->oxvouchers__oxid->value ) {
            $this->oxvouchers__oxorderid->setValue($sOrderId);
            $this->oxvouchers__oxuserid->setValue($sUserId);
            $this->oxvouchers__oxdiscount->setValue($dDiscount);
            $this->oxvouchers__oxdateused->setValue(date( "Y-m-d", oxRegistry::get("oxUtilsDate")->getTime() ));
            $this->save();
        }
    }

    public function markAsReserved()
    {
        //saving oxreserved field
        $sVoucherID = $this->oxvouchers__oxid->value;

        if ( $sVoucherID ) {
            $oDb = oxDb::getDb();
            $sQ = "update oxvouchers set oxreserved = " . time() . " where oxid = " . $oDb->quote( $sVoucherID );
            $oDb->Execute( $sQ );
        }
    }

    public function unMarkAsReserved()
    {
        //saving oxreserved field
        $sVoucherID = $this->oxvouchers__oxid->value;

        if ( $sVoucherID ) {
            $oDb = oxDb::getDb();
            $sQ = "update oxvouchers set oxreserved = 0 where oxid = " . $oDb->quote( $sVoucherID );
            $oDb->Execute($sQ);
        }
    }

    public function getDiscountValue( $dPrice )
    {
        if ($this->_isProductVoucher()) {
            return $this->_getProductDiscoutValue( (double) $dPrice );
        } elseif ($this->_isCategoryVoucher()) {
            return $this->_getCategoryDiscoutValue( (double) $dPrice );
        } else {
            return $this->_getGenericDiscoutValue( (double) $dPrice );
        }
    }

    // Checking General Availability
    public function checkVoucherAvailability( $aVouchers, $dPrice )
    {
        $this->_isAvailableWithSameSeries( $aVouchers );
        $this->_isAvailableWithOtherSeries( $aVouchers );
        $this->_isValidDate();
        $this->_isAvailablePrice( $dPrice );
        $this->_isNotReserved();

        // returning true - no exception was thrown
        return true;
    }

    public function checkBasketVoucherAvailability( $aVouchers, $dPrice )
    {
        $this->_isAvailableWithSameSeries( $aVouchers );
        $this->_isAvailableWithOtherSeries( $aVouchers );
        $this->_isValidDate();
        $this->_isAvailablePrice( $dPrice );

        // returning true - no exception was thrown
        return true;
    }

    protected function _isAvailablePrice( $dPrice )
    {
        $oSeries = $this->getSerie();
        $oCur = $this->getConfig()->getActShopCurrencyObject();
        if ( $oSeries->oxvoucherseries__oxminimumvalue->value && $dPrice < ($oSeries->oxvoucherseries__oxminimumvalue->value*$oCur->rate) ) {
            $oEx = oxNew( 'oxVoucherException' );
            $oEx->setMessage('ERROR_MESSAGE_VOUCHER_INCORRECTPRICE');
            $oEx->setVoucherNr($this->oxvouchers__oxvouchernr->value);
            throw $oEx;
        }

        return true;
    }

    protected function _isAvailableWithSameSeries( $aVouchers )
    {
        if ( is_array( $aVouchers ) ) {
            $sId = $this->getId();
            if (isset($aVouchers[$sId])) {
                unset($aVouchers[$sId]);
            }
            $oSeries = $this->getSerie();
            if (!$oSeries->oxvoucherseries__oxallowsameseries->value) {
                foreach ( $aVouchers as $voucherId => $voucherNr ) {
                    $oVoucher = oxNew( 'oxVoucher' );
                    $oVoucher->load($voucherId);
                    if ( $this->oxvouchers__oxvoucherserieid->value == $oVoucher->oxvouchers__oxvoucherserieid->value ) {
                            $oEx = oxNew( 'oxVoucherException' );
                            $oEx->setMessage('ERROR_MESSAGE_VOUCHER_NOTALLOWEDSAMESERIES');
                            $oEx->setVoucherNr( $this->oxvouchers__oxvouchernr->value );
                            throw $oEx;
                    }
                }
            }
        }

        return true;
    }

    protected function _isAvailableWithOtherSeries( $aVouchers )
    {
        if ( is_array( $aVouchers ) && count($aVouchers) ) {
            $oSeries = $this->getSerie();
            $sIds = implode(',', oxDb::getInstance()->quoteArray( array_keys( $aVouchers ) ) );
            $blAvailable = true;
            $oDb = oxDb::getDb();
            if (!$oSeries->oxvoucherseries__oxallowotherseries->value) {
                // just search for vouchers with different series
                $sSql  = "select 1 from oxvouchers where oxvouchers.oxid in ($sIds) and ";
                $sSql .= "oxvouchers.oxvoucherserieid != " . $oDb->quote( $this->oxvouchers__oxvoucherserieid->value ) ;
                $blAvailable &= !$oDb->getOne($sSql);
            } else {
                // search for vouchers with different series and those vouchers do not allow other series
                $sSql  = "select 1 from oxvouchers left join oxvoucherseries on oxvouchers.oxvoucherserieid=oxvoucherseries.oxid ";
                $sSql .= "where oxvouchers.oxid in ($sIds) and oxvouchers.oxvoucherserieid != " . $oDb->quote( $this->oxvouchers__oxvoucherserieid->value );
                $sSql .= "and not oxvoucherseries.oxallowotherseries";
                $blAvailable &= !$oDb->getOne($sSql);
            }
            if ( !$blAvailable ) {
                    $oEx = oxNew( 'oxVoucherException' );
                    $oEx->setMessage('ERROR_MESSAGE_VOUCHER_NOTALLOWEDOTHERSERIES');
                    $oEx->setVoucherNr($this->oxvouchers__oxvouchernr->value);
                    throw $oEx;
            }
        }

        return true;
    }

    protected function _isValidDate()
    {
        $oSeries = $this->getSerie();

        // If date is not set will add day before and day after to check if voucher valid today.
        $iTomorrow = mktime( 0, 0, 0, date( "m" ), date( "d" )+1, date( "Y" ) );
        $iYesterday = mktime( 0, 0, 0, date( "m" ), date( "d" )-1, date( "Y" ) );

        // Checks if beginning date is set, if not set $iFrom to yesterday so it will be valid.
        $iFrom = ( (int)$oSeries->oxvoucherseries__oxbegindate->value ) ?
                   strtotime( $oSeries->oxvoucherseries__oxbegindate->value ) : $iYesterday;

        // Checks if end date is set, if no set $iTo to tomorrow so it will be valid.
        $iTo = ( (int)$oSeries->oxvoucherseries__oxenddate->value ) ?
                   strtotime( $oSeries->oxvoucherseries__oxenddate->value ) : $iTomorrow;

        if ( $iFrom < time() && $iTo > time() ) {
            return true;
        }

        $oEx = oxNew( 'oxVoucherException' );
        $oEx->setMessage('MESSAGE_COUPON_EXPIRED');
        if ( $iFrom > time() && $iTo > time() ) {
            $oEx->setMessage('ERROR_MESSAGE_VOUCHER_NOVOUCHER');
        }
        $oEx->setVoucherNr( $this->oxvouchers__oxvouchernr->value );
        throw $oEx;
    }

    protected function _isNotReserved()
    {

        if ( $this->oxvouchers__oxreserved->value < time() - $this->_getVoucherTimeout() ) {
            return true;
        }

        $oEx = oxNew( 'oxVoucherException' );
        $oEx->setMessage('EXCEPTION_VOUCHER_ISRESERVED');
        $oEx->setVoucherNr( $this->oxvouchers__oxvouchernr->value );
        throw $oEx;
    }

    // Checking User Availability
    public function checkUserAvailability( $oUser )
    {

        $this->_isAvailableInOtherOrder( $oUser );
        $this->_isValidUserGroup( $oUser );

        // returning true if no exception was thrown
        return true;
    }

    protected function _isAvailableInOtherOrder( $oUser )
    {
        $oSeries = $this->getSerie();
        if ( !$oSeries->oxvoucherseries__oxallowuseanother->value ) {

            $oDb = oxDb::getDb();
            $sSelect  = 'select count(*) from '.$this->getViewName().' where oxuserid = '. $oDb->quote( $oUser->oxuser__oxid->value ) . ' and ';
            $sSelect .= 'oxvoucherserieid = ' . $oDb->quote( $this->oxvouchers__oxvoucherserieid->value ) . ' and ';
            $sSelect .= '((oxorderid is not NULL and oxorderid != "") or (oxdateused is not NULL and oxdateused != 0)) ';

            if ( $oDb->getOne( $sSelect )) {
                $oEx = oxNew( 'oxVoucherException' );
                $oEx->setMessage('ERROR_MESSAGE_VOUCHER_NOTALLOWEDSAMESERIES');
                $oEx->setVoucherNr($this->oxvouchers__oxvouchernr->value);
                throw $oEx;
            }
        }

        return true;
    }

    protected function _isValidUserGroup( $oUser )
    {
        $oVoucherSeries = $this->getSerie();
        $oUserGroups = $oVoucherSeries->setUserGroups();

        if ( !$oUserGroups->count() ) {
            return true;
        }

        if ( $oUser ) {
            foreach ( $oUserGroups as $oGroup ) {
                if ( $oUser->inGroup( $oGroup->getId() ) ) {
                    return true;
                }
            }
        }

        $oEx = oxNew( 'oxVoucherException' );
        $oEx->setMessage( 'ERROR_MESSAGE_VOUCHER_NOTVALIDUSERGROUP' );
        $oEx->setVoucherNr( $this->oxvouchers__oxvouchernr->value );
        throw $oEx;
    }

    public function getSimpleVoucher()
    {
        $oVoucher = new stdClass();
        $oVoucher->sVoucherId = $this->getId();
        $oVoucher->sVoucherNr = $this->oxvouchers__oxvouchernr->value;
        // R. set in oxBasket : $oVoucher->fVoucherdiscount = oxRegistry::getLang()->formatCurrency( $this->oxvouchers__oxdiscount->value );

        return $oVoucher;
    }

    public function getSerie()
    {
        if ($this->_oSerie !== null) {
            return $this->_oSerie;
        }
        $oSeries = oxNew('oxVoucherSerie');
        if (!$oSeries->load($this->oxvouchers__oxvoucherserieid->value)) {
            throw oxNew( "oxObjectException" );
        }
        $this->_oSerie = $oSeries;
        return $oSeries;
    }

    protected function _isProductVoucher()
    {
        $oDb    = oxDb::getDb();
        $oSeries  = $this->getSerie();
        $sSelect = "select 1 from oxobject2discount where oxdiscountid = ".$oDb->quote( $oSeries->getId() )." and oxtype = 'oxarticles'";
        $blOk    = ( bool ) $oDb->getOne( $sSelect );

        return $blOk;
    }

    protected function _isCategoryVoucher()
    {
        $oDb    = oxDb::getDb();
        $oSeries  = $this->getSerie();
        $sSelect = "select 1 from oxobject2discount where oxdiscountid = ". $oDb->quote( $oSeries->getId() )." and oxtype = 'oxcategories'";
        $blOk    = ( bool ) $oDb->getOne( $sSelect );

        return $blOk;
    }

    protected function _getSerieDiscount( )
    {
        $oSeries    = $this->getSerie();
        $oDiscount = oxNew('oxDiscount');

        $oDiscount->setId($oSeries->getId());
        $oDiscount->oxdiscount__oxshopid      = new oxField($oSeries->oxvoucherseries__oxshopid->value);
        $oDiscount->oxdiscount__oxactive      = new oxField(true);
        $oDiscount->oxdiscount__oxactivefrom  = new oxField($oSeries->oxvoucherseries__oxbegindate->value);
        $oDiscount->oxdiscount__oxactiveto    = new oxField($oSeries->oxvoucherseries__oxenddate->value);
        $oDiscount->oxdiscount__oxtitle       = new oxField($oSeries->oxvoucherseries__oxserienr->value);
        $oDiscount->oxdiscount__oxamount      = new oxField(1);
        $oDiscount->oxdiscount__oxamountto    = new oxField(MAX_64BIT_INTEGER);
        $oDiscount->oxdiscount__oxprice       = new oxField(0);
        $oDiscount->oxdiscount__oxpriceto     = new oxField(MAX_64BIT_INTEGER);
        $oDiscount->oxdiscount__oxaddsumtype  = new oxField($oSeries->oxvoucherseries__oxdiscounttype->value=='percent'?'%':'abs');
        $oDiscount->oxdiscount__oxaddsum      = new oxField($oSeries->oxvoucherseries__oxdiscount->value);
        $oDiscount->oxdiscount__oxitmartid    = new oxField();
        $oDiscount->oxdiscount__oxitmamount   = new oxField();
        $oDiscount->oxdiscount__oxitmmultiple = new oxField();

        return $oDiscount;
    }

    protected function _getBasketItems($oDiscount = null)
    {
        if ($this->oxvouchers__oxorderid->value) {
            return $this->_getOrderBasketItems($oDiscount);
        } elseif ( $this->getSession()->getBasket() ) {
            return $this->_getSessionBasketItems($oDiscount);
        } else {
            return array();
        }
    }

    protected function _getOrderBasketItems($oDiscount = null)
    {
        if (is_null($oDiscount)) {
            $oDiscount = $this->_getSerieDiscount();
        }

        $oOrder = oxNew('oxOrder');
        $oOrder->load($this->oxvouchers__oxorderid->value);

        $aItems  = array();
        $iCount  = 0;

        foreach ( $oOrder->getOrderArticles(true) as $oOrderArticle ) {
            if (!$oOrderArticle->skipDiscounts() && $oDiscount->isForBasketItem($oOrderArticle)) {
                $aItems[$iCount] = array(
                    'oxid'     => $oOrderArticle->getProductId(),
                    'price'    => $oOrderArticle->oxorderarticles__oxbprice->value,
                    'discount' => $oDiscount->getAbsValue($oOrderArticle->oxorderarticles__oxbprice->value),
                    'amount'   => $oOrderArticle->oxorderarticles__oxamount->value,
                );
                $iCount ++;
            }
        }

        return $aItems;
    }

    protected function _getSessionBasketItems($oDiscount = null)
    {
        if (is_null($oDiscount)) {
            $oDiscount = $this->_getSerieDiscount();
        }

        $oBasket = $this->getSession()->getBasket();
        $aItems  = array();
        $iCount  = 0;

        foreach ( $oBasket->getContents() as $oBasketItem ) {
            if ( !$oBasketItem->isDiscountArticle() && ( $oArticle = $oBasketItem->getArticle() ) && !$oArticle->skipDiscounts() && $oDiscount->isForBasketItem($oArticle) ) {

                $aItems[$iCount] = array(
                    'oxid'     => $oArticle->getId(),
                    'price'    => $oArticle->getBasketPrice( $oBasketItem->getAmount(), $oBasketItem->getSelList(), $oBasket )->getPrice(),
                    'discount' => $oDiscount->getAbsValue($oArticle->getBasketPrice( $oBasketItem->getAmount(), $oBasketItem->getSelList(), $oBasket )->getPrice()),
                    'amount'   => $oBasketItem->getAmount(),
                );

                $iCount ++;
            }
        }

        return $aItems;
    }

    protected function _getGenericDiscoutValue( $dPrice )
    {
        $oSeries = $this->getSerie();
        if ( $oSeries->oxvoucherseries__oxdiscounttype->value == 'absolute' ) {
            $oCur = $this->getConfig()->getActShopCurrencyObject();
            $dDiscount = $oSeries->oxvoucherseries__oxdiscount->value * $oCur->rate;
        } else {
            $dDiscount = $oSeries->oxvoucherseries__oxdiscount->value / 100 * $dPrice;
        }

        if ( $dDiscount > $dPrice ) {
            $dDiscount = $dPrice;
        }

        return $dDiscount;
    }


    public function getDiscount()
    {
        $oSeries = $this->getSerie();
        return $oSeries->oxvoucherseries__oxdiscount->value;
    }

    public function getDiscountType()
    {
        $oSeries = $this->getSerie();
        return $oSeries->oxvoucherseries__oxdiscounttype->value;
    }


    protected function _getProductDiscoutValue( $dPrice )
    {
        $oDiscount    = $this->_getSerieDiscount();
        $aBasketItems = $this->_getBasketItems($oDiscount);

        // Basket Item Count and isAdmin check (unble to access property $oOrder->_getOrderBasket()->_blSkipVouchersAvailabilityChecking)
        if (!count($aBasketItems) && !$this->isAdmin() ) {
            $oEx = oxNew( 'oxVoucherException' );
            $oEx->setMessage('ERROR_MESSAGE_VOUCHER_NOVOUCHER');
            $oEx->setVoucherNr($this->oxvouchers__oxvouchernr->value);
            throw $oEx;
        }

        $oSeries    = $this->getSerie();

        $oVoucherPrice  = oxNew('oxPrice');
        $oDiscountPrice = oxNew('oxPrice');
        $oProductPrice  = oxNew('oxPrice');
        $oProductTotal  = oxNew('oxPrice');

        // Is the voucher discount applied to at least one basket item
        $blDiscountApplied = false;

        foreach ( $aBasketItems as $aBasketItem ) {

            // If discount was already applied for the voucher to at least one basket items, then break
            if ( $blDiscountApplied and !empty( $oSeries->oxvoucherseries__oxcalculateonce->value ) ) {
                break;
            }

            $oDiscountPrice->setPrice($aBasketItem['discount']);
            $oProductPrice->setPrice($aBasketItem['price']);

            // Individual voucher is not multiplied by article amount
            if (!$oSeries->oxvoucherseries__oxcalculateonce->value) {
                $oDiscountPrice->multiply($aBasketItem['amount']);
                $oProductPrice->multiply($aBasketItem['amount']);
            }

            $oVoucherPrice->add($oDiscountPrice->getBruttoPrice());
            $oProductTotal->add($oProductPrice->getBruttoPrice());

            if ( !empty( $aBasketItem['discount'] ) ) {
                $blDiscountApplied = true;
            }
        }

        $dVoucher = $oVoucherPrice->getBruttoPrice();
        $dProduct = $oProductTotal->getBruttoPrice();

        if ( $dVoucher > $dProduct ) {
            return $dProduct;
        }

        return $dVoucher;
    }

    protected function _getCategoryDiscoutValue( $dPrice )
    {
        $oDiscount    = $this->_getSerieDiscount();
        $aBasketItems = $this->_getBasketItems( $oDiscount );

        // Basket Item Count and isAdmin check (unable to access property $oOrder->_getOrderBasket()->_blSkipVouchersAvailabilityChecking)
        if ( !count( $aBasketItems ) && !$this->isAdmin() ) {
            $oEx = oxNew( 'oxVoucherException' );
            $oEx->setMessage('ERROR_MESSAGE_VOUCHER_NOVOUCHER');
            $oEx->setVoucherNr($this->oxvouchers__oxvouchernr->value);
            throw $oEx;
        }

        $oProductPrice = oxNew('oxPrice');
        $oProductTotal = oxNew('oxPrice');

        foreach ( $aBasketItems as $aBasketItem ) {
            $oProductPrice->setPrice( $aBasketItem['price'] );
            $oProductPrice->multiply( $aBasketItem['amount'] );
            $oProductTotal->add( $oProductPrice->getBruttoPrice() );
        }

        $dProduct = $oProductTotal->getBruttoPrice();
        $dVoucher = $oDiscount->getAbsValue( $dProduct );
        return ( $dVoucher > $dProduct ) ? $dProduct : $dVoucher;
    }

    public function __get( $sName )
    {
        switch ( $sName ) {

            // simple voucher mapping
            case 'sVoucherId':
                return $this->getId();
                break;
            case 'sVoucherNr':
                return $this->oxvouchers__oxvouchernr;
                break;
            case 'fVoucherdiscount':
                return $this->oxvouchers__oxdiscount;
                break;
        }
        return parent::__get($sName);
    }
    
    protected function _getVoucherTimeout() 
    {
        $iVoucherTimeout =  intval(oxRegistry::getConfig()->getConfigParam( 'iVoucherTimeout' )) ? 
            intval(oxRegistry::getConfig()->getConfigParam( 'iVoucherTimeout' )) : 
            3 *3600;
        return $iVoucherTimeout;
    }    
}