oxprice.php

Go to the documentation of this file.

<?php

class oxPrice
{

    protected $_dBrutto = 0.0;

    protected $_dNetto = 0.0;

    protected $_dVat = 0.0;


    protected $_aDiscounts = null;


    protected $_blNetPriceMode;

    public function __construct($dPrice = null)
    {
        $this->setNettoMode(oxRegistry::getConfig()->getConfigParam('blEnterNetPrice'));

        if (!is_null($dPrice)) {
            $this->setPrice($dPrice);
        }
    }

    public function setNettoMode($blNetto = true)
    {
        $this->_blNetPriceMode = $blNetto;
    }

    public function isNettoMode()
    {
        return $this->_blNetPriceMode;
    }

    public function setNettoPriceMode()
    {
        $this->setNettoMode();
    }

    public function setBruttoPriceMode()
    {
        $this->setNettoMode(false);
    }

    public function setVat($dVat)
    {
        $this->_dVat = (double) $dVat;
    }

    public function setUserVat($newVat)
    {
        if (!$this->isNettoMode() && $newVat != $this->_dVat) {
            $this->_dBrutto = self::Netto2Brutto(self::Brutto2Netto($this->_dBrutto, $this->_dVat), (double) $newVat);
        }
        $this->_dVat = (double) $newVat;
    }

    public function getVat()
    {
        return $this->_dVat;
    }

    public function setPrice($dPrice, $dVat = null)
    {
        if (!is_null($dVat)) {
            $this->setVat($dVat);
        }

        if ($this->isNettoMode()) {
            $this->_dNetto = $dPrice;
        } else {
            $this->_dBrutto = $dPrice;
        }
    }

    public function getPrice()
    {
        if ($this->isNettoMode()) {
            return $this->getNettoPrice();
        } else {
            return $this->getBruttoPrice();
        }
    }

    public function getBruttoPrice()
    {
        if ($this->isNettoMode()) {
            return $this->getNettoPrice() + $this->getVatValue();
        } else {
            return oxRegistry::getUtils()->fRound($this->_dBrutto);
        }
    }

    public function getNettoPrice()
    {
        if ($this->isNettoMode()) {
            return oxRegistry::getUtils()->fRound($this->_dNetto);
        } else {
            return $this->getBruttoPrice() - $this->getVatValue();
        }
    }

    public function getVatValue()
    {
        if ($this->isNettoMode()) {
            $dVatValue = $this->getNettoPrice() * $this->getVat() / 100;
        } else {
            $dVatValue = $this->getBruttoPrice() * $this->getVat() / (100 + $this->getVat());
        }

        return oxRegistry::getUtils()->fRound($dVatValue);
    }

    public function subtractPercent($dValue)
    {
        $dPrice = $this->getPrice();
        $this->setPrice($dPrice - self::percent($dPrice, $dValue));
    }

    public function addPercent($dValue)
    {
        $this->subtractPercent(-$dValue);
    }

    public function addPrice(oxPrice $oPrice)
    {
        if ($this->isNettoMode()) {
            $this->add($oPrice->getNettoPrice());
        } else {
            $this->add($oPrice->getBruttoPrice());
        }
    }

    public function add($dValue)
    {
        $dPrice = $this->getPrice();
        $this->setPrice($dPrice + $dValue);
    }

    public function subtract($dValue)
    {
        $this->add(-$dValue);
    }

    public function multiply($dValue)
    {
        $dPrice = $this->getPrice();
        $this->setPrice($dPrice * $dValue);
    }

    public function divide($dValue)
    {
        $dPrice = $this->getPrice();
        $this->setPrice($dPrice / $dValue);
    }

    public function compare(oxPrice $oPrice)
    {
        $dBruttoPrice1 = $this->getBruttoPrice();
        $dBruttoPrice2 = $oPrice->getBruttoPrice();

        if ($dBruttoPrice1 == $dBruttoPrice2) {
            $iRes = 0;
        } elseif ($dBruttoPrice1 > $dBruttoPrice2) {
            $iRes = 1;
        } else {
            $iRes = -1;
        }

        return $iRes;
    }

    public static function percent($dValue, $dPercent)
    {
        return ((double) $dValue * (double) $dPercent) / 100.0;
    }

    public static function brutto2Netto($dBrutto, $dVat)
    {
        // if VAT = -100% Return 0 because we subtract all what we have.
        // made to avoid division by zero in formula.
        if ($dVat == -100) {
            return 0;
        }

        return (double) ((double) $dBrutto * 100.0) / (100.0 + (double) $dVat);
    }

    public static function netto2Brutto($dNetto, $dVat)
    {
        return (double) $dNetto + self::percent($dNetto, $dVat);
    }

    public static function getPriceInActCurrency($dPrice)
    {
        $oCur = oxRegistry::getConfig()->getActShopCurrencyObject();

        return (( double ) $dPrice) * $oCur->rate;
    }


    public function setDiscount($dValue, $sType)
    {
        $this->_aDiscounts[] = array('value' => $dValue, 'type' => $sType);
    }

    public function getDiscounts()
    {
        return $this->_aDiscounts;
    }

    protected function _flushDiscounts()
    {
        $this->_aDiscounts = null;
    }

    public function calculateDiscount()
    {
        $dPrice = $this->getPrice();
        $aDiscounts = $this->getDiscounts();

        if ($aDiscounts) {
            foreach ($aDiscounts as $aDiscount) {

                if ($aDiscount['type'] == 'abs') {
                    $dPrice = $dPrice - $aDiscount['value'];
                } else {
                    $dPrice = $dPrice * (100 - $aDiscount['value']) / 100;
                }
            }
            if ($dPrice < 0) {
                $this->setPrice(0);
            } else {
                $this->setPrice($dPrice);
            }

            $this->_flushDiscounts();
        }
    }
}