oxdelivery.php

Go to the documentation of this file.

<?php

class oxDelivery extends oxI18n
{
    protected $_sCoreTbl = 'oxdelivery';

    protected $_sClassName = 'oxdelivery';

    protected $_iItemCnt = 0;

    protected $_iProdCnt = 0;

    protected $_dPrice = 0;

    protected $_oPrice = null;

    protected $_aArtIds = null;

    protected $_aCatIds = null;

    protected $_blFreeShipping = true;

    protected static $_aProductList = array();

    protected $_blDelVatOnTop = false;

    public function __construct()
    {
        parent::__construct();
        $this->init( 'oxdelivery' );
        $this->setDelVatOnTop( $this->getConfig()->getConfigParam( 'blDeliveryVatOnTop' ) );
    }

    public function setDelVatOnTop( $blOnTop )
    {
        $this->_blDelVatOnTop = $blOnTop;
    }

    public function getArticles()
    {
        if ( $this->_aArtIds !== null ) {
            return $this->_aArtIds;
        }

        $sQ = 'select oxobjectid from oxobject2delivery where oxdeliveryid="'.$this->getId().'" and oxtype = "oxarticles" ';

        $aArtIds = oxDb::getDb()->getArray( $sQ );

        //make single dimension array
        foreach ( $aArtIds as $aItem ) {
            $this->_aArtIds[] = $aItem[0];
        }

        return $this->_aArtIds;

    }

    public function getCategories()
    {
        if ( $this->_aCatIds !== null ) {
            return $this->_aCatIds;
        }

        $sQ = 'select oxobjectid from oxobject2delivery where oxdeliveryid="'.$this->getId().'" and oxtype = "oxcategories" ';

        $aCatIds = oxDb::getDb()->getAll( $sQ );

        //make single dimension array
        foreach ( $aCatIds AS $aItem ) {
            $this->_aCatIds[] = $aItem[0];
        }

        return $this->_aCatIds;
    }

    public function hasArtices()
    {
        return ( bool ) count( $this->getArticles() );
    }

    public function hasCategories()
    {
        return ( bool ) count( $this->getCategories() );
    }

    public function getDeliveryAmount( $oBasketItem )
    {
        $dAmount = 0 ;

        $blExclNonMaterial = $this->getConfig()->getConfigParam( 'blExclNonMaterialFromDelivery' );
        // calculating only the price which is for non free shipping products
        $oProduct = $oBasketItem->getArticle(false);
        if ( !$oProduct->oxarticles__oxfreeshipping->value &&
              !( $oProduct->oxarticles__oxnonmaterial->value && $blExclNonMaterial ) ) {

            $this->_blFreeShipping = false;

            switch ( $this->oxdelivery__oxdeltype->value ) {
                case 'p': // price
                    if ( $this->oxdelivery__oxfixed->value == 2 ) {
                        $dAmount += $oBasketItem->getArticle()->getPrice()->getBruttoPrice();
                    } else {
                        $dAmount += $oBasketItem->getPrice()->getBruttoPrice(); // price// currency conversion must allready be done in price class / $oCur->rate; // $oBasketItem->oPrice->getPrice() / $oCur->rate;
                    }
                    break;
                case 'w': // weight
                    if ( $this->oxdelivery__oxfixed->value == 2 ) {
                        $dAmount += $oBasketItem->getArticle()->oxarticles__oxweight->value;
                    } else {
                        $dAmount += $oBasketItem->getWeight();
                    }
                    break;
                case 's': // size
                    $dAmount += $oProduct->oxarticles__oxlength->value *
                                $oProduct->oxarticles__oxwidth->value *
                                $oProduct->oxarticles__oxheight->value;
                    if ( $this->oxdelivery__oxfixed->value < 2 ) {
                        $dAmount *= $oBasketItem->getAmount();
                    }
                    break;
                case 'a': // amount
                    $dAmount += $oBasketItem->getAmount();
                    break;
            }

            $this->_dPrice   += $oBasketItem->getPrice()->getBruttoPrice();
        }

        return $dAmount;
    }

    public function setDeliveryPrice( $oPrice )
    {
        $this->_oPrice = $oPrice;
    }

    public function getDeliveryPrice( $dVat = null )
    {
        if ( $this->_oPrice === null ) {
            // loading oxprice object for final price calculation
            $this->_oPrice = oxNew( 'oxPrice' );

            if ( !$this->_blDelVatOnTop ) {
                $this->_oPrice->setBruttoPriceMode();
            } else {
                $this->_oPrice->setNettoPriceMode();
            }

            $this->_oPrice->setVat( $dVat );

            // if article is free shipping, price for delivery will be not calculated
            if ( $this->_blFreeShipping ) {
                return $this->_oPrice;
            }

            // calculating base price value
            switch ( $this->oxdelivery__oxaddsumtype->value ) {
                case 'abs':

                    $dAmount = 0;

                    if ( $this->oxdelivery__oxfixed->value == 0 ) {
                        // 1. Once per Cart
                        $dAmount = 1;
                    } elseif ( $this->oxdelivery__oxfixed->value == 1 ) {
                        // 2. Once per Product overall
                        $dAmount = $this->_iProdCnt;
                    } elseif ( $this->oxdelivery__oxfixed->value == 2 ) {
                        // 3. Once per Product in Cart
                        $dAmount = $this->_iItemCnt;
                    }

                    $oCur = $this->getConfig()->getActShopCurrencyObject();
                    $this->_oPrice->add( $this->oxdelivery__oxaddsum->value * $oCur->rate );
                    $this->_oPrice->multiply( $dAmount );
                    break;
                case '%':

                    $this->_oPrice->add( $this->_dPrice /100 * $this->oxdelivery__oxaddsum->value );
                    break;
            }
        }

        // calculating total price
        return $this->_oPrice;
    }

    public function delete( $sOXID = null )
    {
        if ( !$sOXID ) {
            $sOXID = $this->getId();
        }
        if ( !$sOXID ) {
            return false;
        }


        $oDb = oxDb::getDb();
        $sQ = "delete from oxobject2delivery where oxobject2delivery.oxdeliveryid = ".$oDb->quote($sOXID);
        $oDb->execute( $sQ );

        return parent::delete( $sOXID );
    }

    public function isForBasket( $oBasket )
    {
        // amount for conditional check
        $blHasArticles   = $this->hasArtices();
        $blHasCategories = $this->hasCategories();
        $blUse = true;
        $iAmount = 0;
        $blForBasket = false;

        // category & article check
        if ( $blHasCategories || $blHasArticles ) {
            $blUse = false;

            $aDeliveryArticles   = $this->getArticles();
            $aDeliveryCategories = $this->getCategories();

            foreach ( $oBasket->getContents() as $oContent ) {

                //V FS#1954 - load delivery for variants from parent article
                $oArticle   = $oContent->getArticle(false);
                $sProductId = $oArticle->getProductId();
                $sParentId  = $oArticle->getProductParentId();

                if ( $blHasArticles && (in_array( $sProductId, $aDeliveryArticles ) || ( $sParentId && in_array( $sParentId, $aDeliveryArticles ) ) ) ) {
                    $blUse = true;
                    $iArtAmount = $this->getDeliveryAmount( $oContent );
                    if ( $this->oxdelivery__oxfixed->value > 0 ) {
                        if ( $this->_isForArticle( $oContent, $iArtAmount ) ) {
                            $blForBasket = true;
                        }
                    } else {
                        $iAmount += $iArtAmount;
                    }

                } elseif ( $blHasCategories ) {

                    if ( isset( self::$_aProductList[$sProductId] ) ) {
                        $oProduct = self::$_aProductList[$sProductId];
                    } else {
                        $oProduct = oxNew( 'oxarticle' );
                        $oProduct->setSkipAssign( true );

                        if ( !$oProduct->load( $sProductId ) ) {
                            continue;
                        }

                        $oProduct->setId($sProductId);
                        self::$_aProductList[$sProductId] = $oProduct;
                    }

                    foreach ( $aDeliveryCategories as $sCatId ) {

                        if ( $oProduct->inCategory( $sCatId ) ) {
                            $blUse = true;

                            $iArtAmount = $this->getDeliveryAmount( $oContent );
                            if ( $this->oxdelivery__oxfixed->value > 0 ) {
                                if ( $this->_isForArticle( $oContent, $iArtAmount ) ) {
                                    $blForBasket = true;
                                }
                            } else {
                                $iAmount += $iArtAmount;
                            }

                            break;
                        }
                    }
                }
            }

        } else {
            // regular amounts check
            foreach ( $oBasket->getContents() as $oContent ) {
                $iArtAmount = $this->getDeliveryAmount( $oContent );
                if ( $this->oxdelivery__oxfixed->value > 0 ) {
                    if ( $this->_isForArticle( $oContent, $iArtAmount ) ) {
                        $blForBasket = true;
                    }
                } else {
                    $iAmount += $iArtAmount;
                }
            }
        }

        //#M1130: Single article in Basket, checked as free shipping, is not buyable (step 3 no payments found)
        if ( !$blForBasket && $blUse && ( $this->_checkDeliveryAmount($iAmount) || $this->_blFreeShipping ) ) {
            $blForBasket = true;
        }
        return $blForBasket;
    }

    protected function _isForArticle( $oContent, $iArtAmount )
    {
        if ( !$this->_blFreeShipping && $this->_checkDeliveryAmount($iArtAmount) ) {
            $this->_iItemCnt += $oContent->getAmount();
            $this->_iProdCnt += 1;
            return true;
        }
        return false;
    }

    protected function _checkDeliveryAmount($iAmount)
    {
        switch ( $this->oxdelivery__oxdeltype->value ) {
            case 'p': // price
                $oCur = $this->getConfig()->getActShopCurrencyObject();
                $iAmount /= $oCur->rate;
                break;
            case 'w': // weight
            case 's': // size
            case 'a': // amount
                break;
        }

        if ( $iAmount >= $this->oxdelivery__oxparam->value && $iAmount <= $this->oxdelivery__oxparamend->value ) {
            return true;
        }

        return false;
    }
}