448 lines
11 KiB
PHP
448 lines
11 KiB
PHP
<?php
|
|
/**
|
|
* Représente un paiement.
|
|
* N'est pas utilisé directement
|
|
*
|
|
*/
|
|
class HIPAY_MAPI_Payment extends HIPAY_MAPI_XML {
|
|
|
|
/**
|
|
* Paramètres du paiement
|
|
*
|
|
* @var HIPAY_MAPI_PaymentParams
|
|
*/
|
|
protected $paymentParams;
|
|
|
|
/**
|
|
* Objets HIPAY_MAPI_Order
|
|
*
|
|
* @var array
|
|
*/
|
|
protected $order;
|
|
|
|
/**
|
|
* Objets HIPAY_MAPI_Item
|
|
*
|
|
* @var array
|
|
*/
|
|
protected $items;
|
|
|
|
/**
|
|
* Total des taxes sur les produits
|
|
*
|
|
* @var array
|
|
*/
|
|
protected $_taxItemsAmount;
|
|
|
|
/**
|
|
* Total des taxes sur les frais d'envoi
|
|
*
|
|
* @var array
|
|
*/
|
|
protected $_taxShippingAmount;
|
|
/**
|
|
* Total des taxes sur les assurances
|
|
*
|
|
* @var array
|
|
*/
|
|
protected $_taxInsuranceAmount;
|
|
|
|
/**
|
|
* Total des taxes sur les coûts fixes
|
|
*
|
|
* @var array
|
|
*/
|
|
protected $_taxFixedCostAmount;
|
|
|
|
/**
|
|
* Total du montant HT des produits
|
|
*
|
|
* @var array
|
|
*/
|
|
protected $_itemsTotalAmount;
|
|
|
|
/**
|
|
* Total des taxes
|
|
*
|
|
* @var array
|
|
*/
|
|
public $_taxTotalAmount;
|
|
|
|
/**
|
|
* Total de la commande hors taxes
|
|
*
|
|
* @var array
|
|
*/
|
|
protected $_orderTotalAmountHT;
|
|
|
|
/**
|
|
* Total de la commande
|
|
*
|
|
* @var array
|
|
*/
|
|
protected $_orderTotalAmount;
|
|
|
|
|
|
/**
|
|
* Total des affilies
|
|
*
|
|
* @var array
|
|
*/
|
|
protected $_affiliateTotalAmount;
|
|
|
|
|
|
public function __construct($paymentParams,$order,$items) {
|
|
try {
|
|
$this->init($paymentParams,$order,$items);
|
|
} catch(Exception $e) {
|
|
throw new Exception($e->getMessage());
|
|
}
|
|
}
|
|
|
|
protected function init($paymentParams,$order,$items) {
|
|
if (!($paymentParams instanceof HIPAY_MAPI_PaymentParams)
|
|
|| !HIPAY_MAPI_UTILS::is_an_array_of($order,'HIPAY_MAPI_Order')
|
|
|| !HIPAY_MAPI_UTILS::is_an_array_of($items,'HIPAY_MAPI_Item')
|
|
|| count($items)<1)
|
|
throw new Exception('Wrong parameters');
|
|
|
|
try {
|
|
$paymentParams->check();
|
|
} catch (Exception $e) {
|
|
throw new Exception($e->getMessage());
|
|
}
|
|
foreach($order as $orderObj) {
|
|
try {
|
|
$orderObj->check();
|
|
} catch (Exception $e) {
|
|
throw new Exception($e->getMessage());
|
|
}
|
|
}
|
|
|
|
foreach($items as $obj)
|
|
try {
|
|
$obj->check();
|
|
} catch (Exception $e) {
|
|
throw new Exception($e->getMessage());
|
|
}
|
|
|
|
$this->paymentParams= clone $paymentParams;
|
|
$this->paymentParams->lock();
|
|
|
|
|
|
foreach($order as $obj) {
|
|
$this->order[]= clone $obj;
|
|
end($this->order)->lock();
|
|
$this->_taxItemsAmount[]=0;
|
|
$this->_taxShippingAmount[]=0;
|
|
$this->_taxInsuranceAmount[]=0;
|
|
$this->_taxFixedCostAmount[]=0;
|
|
$this->_itemsTotalAmount[]=0;
|
|
$this->_taxTotalAmount[]=0;
|
|
$this->_orderTotalAmount[]=0;
|
|
$this->_affiliateTotalAmount[]=0;
|
|
|
|
}
|
|
foreach($items as $obj) {
|
|
$this->items[]= clone $obj;
|
|
end($this->items)->lock();
|
|
}
|
|
try {
|
|
$this->compute();
|
|
} catch(Exception $e) {
|
|
throw new Exception($e->getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Calcul les différents montants (taxes, affiliés, totaux) de la commande
|
|
*
|
|
*/
|
|
protected function compute() {
|
|
|
|
// Mise à jour du montant total des taxes pour chaque item du tableau _taxItemsAmount
|
|
// Mise à jour du montant total des taxes de livraison pour chaque order du tableau _taxShippingAmount
|
|
// Mise à jour du montant total des taxes d'assurances pour chaque order du tableau _taxInsuranceAmount
|
|
// Mise à jour du montant total des taxes de couts fixes pour chaque order du tableau _taxFixedCostAmount
|
|
$this->computeTaxes();
|
|
// Mise a jour du montant total HT des produits pour chaque item du tableau _itemsTotalAmount
|
|
$this->computeItemsAmount();
|
|
// Pour chaque commande
|
|
foreach($this->order as $key=>$order) {
|
|
$this->_taxTotalAmount[$key] = $this->_taxItemsAmount[$key] + $this->_taxShippingAmount[$key] + $this->_taxInsuranceAmount[$key] + $this->_taxFixedCostAmount[$key];
|
|
$this->_orderTotalAmountHT[$key] = $order->getShippingAmount() + $order->getInsuranceAmount() + $order->getFixedCostAmount() + $this->_itemsTotalAmount[$key];
|
|
$this->_orderTotalAmount[$key] = $this->_orderTotalAmountHT[$key] + $this->_taxTotalAmount[$key];
|
|
// $this->_orderTotalAmount[$key] = $order->getShippingAmount() + $order->getInsuranceAmount() + $order->getFixedCostAmount() + $this->_itemsTotalAmount[$key] +
|
|
// $this->_taxItemsAmount[$key] +
|
|
// $this->_taxShippingAmount[$key] +
|
|
// $this->_taxInsuranceAmount[$key] +
|
|
// $this->_taxFixedCostAmount[$key];
|
|
}
|
|
try {
|
|
$this->computeAffiliates();
|
|
} catch(Exception $e) {
|
|
throw new Exception($e->getMessage());
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Calcul le montant des taxes
|
|
*
|
|
*/
|
|
protected function computeTaxes() {
|
|
|
|
// Taxes sur les produits au niveau de l'item (ligne de commande)
|
|
// @FIXME bug et confusion entre indice d'item et indice d'order ?
|
|
$cur=0;
|
|
// pour chaque ligne de commande
|
|
foreach($this->items as $item) {
|
|
// Liste des taxes de la ligne
|
|
$itemTaxes= $item->getTax();
|
|
$tItemsAmount=0;
|
|
// pour chaque taxe appliquée sur cette ligne
|
|
foreach($itemTaxes as $tax) {
|
|
$amount=HIPAY_MAPI_UTILS::computeTax($item->getPrice(),$tax);
|
|
$tax->setTaxAmount($amount);
|
|
$tax->lock();
|
|
// mise a jour du montant total des taxes pour cet item (ligne de commande)
|
|
$tItemsAmount+=$amount;
|
|
}
|
|
if (!isset($this->order[$cur]))
|
|
$cur=0;
|
|
if (!isset($this->_taxItemsAmount[$cur]))
|
|
$this->_taxItemsAmount[$cur]=0;
|
|
// mise a jour du montant total des taxes pour cette ligne de commande
|
|
// avec prise en compte du nombre de produits dans l'indice numLigneCommande
|
|
// du tableau _taxItemsAmount de cette commande
|
|
$this->_taxItemsAmount[$cur]+=($tItemsAmount*$item->getQuantity());
|
|
$item->lock();
|
|
$cur++;
|
|
}
|
|
|
|
// Taxes sur frais d'envoi, assurances, coûts fixes
|
|
// au niveau des commandes
|
|
$cur=0;
|
|
foreach($this->order as $order) {
|
|
// Taxes sur frais d'envoi
|
|
$taxArr =& $order->getShippingTax();
|
|
foreach($taxArr as $key=>$tax) {
|
|
$amount=HIPAY_MAPI_UTILS::computeTax($order->getShippingAmount(),$tax);
|
|
$taxArr[$key]->setTaxAmount($amount);
|
|
$taxArr[$key]->lock();
|
|
|
|
if (!isset($this->_taxShippingAmount[$cur]))
|
|
$this->_taxShippingAmount[$cur]=0;
|
|
$this->_taxShippingAmount[$cur]+=$amount;
|
|
}
|
|
// Taxes sur assurances
|
|
$taxArr =& $order->getInsuranceTax();
|
|
foreach($taxArr as $key=>$tax) {
|
|
$amount=HIPAY_MAPI_UTILS::computeTax($order->getInsuranceAmount(),$tax);
|
|
$taxArr[$key]->setTaxAmount($amount);
|
|
$taxArr[$key]->lock();
|
|
if (!isset($this->_taxInsuranceAmount[$cur]))
|
|
$this->_taxInsuranceAmount[$cur]=0;
|
|
$this->_taxInsuranceAmount[$cur]+=$amount;
|
|
}
|
|
// Taxes sur coûts fixes
|
|
$taxArr =& $order->getFixedCostTax();
|
|
foreach($taxArr as $key=>$tax) {
|
|
$amount=HIPAY_MAPI_UTILS::computeTax($order->getFixedCostAmount(),$tax);
|
|
$taxArr[$key]->setTaxAmount($amount);
|
|
$taxArr[$key]->lock();
|
|
if (!isset($this->_taxFixedCostAmount[$cur]))
|
|
$this->_taxFixedCostAmount[$cur]=0;
|
|
$this->_taxFixedCostAmount[$cur]+=$amount;
|
|
}
|
|
$cur++;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Calcul le montant total HT des produits
|
|
*
|
|
*/
|
|
protected function computeItemsAmount() {
|
|
$itemsAmount=0;
|
|
$cur=0;
|
|
foreach($this->items as $item) {
|
|
$mt=sprintf("%.02f",$item->getPrice()*$item->getQuantity());
|
|
|
|
if (!isset($this->order[$cur]))
|
|
$cur=0;
|
|
if (!isset($this->_itemsTotalAmount[$cur]))
|
|
$this->_itemsTotalAmount[$cur]=0;
|
|
$this->_itemsTotalAmount[$cur]+=$mt;
|
|
$cur++;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Retourne le montant total des taxes
|
|
*
|
|
* @param array $tItemsAmount
|
|
* @param array $tShippingAmount
|
|
* @param array $tInsuranceAmount
|
|
* @param array $tFixedCostAmount
|
|
*/
|
|
public function getTotalTaxes(&$tItemsAmount,&$tShippingAmount,&$tInsuranceAmount,&$tFixedCostAmount) {
|
|
$tItemsAmount=$this->getItemsTaxes();;
|
|
$tShippingAmount=$this->getShippingTaxes();
|
|
$tInsuranceAmount=$this->getInsuranceTaxes();
|
|
$tFixedCostAmount=$this->getFixedCostTaxes();
|
|
}
|
|
|
|
/**
|
|
* Retourne le montant des taxes sur les articles
|
|
*
|
|
* @return float
|
|
*/
|
|
public function getItemsTaxes() {
|
|
return $this->_taxItemsAmount;
|
|
}
|
|
|
|
/**
|
|
* Retourne le montant des taxes sur les frais de port
|
|
*
|
|
* @return float
|
|
*/
|
|
public function getShippingTaxes() {
|
|
return $this->_taxShippingAmount;
|
|
}
|
|
|
|
/**
|
|
* Retourne le montant des taxes sur les assurances
|
|
*
|
|
* @return float
|
|
*/
|
|
public function getInsuranceTaxes() {
|
|
return $this->_taxInsuranceAmount;
|
|
}
|
|
|
|
/**
|
|
* Retourne le montant des taxes sur les couts fixes
|
|
*
|
|
* @return float
|
|
*/
|
|
public function getFixedCostTaxes() {
|
|
return $this->_taxFixedCostAmount;
|
|
}
|
|
|
|
/**
|
|
* Retourne le montant total des produits
|
|
*
|
|
* @return array
|
|
*/
|
|
public function getItemsTotalAmount() {
|
|
return $this->_itemsTotalAmount;
|
|
}
|
|
|
|
/**
|
|
* Retourne le montant total des taxes
|
|
*
|
|
* @return array
|
|
*/
|
|
public function getTaxesTotalAmount() {
|
|
return $this->_taxTotalAmount;
|
|
}
|
|
|
|
/**
|
|
* Retourne le montant total hors taxes de la commande
|
|
*
|
|
* @return array
|
|
*/
|
|
public function getOrderTotalAmountHT() {
|
|
return $this->_orderTotalAmountHT;
|
|
}
|
|
|
|
/**
|
|
* Retourne le montant total TTC de la commande
|
|
*
|
|
* @return array
|
|
*/
|
|
public function getOrderTotalAmount() {
|
|
return $this->_orderTotalAmount;
|
|
}
|
|
|
|
/**
|
|
* Retourne le montant total des affiliés
|
|
*
|
|
* @return array
|
|
*/
|
|
public function getAffiliateTotalAmount() {
|
|
return $this->_affiliateTotalAmount;
|
|
}
|
|
|
|
/**
|
|
* Retourne les objets order
|
|
*
|
|
* @return array
|
|
*/
|
|
public function getOrder() {
|
|
return $this->order;
|
|
}
|
|
|
|
/**
|
|
* Retourne les objets items
|
|
*
|
|
* @return array
|
|
*/
|
|
public function getItems() {
|
|
return $this->items;
|
|
}
|
|
|
|
/**
|
|
* Retourne l'objet paramètre
|
|
*
|
|
* @return HIPAY_MAPI_PaymentParams
|
|
*/
|
|
public function getPaymentParams() {
|
|
return $this->paymentParams;
|
|
}
|
|
|
|
|
|
/**
|
|
* Calcul les montants à redistribuer aux affiliés
|
|
*
|
|
*/
|
|
protected function computeAffiliates() {
|
|
|
|
|
|
foreach($this->order as $k=>$order) {
|
|
$totalAmount=0;
|
|
$tAffiliate = $order->getAffiliate();
|
|
foreach($tAffiliate as $key=>$affiliate) {
|
|
$baseAmount=0;
|
|
$percentageTarget= $affiliate->getPercentageTarget();
|
|
if ($percentageTarget>0) {
|
|
if ($percentageTarget & HIPAY_MAPI_TTARGET_ITEM)
|
|
$baseAmount+=$this->_itemsTotalAmount[$k];
|
|
if ($percentageTarget & HIPAY_MAPI_TTARGET_TAX)
|
|
$baseAmount+=$this->_taxItemsAmount[$k]+$this->_taxFixedCostAmount[$k]+$this->_taxInsuranceAmount[$k]+$this->_taxShippingAmount[$k];
|
|
if ($percentageTarget& HIPAY_MAPI_TTARGET_INSURANCE)
|
|
$baseAmount+=$order->getInsuranceAmount();
|
|
if ($percentageTarget & HIPAY_MAPI_TTARGET_FCOST)
|
|
$baseAmount+=$order->getFixedCostAmount();
|
|
if ($percentageTarget & HIPAY_MAPI_TTARGET_SHIPPING)
|
|
$baseAmount+=$order->getShippingAmount();
|
|
$tAffiliate[$key]->setBaseAmount($baseAmount);
|
|
} else {
|
|
$baseAmount = $affiliate->getValue();
|
|
$tAffiliate[$key]->setBaseAmount($baseAmount);
|
|
}
|
|
$totalAmount+=$tAffiliate[$key]->getAmount();
|
|
$tAffiliate[$key]->lock();
|
|
}
|
|
$this->_affiliateTotalAmount[$k]=$totalAmount;
|
|
if ($totalAmount > $this->_orderTotalAmount[$k]) {
|
|
throw new Exception('Le montant à redistribuer est supérieur au montant de la transaction ('.$totalAmount.'/'.$this->_orderTotalAmount.')');
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
?>
|