oxdelivery.php

Go to the documentation of this file.

<?php

class oxDelivery extends oxI18n
{

    const CALCULATION_RULE_ONCE_PER_CART = 0;
    const CALCULATION_RULE_FOR_EACH_DIFFERENT_PRODUCT = 1;
    const CALCULATION_RULE_FOR_EACH_PRODUCT = 2;

    const CONDITION_TYPE_PRICE = 'p';
    const CONDITION_TYPE_AMOUNT = 'a';
    const CONDITION_TYPE_SIZE = 's';
    const CONDITION_TYPE_WEIGHT = 'w';

    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;

    protected $_aCountriesISO = null;

    protected $_aRDFaDeliverySet = null;

    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 (is_null($this->_aArtIds)) {
            $oDb = oxDb::getDb();
            $sQ = "select oxobjectid from oxobject2delivery where oxdeliveryid=" . $oDb->quote($this->getId()) . " and oxtype = 'oxarticles'";
            $aArtIds = $oDb->getCol($sQ);
            $this->_aArtIds = $aArtIds;
        }

        return $this->_aArtIds;
    }

    public function getCategories()
    {
        if (is_null($this->_aCatIds)) {
            $oDb = oxDb::getDb();
            $sQ = "select oxobjectid from oxobject2delivery where oxdeliveryid=" . $oDb->quote($this->getId()) . " and oxtype = 'oxcategories'";
            $aCatIds = $oDb->getCol($sQ);
            $this->_aCatIds = $aCatIds;
        }

        return $this->_aCatIds;
    }

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

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

    public function getDeliveryAmount($oBasketItem)
    {
        $dAmount = 0;
        $oProduct = $oBasketItem->getArticle(false);

        if ($oProduct->isOrderArticle()) {
            $oProduct = $oProduct->getArticle();
        }

        $blExclNonMaterial = $this->getConfig()->getConfigParam('blExclNonMaterialFromDelivery');

        // mark free shipping products
        if ($oProduct->oxarticles__oxfreeshipping->value || ($oProduct->oxarticles__oxnonmaterial->value && $blExclNonMaterial)) {
            if ($this->_blFreeShipping !== false) {
                $this->_blFreeShipping = true;
            }
        } else {

            $this->_blFreeShipping = false;

            switch ($this->getConditionType()) {
                case self::CONDITION_TYPE_PRICE: // price
                    if ($this->getCalculationRule() == self::CALCULATION_RULE_FOR_EACH_PRODUCT) {
                        $dAmount += $oProduct->getPrice()->getPrice();
                    } else {
                        $dAmount += $oBasketItem->getPrice()->getPrice(); // price// currency conversion must allready be done in price class / $oCur->rate; // $oBasketItem->oPrice->getPrice() / $oCur->rate;
                    }
                    break;
                case self::CONDITION_TYPE_WEIGHT: // weight
                    if ($this->getCalculationRule() == self::CALCULATION_RULE_FOR_EACH_PRODUCT) {
                        $dAmount += $oProduct->getWeight();
                    } else {
                        $dAmount += $oBasketItem->getWeight();
                    }
                    break;
                case self::CONDITION_TYPE_SIZE: // size
                    $dAmount += $oProduct->getSize();
                    if ($this->getCalculationRule() != self::CALCULATION_RULE_FOR_EACH_PRODUCT) {
                        $dAmount *= $oBasketItem->getAmount();
                    }
                    break;
                case self::CONDITION_TYPE_AMOUNT: // amount
                    $dAmount += $oBasketItem->getAmount();
                    break;
            }

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

        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
            $oPrice = oxNew('oxPrice');
            $oPrice->setNettoMode($this->_blDelVatOnTop);
            $oPrice->setVat($dVat);

            // if article is free shipping, price for delivery will be not calculated
            if (!$this->_blFreeShipping) {
                $oPrice->add($this->_getCostSum());
            }
            $this->setDeliveryPrice($oPrice);
        }

        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->hasArticles();
        $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->getParentId();

                if ($blHasArticles && (in_array($sProductId, $aDeliveryArticles) || ($sParentId && in_array($sParentId, $aDeliveryArticles)))) {
                    $blUse = true;
                    $iArtAmount = $this->getDeliveryAmount($oContent);
                    if ($this->getCalculationRule() != self::CALCULATION_RULE_ONCE_PER_CART) {
                        if ($this->_isForArticle($oContent, $iArtAmount)) {
                            $blForBasket = true;
                        }
                    }
                    if (!$blForBasket) {
                        $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->getCalculationRule() != self::CALCULATION_RULE_ONCE_PER_CART) {
                                if ($this->_isForArticle($oContent, $iArtAmount)) {
                                    $blForBasket = true;
                                }
                            }
                            if (!$blForBasket) {
                                $iAmount += $iArtAmount;
                            }
                            //HR#5650 product might be in multiple rule categories, counting it once is enough
                            break;
                        }
                    }

                }
            }
        } else {
            // regular amounts check
            foreach ($oBasket->getContents() as $oContent) {
                $iArtAmount = $this->getDeliveryAmount($oContent);
                if ($this->getCalculationRule() != self::CALCULATION_RULE_ONCE_PER_CART) {
                    if ($this->_isForArticle($oContent, $iArtAmount)) {
                        $blForBasket = true;
                    }
                }
                if (!$blForBasket) {
                    $iAmount += $iArtAmount;
                }
            }
        }

        /* if ( $this->getConditionType() == self::CONDITION_TYPE_PRICE ) {
             $iAmount = $oBasket->_getDiscountedProductsSum();
         }*/

        //#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)
    {
        $blResult = false;
        if (!$this->_blFreeShipping && $this->_checkDeliveryAmount($iArtAmount)) {
            $this->_iItemCnt += $oContent->getAmount();
            $this->_iProdCnt += 1;
            $blResult = true;
        }

        return $blResult;
    }

    protected function _checkDeliveryAmount($iAmount)
    {
        $blResult = false;

        if ($this->getConditionType() == self::CONDITION_TYPE_PRICE) {
            $oCur = $this->getConfig()->getActShopCurrencyObject();
            $iAmount /= $oCur->rate;
        }

        if ($iAmount >= $this->getConditionFrom() && $iAmount <= $this->getConditionTo()) {
            $blResult = true;
        }

        return $blResult;
    }

    public function getIdByName($sTitle)
    {
        $oDb = oxDb::getDb();
        $sQ = "SELECT `oxid` FROM `" . getViewName('oxdelivery') . "` WHERE `oxtitle` = " . $oDb->quote($sTitle);
        $sId = $oDb->getOne($sQ);

        return $sId;
    }

    public function getCountriesISO()
    {
        if ($this->_aCountriesISO === null) {

            $oDb = oxDb::getDb();
            $this->_aCountriesISO = array();

            $sSelect = "
                SELECT
                    `oxcountry`.`oxisoalpha2`
                FROM `oxcountry`
                    LEFT JOIN `oxobject2delivery` ON `oxobject2delivery`.`oxobjectid` = `oxcountry`.`oxid`
                WHERE `oxobject2delivery`.`oxdeliveryid` = " . $oDb->quote($this->getId()) . "
                    AND `oxobject2delivery`.`oxtype` = 'oxcountry'";

            $rs = $oDb->getCol($sSelect);
            $this->_aCountriesISO = $rs;

        }

        return $this->_aCountriesISO;
    }

    public function getConditionType()
    {
        return $this->oxdelivery__oxdeltype->value;
    }

    public function getConditionFrom()
    {
        return $this->oxdelivery__oxparam->value;
    }

    public function getConditionTo()
    {
        return $this->oxdelivery__oxparamend->value;
    }

    public function getCalculationRule()
    {
        return $this->oxdelivery__oxfixed->value;
    }

    public function getAddSum()
    {
        return $this->oxdelivery__oxaddsum->value;
    }

    public function getAddSumType()
    {
        return $this->oxdelivery__oxaddsumtype->value;
    }

    protected function _getMultiplier()
    {
        $dAmount = 0;

        if ($this->getCalculationRule() == self::CALCULATION_RULE_ONCE_PER_CART) {
            $dAmount = 1;
        } elseif ($this->getCalculationRule() == self::CALCULATION_RULE_FOR_EACH_DIFFERENT_PRODUCT) {
            $dAmount = $this->_iProdCnt;
        } elseif ($this->getCalculationRule() == self::CALCULATION_RULE_FOR_EACH_PRODUCT) {
            $dAmount = $this->_iItemCnt;
        }

        return $dAmount;
    }

    protected function _getCostSum()
    {
        if ($this->getAddSumType() == 'abs') {
            $oCur = $this->getConfig()->getActShopCurrencyObject();
            $dPrice = $this->getAddSum() * $oCur->rate * $this->_getMultiplier();
        } else {
            $dPrice = $this->_dPrice / 100 * $this->getAddSum();
        }

        return $dPrice;
    }
}