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($dInitPrice = null)
    {
        $this->_blNetPriceMode = oxRegistry::getConfig()->getConfigParam( 'blEnterNetPrice' );

        if ($dInitPrice) {
            $this->setPrice($dInitPrice);
        }
    }

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

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

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

    public function setUserVat($newVat)
    {
        if (!$this->_blNetPriceMode && $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 (isset($dVat)) {
            $this->_dVat = (double) $dVat;
        }

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

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

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

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

    public function getVatValue()
    {
        if ( $this->_blNetPriceMode ) {
            $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->_blNetPriceMode) {
            $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);
    }

    protected function _recalculate()
    {
        if ( $this->_blNetPriceMode ) {
            $this->_dBrutto = self::netto2Brutto($this->_dNetto, $this->_dVat);
            $this->_dNetto = oxRegistry::getUtils()->fRound($this->_dNetto);
        } else {
            $this->_dNetto  = self::brutto2Netto($this->_dBrutto, $this->_dVat);
            $this->_dBrutto = oxRegistry::getUtils()->fRound($this->_dBrutto);
        }
    }

    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();
        }
    }

}