694 lines
18 KiB
PHP
694 lines
18 KiB
PHP
<?php
|
|
|
|
/**
|
|
* SOTESHOP/stDelivery
|
|
*
|
|
* Ten plik należy do aplikacji stDelivery opartej na licencji (Professional License SOTE).
|
|
* Nie zmieniaj tego pliku, jeśli chcesz korzystać z automatycznych aktualizacji oprogramowania.
|
|
* Jeśli chcesz wprowadzać swoje modyfikacje do programu, zapoznaj się z dokumentacją, jak zmieniać
|
|
* oprogramowanie bez zmiany kodu bazowego http://www.sote.pl/modifications
|
|
*
|
|
* @package stDelivery
|
|
* @subpackage libs
|
|
* @copyright SOTE (www.sote.pl)
|
|
* @license http://www.sote.pl/license/sote (Professional License SOTE)
|
|
* @version $Id: Delivery.php 10244 2011-01-13 14:26:05Z michal $
|
|
* @author Marcin Olejniczak <marcin.olejniczak@sote.pl>
|
|
*/
|
|
|
|
/**
|
|
* Subclass for representing a row from the 'st_delivery' table.
|
|
*
|
|
* @package stDelivery
|
|
* @subpackage libs
|
|
*/
|
|
class Delivery extends BaseDelivery
|
|
{
|
|
protected static $currency = null;
|
|
|
|
protected $withEuTax = true;
|
|
|
|
public function __construct()
|
|
{
|
|
if (null === self::$currency && SF_APP == 'frontend')
|
|
{
|
|
self::$currency = stCurrency::getInstance(sfContext::getInstance())->get();
|
|
}
|
|
}
|
|
|
|
public function __toString()
|
|
{
|
|
return $this->getName();
|
|
}
|
|
|
|
/**
|
|
* Sprawdza czy dostawa jest Aktywna
|
|
*
|
|
* @return bool
|
|
*/
|
|
public function getIsActive()
|
|
{
|
|
return $this->active;
|
|
}
|
|
|
|
/**
|
|
* Ustawia aktywną dostawę
|
|
*
|
|
* @param bool $active
|
|
* @return void
|
|
*/
|
|
public function setIsActive($active)
|
|
{
|
|
$this->setActive($active);
|
|
}
|
|
|
|
public function isWeekendDeliveryAvailable()
|
|
{
|
|
$date = new DateTime();
|
|
|
|
$currentDay = $date->format('N');
|
|
$currentTime = $date->format('H:i');
|
|
|
|
$from = $this->getWeekendDeliveryAvailabilityFrom();
|
|
$to = $this->getWeekendDeliveryAvailabilityTo();
|
|
|
|
if (!empty($from) && "" !== $from['day'] && ($from['day'] > $currentDay || $from['day'] == $currentDay && strtotime($from['time']) > strtotime($currentTime)))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
|
|
if (!empty($to) && "" !== $to['day'] && ($to['day'] < $currentDay || $to['day'] == $currentDay && strtotime($to['time']) < strtotime($currentTime)))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return $this->isWeekendDelivery();
|
|
}
|
|
|
|
public function getWeekendDeliveryAvailabilityFrom()
|
|
{
|
|
$params = $this->getWeekendDeliveryAvailability();
|
|
|
|
return !empty($params) && isset($params['from']) ? $params['from'] : null;
|
|
}
|
|
|
|
public function setWeekendDeliveryAvailabilityFrom($availability)
|
|
{
|
|
$params = !empty($this->getWeekendDeliveryAvailability()) ? $this->getWeekendDeliveryAvailability() : [];
|
|
|
|
$params['from'] = $availability;
|
|
|
|
$this->setWeekendDeliveryAvailability($params);
|
|
}
|
|
|
|
public function getWeekendDeliveryAvailabilityTo()
|
|
{
|
|
$params = $this->getWeekendDeliveryAvailability();
|
|
|
|
return !empty($params) && isset($params['to']) ? $params['to'] : null;
|
|
}
|
|
|
|
public function setWeekendDeliveryAvailabilityTo($availability)
|
|
{
|
|
$params = $this->getWeekendDeliveryAvailability();
|
|
|
|
$params['to'] = $availability;
|
|
|
|
$this->setWeekendDeliveryAvailability($params);
|
|
}
|
|
|
|
public function isWeekendDelivery()
|
|
{
|
|
return $this->getIsWeekendDelivery();
|
|
}
|
|
|
|
public function isExpressDelivery()
|
|
{
|
|
return $this->getIsExpressDelivery();
|
|
}
|
|
|
|
public function getIsWeekendDelivery()
|
|
{
|
|
$weekendDelivery = parent::getIsWeekendDelivery();
|
|
|
|
return null === $weekendDelivery && null !== $this->weekend_delivery_cost_netto || $weekendDelivery;
|
|
}
|
|
|
|
public function setWidth($v)
|
|
{
|
|
parent::setWidth($v);
|
|
$this->computeVolume();
|
|
}
|
|
|
|
public function setHeight($v)
|
|
{
|
|
parent::setHeight($v);
|
|
$this->computeVolume();
|
|
}
|
|
|
|
public function setDepth($v)
|
|
{
|
|
parent::setDepth($v);
|
|
$this->computeVolume();
|
|
}
|
|
|
|
public function getMaxOrderWeight()
|
|
{
|
|
return $this->format(parent::getMaxOrderWeight());
|
|
}
|
|
|
|
public function getMaxOrderAmount()
|
|
{
|
|
return $this->format(parent::getMaxOrderAmount());
|
|
}
|
|
|
|
public function getMinOrderWeight()
|
|
{
|
|
return $this->format(parent::getMinOrderWeight());
|
|
}
|
|
|
|
public function getMinOrderAmount()
|
|
{
|
|
return $this->format(parent::getMinOrderAmount());
|
|
}
|
|
|
|
public function getDefaultCost()
|
|
{
|
|
return $this->format(parent::getDefaultCost());
|
|
}
|
|
|
|
public function getCostNetto($with_currency = false)
|
|
{
|
|
$v = $this->getDefaultCost();
|
|
|
|
if ($with_currency)
|
|
{
|
|
$v = self::$currency->exchange($v);
|
|
}
|
|
|
|
return $v;
|
|
}
|
|
|
|
public function setCostNetto($v)
|
|
{
|
|
$this->setDefaultCost($v);
|
|
}
|
|
|
|
public function getCostBrutto($with_currency = false)
|
|
{
|
|
if (SF_APP == 'frontend' && (sfContext::getInstance()->getUser()->hasVatEu() || sfContext::getInstance()->getUser()->hasVatEx()))
|
|
{
|
|
return $this->getCostNetto($with_currency);
|
|
}
|
|
|
|
$cost = $this->getDefaultCostBrutto();
|
|
|
|
if (null === $cost)
|
|
{
|
|
$cost = stPrice::calculate($this->getCostNetto(), $this->getVat());
|
|
|
|
$this->setCostBrutto($cost);
|
|
}
|
|
|
|
$countryTaxRate = $this->getTax()->getTaxRateByCountry();
|
|
|
|
if (null !== $countryTaxRate)
|
|
{
|
|
$cost = stPrice::calculate(parent::getDefaultCost(), $countryTaxRate);
|
|
}
|
|
|
|
if ($with_currency)
|
|
{
|
|
$cost = self::$currency->exchange($cost);
|
|
}
|
|
|
|
return $this->format($cost);
|
|
}
|
|
|
|
public function getFreeDelivery()
|
|
{
|
|
if (SF_APP == 'frontend' && (sfContext::getInstance()->getUser()->hasVatEu() || sfContext::getInstance()->getUser()->hasVatEx()))
|
|
{
|
|
return stPrice::extract(parent::getFreeDelivery(), $this->getVat(false));
|
|
}
|
|
|
|
return parent::getFreeDelivery();
|
|
}
|
|
|
|
public function getVat($withEuTax = true)
|
|
{
|
|
$this->withEuTax = $withEuTax;
|
|
|
|
$tax = $this->getTax();
|
|
|
|
return $tax->getTaxRateByCountry() ? $tax->getTaxRateByCountry() : $tax->getDefaultTaxRate();
|
|
}
|
|
|
|
public function setCostBrutto($v)
|
|
{
|
|
$this->setDefaultCostBrutto($v);
|
|
}
|
|
|
|
public function getFreeFrom()
|
|
{
|
|
return $this->format($this->getFreeDelivery());
|
|
}
|
|
|
|
public function setFreeFrom($v)
|
|
{
|
|
$this->setFreeDelivery($v);
|
|
}
|
|
|
|
public function getService(): ?stDeliveryTypeInterface
|
|
{
|
|
return null !== $this->getType() ? stDeliveryTypeService::get($this->getType()) : null;
|
|
}
|
|
|
|
public function getType(): ?string
|
|
{
|
|
return DeliveryTypePeer::retrieveTypeById($this->getTypeId());
|
|
}
|
|
|
|
public function isType($type)
|
|
{
|
|
return $this->getType() == $type;
|
|
}
|
|
|
|
public function getSectionCostTypeDesc()
|
|
{
|
|
$tmp = DeliverySectionsPeer::getAdditionalSectionCosts();
|
|
|
|
return $this->getSectionCostType() ? $tmp[$this->getSectionCostType()] : null;
|
|
}
|
|
|
|
/**
|
|
* Zwraca typ płatności dla przypisany do dostawy
|
|
*
|
|
* @param int $paymentTypeId
|
|
* @return DeliveryHasPaymentType|null
|
|
* @throws PropelException
|
|
*/
|
|
public function getDeliveryPaymentType(int $paymentTypeId)
|
|
{
|
|
$c = new Criteria();
|
|
$c->add(DeliveryHasPaymentTypePeer::PAYMENT_TYPE_ID, $paymentTypeId);
|
|
$c->add(DeliveryHasPaymentTypePeer::IS_ACTIVE, true);
|
|
$c->setLimit(1);
|
|
$results = DeliveryHasPaymentTypePeer::doSelectJoinPaymentType($c);
|
|
|
|
return !empty($results) ? $results[0] : null;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Dodana na potrzeby admin generator
|
|
*
|
|
* @param int $v Id vat
|
|
*/
|
|
public function setEditTax($v)
|
|
{
|
|
$this->setTaxId($v);
|
|
}
|
|
|
|
/**
|
|
* @inheritDoc
|
|
*/
|
|
public function getTax($con = null)
|
|
{
|
|
if (SF_APP == 'frontend' && $this->withEuTax)
|
|
{
|
|
$user = sfContext::getInstance()->getUser();
|
|
|
|
if ($user->hasVatEu())
|
|
{
|
|
return stTax::getEu();
|
|
}
|
|
elseif ($user->hasVatEx())
|
|
{
|
|
return stTax::getEx();
|
|
}
|
|
}
|
|
|
|
$this->aTax = parent::getTax($con);
|
|
|
|
if (null === $this->aTax)
|
|
{
|
|
$this->aTax = TaxPeer::doSelectDefaultOne(new Criteria());
|
|
}
|
|
|
|
return $this->aTax;
|
|
}
|
|
|
|
public function isFree(stDeliveryProductInfoAbstract $productInfo)
|
|
{
|
|
return $this->getFreeFrom() > 0 && $productInfo->getTotalAmount() >= $this->getFreeFrom();
|
|
}
|
|
|
|
/**
|
|
* Zwraca całkowity koszt brutto
|
|
*
|
|
* @param stDeliveryProductInfoAbstract $productInfo
|
|
* @param bool $withCurrency
|
|
* @return float|string
|
|
* @throws PropelException
|
|
*/
|
|
public function getTotalCostBrutto(stDeliveryProductInfoAbstract $productInfo, $withCurrency = false)
|
|
{
|
|
return $this->getTotalCost($productInfo, true, $withCurrency);
|
|
}
|
|
|
|
/**
|
|
* Zwraca całkowity koszt netto
|
|
*
|
|
* @param stDeliveryProductInfoAbstract $productInfo
|
|
* @param bool $withCurrency
|
|
* @return float|string
|
|
* @throws PropelException
|
|
*/
|
|
public function getTotalCostNetto(stDeliveryProductInfoAbstract $productInfo, $withCurrency = false)
|
|
{
|
|
return $this->getTotalCost($productInfo, false, $withCurrency);
|
|
}
|
|
|
|
/**
|
|
* Zwraca całkowity koszt
|
|
*
|
|
* @param stDeliveryProductInfoAbstract $productInfo
|
|
* @param bool $withTax
|
|
* @param bool $withCurrency
|
|
* @return mixed
|
|
* @throws PropelException
|
|
*/
|
|
public function getTotalCost(stDeliveryProductInfoAbstract $productInfo, $withTax = false, $withCurrency = false)
|
|
{
|
|
if ($this->isFree($productInfo))
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
$priceType = stConfig::getInstance('stProduct')->get('delivery_price_type', 'netto');
|
|
|
|
$totalProductDeliveryPrice = $productInfo->getTotalDeliveryPrice();
|
|
|
|
if ($priceType == 'netto' && $withTax)
|
|
{
|
|
$totalProductDeliveryPrice = stPrice::calculate($totalProductDeliveryPrice, $this->getVat());
|
|
}
|
|
|
|
if ($priceType == 'brutto' && !$withTax)
|
|
{
|
|
$totalProductDeliveryPrice = stPrice::extract($totalProductDeliveryPrice, $this->getVat());
|
|
}
|
|
|
|
if ($withCurrency)
|
|
{
|
|
$totalProductDeliveryPrice = self::$currency->exchange($totalProductDeliveryPrice);
|
|
}
|
|
|
|
$defaultCost = $withTax ? $this->getCostBrutto($withCurrency) : $this->getCostNetto($withCurrency);
|
|
|
|
return $defaultCost + $totalProductDeliveryPrice + $this->getAdditionaCost($productInfo, $withTax, $withCurrency);
|
|
}
|
|
|
|
/**
|
|
* Zwraca dodatkowy koszt
|
|
*
|
|
* @param stDeliveryProductInfoAbstract $productInfo
|
|
* @param bool $withTax
|
|
* @param bool $withCurrency
|
|
* @return mixed
|
|
* @throws PropelException
|
|
*/
|
|
public function getAdditionaCost(stDeliveryProductInfoAbstract $productInfo, $withTax = false, $withCurrency = false)
|
|
{
|
|
if ($this->isFree($productInfo))
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
switch ($this->getSectionCostType())
|
|
{
|
|
case "ST_BY_ORDER_AMOUNT":
|
|
$fromValue = $productInfo->getTotalAmount();
|
|
break;
|
|
case "ST_BY_ORDER_QUANTITY":
|
|
$fromValue = $productInfo->getTotalQuantity();
|
|
break;
|
|
case "ST_BY_ORDER_WEIGHT":
|
|
$fromValue = $productInfo->getTotalWeight();
|
|
break;
|
|
default:
|
|
$fromValue = 0;
|
|
break;
|
|
}
|
|
|
|
$c = new Criteria();
|
|
|
|
$c->add(DeliverySectionsPeer::VALUE_FROM, $fromValue, Criteria::LESS_EQUAL);
|
|
|
|
$c->setLimit(1);
|
|
|
|
$c->addDescendingOrderByColumn(DeliverySectionsPeer::VALUE_FROM);
|
|
|
|
$results = $this->getDeliverySectionss($c);
|
|
|
|
if (empty($results))
|
|
{
|
|
return 0.00;
|
|
}
|
|
|
|
$results[0]->setDelivery($this);
|
|
|
|
return $withTax ? $results[0]->getCostBrutto($withCurrency) : $results[0]->getCostNetto($withCurrency);
|
|
}
|
|
|
|
/**
|
|
* Zwraca koszt dostawy w weekend
|
|
*
|
|
* @param stDeliveryProductInfoAbstract $productInfo
|
|
* @param bool $withTax
|
|
* @param bool $withCurrency
|
|
* @return float|string
|
|
*/
|
|
public function getWeekendDeliveryCost(stDeliveryProductInfoAbstract $productInfo, $withTax = false, $withCurrency = false)
|
|
{
|
|
if ($this->isFree($productInfo) && !$this->getAlwaysChargeWeekendDeliveryCost())
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
if ($withTax && (SF_APP != 'frontend' || !sfContext::getInstance()->getUser()->hasVatEu() && !sfContext::getInstance()->getUser()->hasVatEx()))
|
|
{
|
|
$cost = $this->getWeekendDeliveryCostBrutto();
|
|
$countryTaxRate = $this->getTax()->getTaxRateByCountry();
|
|
|
|
if (null !== $countryTaxRate)
|
|
{
|
|
$cost = stPrice::calculate($this->getWeekendDeliveryCostNetto(), $countryTaxRate);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$cost = $this->getWeekendDeliveryCostNetto();
|
|
}
|
|
|
|
if ($withCurrency)
|
|
{
|
|
$cost = stCurrency::exchange($cost);
|
|
}
|
|
|
|
return $cost;
|
|
}
|
|
|
|
/**
|
|
* Zwraca koszt dostawy ekspresowej
|
|
*
|
|
* @param stDeliveryProductInfoAbstract $productInfo
|
|
* @param bool $withTax
|
|
* @param bool $withCurrency
|
|
* @return float|string
|
|
*/
|
|
public function getExpressDeliveryCost(stDeliveryProductInfoAbstract $productInfo, $withTax = false, $withCurrency = false)
|
|
{
|
|
if ($this->isFree($productInfo) && !$this->getAlwaysChargeExpressDeliveryCost())
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
if ($withTax && (SF_APP != 'frontend' || !sfContext::getInstance()->getUser()->hasVatEu() && !sfContext::getInstance()->getUser()->hasVatEx()))
|
|
{
|
|
$cost = $this->getExpressDeliveryCostBrutto();
|
|
|
|
$countryTaxRate = $this->getTax()->getTaxRateByCountry();
|
|
|
|
if (null !== $countryTaxRate)
|
|
{
|
|
$cost = stPrice::calculate($this->getExpressDeliveryCostNetto(), $countryTaxRate);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$cost = $this->getExpressDeliveryCostNetto();
|
|
}
|
|
|
|
if ($withCurrency)
|
|
{
|
|
$cost = stCurrency::exchange($cost);
|
|
}
|
|
|
|
return $cost;
|
|
}
|
|
|
|
/**
|
|
* Przeciążenie hydrate
|
|
*
|
|
* @param ResultSet $rs
|
|
* @param int $startcol
|
|
* @return object
|
|
*/
|
|
public function hydrate(ResultSet $rs, $startcol = 1)
|
|
{
|
|
$this->setCulture(stLanguage::getHydrateCulture());
|
|
|
|
return parent::hydrate($rs, $startcol);
|
|
}
|
|
|
|
/**
|
|
* Przeciążenie getName
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getName()
|
|
{
|
|
if ($this->getCulture() == stLanguage::getOptLanguage())
|
|
{
|
|
return stLanguage::getDefaultValue($this, __METHOD__);
|
|
}
|
|
|
|
$v = parent::getName();
|
|
|
|
if (is_null($v))
|
|
{
|
|
$v = stLanguage::getDefaultValue($this, __METHOD__);
|
|
}
|
|
|
|
return $v;
|
|
}
|
|
|
|
/**
|
|
* Przeciążenie setName
|
|
*
|
|
* @param string $v Nazwa producenta
|
|
*/
|
|
public function setName($v)
|
|
{
|
|
if ($this->getCulture() == stLanguage::getOptLanguage())
|
|
{
|
|
stLanguage::setDefaultValue($this, __METHOD__, $v);
|
|
}
|
|
|
|
parent::setName($v);
|
|
}
|
|
|
|
public function getParam($name, $default = null)
|
|
{
|
|
return $this->params && isset($this->params[$name]) ? $this->params[$name] : $default;
|
|
}
|
|
|
|
/**
|
|
* Przeciążenie getDescription
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getDescription()
|
|
{
|
|
if ($this->getCulture() == stLanguage::getOptLanguage())
|
|
{
|
|
return stLanguage::getDefaultValue($this, __METHOD__);
|
|
}
|
|
|
|
$v = parent::getDescription();
|
|
|
|
if (is_null($v))
|
|
{
|
|
$v = stLanguage::getDefaultValue($this, __METHOD__);
|
|
}
|
|
|
|
return $v;
|
|
}
|
|
|
|
/**
|
|
* Przeciążenie setDescription
|
|
*
|
|
* @param string $v Nazwa producenta
|
|
*/
|
|
public function setDescription($v)
|
|
{
|
|
if ($this->getCulture() == stLanguage::getOptLanguage())
|
|
{
|
|
stLanguage::setDefaultValue($this, __METHOD__, $v);
|
|
}
|
|
|
|
parent::setDescription($v);
|
|
}
|
|
|
|
public function delete($con = null)
|
|
{
|
|
$ret = parent::delete($con);
|
|
|
|
self::clearCache();
|
|
|
|
return $ret;
|
|
}
|
|
|
|
public function save($con = null)
|
|
{
|
|
if ($this->getIsDefault() && $this->isColumnModified(DeliveryPeer::IS_DEFAULT))
|
|
{
|
|
$c = new Criteria();
|
|
|
|
$c->add(DeliveryPeer::COUNTRIES_AREA_ID, $this->getCountriesAreaId());
|
|
|
|
$delivery = DeliveryPeer::doSelectDefault($c);
|
|
|
|
if ($delivery)
|
|
{
|
|
$delivery->setIsDefault(false);
|
|
|
|
$delivery->save($con);
|
|
}
|
|
}
|
|
|
|
$ret = parent::save($con);
|
|
|
|
self::clearCache();
|
|
|
|
return $ret;
|
|
}
|
|
|
|
protected function format($v)
|
|
{
|
|
$v = $v ? $v : 0.00;
|
|
|
|
if (is_numeric($v))
|
|
{
|
|
return stPrice::round($v);
|
|
}
|
|
|
|
return $v;
|
|
}
|
|
|
|
protected function computeVolume()
|
|
{
|
|
$volume = $this->width * $this->height * $this->depth;
|
|
$this->setVolume($volume);
|
|
}
|
|
|
|
public static function clearCache()
|
|
{
|
|
$fc = new stFunctionCache('stDelivery');
|
|
$fc->removeAll();
|
|
}
|
|
}
|