/class.xmodmonetique.inc

https://github.com/jcplat/console-seolan · PHP · 1856 lines · 1015 code · 81 blank · 760 comment · 172 complexity · 36d94239298c177e1cd74d1b9f9ffabd MD5 · raw file

Large files are truncated click here to view the full file

    

  1. <?php
    2. 

  2. /**
    3. 

  3.  * \file     class.xmodmonetique.inc
    4. 

  4.  * \name     XModMonetique
    5. 

  5.  * \author   Vladimir Monari
    6. 

  6.  * \version  1.0
    7. 

  7.  * \date     1 Septembre 2013
    8. 

  8.  */
    9. 

  9. 

  10. /**
    11. 

  11.  * \brief Classe MTransaction.
    12. 

  12.  * Classe représentant une transaction.
    13. 

  13.  * \version 1.0
    14. 

  14.  * \note 
    15. 

  15.  * - Pour Paybox et Atos une transaction en état WAITTING signifie que le serveur n'était pas disponible lors de l'appel.
    16. 

  16.  * - Pour SystemPay une transaction en état WAITTING signifie que le status en banque de la transaction ne permet pas cette action pour le moment. Elle devra donc être rejouée. Exemple: 
    17. 

  17.  * - Un remboursement ne peut être éfféctué que si la transaction à été remisé. Si le remboursement est intégral, on peut annuler la transaction, sinon il faudra attendre.
    18. 

  18.  */
    19. 

  19. 

  20. /*************************************************************************
    21. 

  21.  * TEST MULTI WEB_PAYMENT :
    22. 

  22.  * - $order->options['nbDeadLine'] = 3;
    23. 

  23.  * - $order->options['frequencyDuplicate'] = 31;
    24. 

  24.  * - $order->options['captureDay'] = 10; ///< Spécifique à paybox (numéro du jour de prélèvement dans le mois)
    25. 

  25.  * - $order->options['captureDelay'] = 10;
    26. 

  26.  * - $order->options['noCapture'] = true; ///< Demande d'autorisation uniquement
    27. 

  27.  *
    28. 

  28.  * TEST D'ENROLLEMENT :
    29. 

  29.  * - $order->options['enrollement']= true;
    30. 

  30.  * - $order->options['refAbonnement'] = 'Atos Refus';
    31. 

  31.  ***************************************************************************/
    32. 

  32. 

  33. 

  34. class MTransaction{
    35. 

  35.   public $oid = null; ///< Identifiant de la transaction.
    36. 

  36.   public $orderOid = null; ///< Identifiant oid de la commande.
    37. 

  37.   public $orderReference = null; ///< Référence de la commande.
    38. 

  38.   public $customerOid = null; ///< Identifiant oid du client.
    39. 

  39.   public $customerEmail = null;	///< Email du client.
    40. 

  40.   public $dateCreated = null; ///< Date de création de la transaction.
    41. 

  41.   public $responseCode = null; ///< Code reponse de la banque.
    42. 

  42.   public $amount = null; ///< Float $amount : Montant de la transaction en euros.
    43. 

  43.   /** 
    44. 

  44.    * \brief Status de la transaction.
    45. 

  45.    * \details Peut-être valorisé à :
    46. 

  46.    * - XModMonetique::RUNNING.
    47. 

  47.    * - XModMonetique::WAITTING. 
    48. 

  48.    * - XModMonetique::SUCCESS. 
    49. 

  49.    * - XModMonetique::ERROR. 
    50. 

  50.    * - XModMonetique::INVALID.
    51. 

  51.    */
    52. 

  52.   public $status = null; 
    53. 

  53.   /** 
    54. 

  54.    * \brief Type de la transaction.
    55. 

  55.    * \details Peut-être valorisé à :
    56. 

  56.    * - XModMonetique::DUPLICATE.
    57. 

  57.    * - XModMonetique::WEB_PAYMENT. 
    58. 

  58.    * - XModMonetique::REFUND. 
    59. 

  59.    */
    60. 

  60.   public $type = null;
    61. 

  61.   public $dateTimeOut = null; ///< Date et heure d'envoi en banque des paramètres de la transaction.
    62. 

  62.   public $dateTimeIn = null; ///< Date et heure du retour banque de la transaction.
    63. 

  63.   public $transOri = null; ///< Lien vers la transaction d'origine (oid de la transaction d'origine). 
    64. 

  64.   public $shopMoid = null; ///< Identifiant du module de la boutique.
    65. 

  65.   public $shopClass = null;///< Classe de la boutique.
    66. 

  66.   public $shopName = null;///< Nom de la boutique.
    67. 

  67.   /** 
    68. 

  68.    * \brief  Mode de la notification boutique.
    69. 

  69.    * \details Peut-être valorisé à :
    70. 

  70.    * - \link XModMonetique::ASYNC_RESPONSE \endlink
    71. 

  71.    * - \link XModMonetique::SYNC_RESPONSE \endlink
    72. 

  72.    * - \link XModMonetique::RESPONSE_NONE \endlink
    73. 

  73.    */
    74. 

  74.   public $autoResponseMode = null;
    75. 

  75.   public $shopCallBack = null; ///< Fonction de la boutique permettant le traitement de la réponse.
    76. 

  76.   public $statusComplement = null;  ///< Complément de statut de la transaction. Donne des informations complémentaire sur l'état de la transaction.
    77. 

  77.   public $callParms = null; ///< Paramètres bruts transmis lors de l'appel en banque.
    78. 

  78.   public $responseParms = null;  ///< Réponse brute retournée par la banque.
    79. 

  79.   public $refAbonneBoutique = null; ///< Référence d'abonné attribué à un client lors d'une commande définissant un enrollement. 
    80. 

  80.   public $monetiqueMoid = null; ///< Identifiant du module de gestion des transaction utilisé pour celle-ci.
    81. 

  81.   public $nbReturn = null; ///< Nombre de retour banque (Utile à Paybox uniquement, maximum 3 trois retour pour un paiement web).
    82. 

  82.   /** 
    83. 

  83.    * \brief  Statut de la notification boutique.
    84. 

  84.    * \details Peut-être valorisé à :
    85. 

  85.    * - XModMonetique::RESPONSE_STATUS_SENT \endlink
    86. 

  86.    * - XModMonetique::RESPONSE_STATUS_TO_SEND \endlink
    87. 

  87.    * - XModMonetique::RESPONSE_STATUS_NOT_TO_SEND \endlink
    88. 

  88.    */
    89. 

  89.   public $responseStatus = null;
    90. 

  90.   public $transId = null; ///< Identifiant en bancaire de la transaction.
    91. 

  91.   public $modeTest = True; ///< Mode test par defaut.
    92. 

  92.   public $captureDelay = '0'; ///< Capture immédiate par défaut.
    93. 

  93.   /**
    94. 

  94.    *\brief Capture par défaut, sinon simple demande d'autorisation.
    95. 

  95.    * \details Peut-être valorisé à :
    96. 

  96.    * - \link XModMonetique::AUTHORIZATION_ONLY \endlink
    97. 

  97.    * - \link XModMonetique::CATCH_PAYMENT \endlink
    98. 

  98.    */
    99. 

  99.   public $captureMode = null; 
    100. 

  100.   public $frequencyDuplicate = null; ///< Capture immédiate par défaut.
    101. 

  101.   public $enrollement = False; ///< Pas d'enrollement par défaut
    102. 

  102.   public $nbDeadLine = 1; ///< Nombre d'échéances par défaut
    103. 

  103. }
    104. 

  104. 

  105. /**
    106. 

  106.  * \brief Classe MOrderInfos.
    107. 

  107.  * Classe représentant une commande.
    108. 

  108.  * \version 1.0
    109. 

  109.  */
    110. 

  110. class MOrderInfos{
    111. 

  111.   public $oid = null; ///< Identifiant oid de la commande.
    112. 

  112.   public $reference = null; ///< Référence de la commande.
    113. 

  113.   public $amount = null; ///< Montant de la commande.
    114. 

  114.   /** 
    115. 

  115.    * \brief Contient les options éventuelles de la commande.
    116. 

  116.    * \details Doit être valorisé à :
    117. 

  117.    * - Pour un enrollement :
    118. 

  118.    *  - $order->options['enrollement']= true;
    119. 

  119.    *  - $order->options['refAbonnement'] = '<Référence de l'abonné>';
    120. 

  120.    * - Pour un paiement multiple :
    121. 

  121.    *  - $order->options['nbDeadLine'] = 3;
    122. 

  122.    *  - Facultatif:
    123. 

  123.    *   - $order->options['frequencyDuplicate'] = 31; Fréquence de prélevement en jours. Par défaut 30.
    124. 

  124.    *   - $order->options['captureDay'] = 10; Spécifique à paybox : Numéro du jour de prelevement dans le mois. Par défaut le 1.
    125. 

  125.    * - Pour modifier le délai de la capture :
    126. 

  126.    *   - $order->options['captureDelay'] = 10; Délais de capture réelle de la transaction en jours. Par défaut 0. 
    127. 

  127.    *  - Pour une demande d'autorisation seule :
    128. 

  128.    *   - $order->options['noCapture'] = true; ///< Demande d'autorisation uniquement
    129. 

  129.    */
    130. 

  130.   public $options = array();
    131. 

  131.   public $cardsType = array();
    132. 

  132. }
    133. 

  133. 

  134. /**
    135. 

  135.  * \brief Classe MCustomerInfos.
    136. 

  136.  * Classe représentant un client.
    137. 

  137.  * \version 1.0
    138. 

  138.  */
    139. 

  139. class MCustomerInfos{
    140. 

  140.   public $oid = null;  ///< Identifiant oid du client.
    141. 

  141.   public $email = null; ///< Email du client.
    142. 

  142. }
    143. 

  143. 

  144. /**
    145. 

  145.  * \brief Classe MShopInfos.
    146. 

  146.  * Classe contenant les paramètres de la boutique.
    147. 

  147.  * \version 1.0
    148. 

  148.  */
    149. 

  149. class MShopInfos{
    150. 

  150.   public $moid = null; ///< Identifiant du module de la boutique.
    151. 

  151.   public $class = null;///< Classe de la boutique.
    152. 

  152.   public $name = null;///< Nom de la boutique.
    153. 

  153.   public $autoResponseMode = null;///< Mode de reponse.
    154. 

  154.   public $autoResponseCallBack = null;///< Fonction de la boutique permettant le traitement de la réponse.
    155. 

  155.   public $cardsType =null; ///< Tableau des cartes voulue par la boutique
    156. 

  156. }
    157. 

  157. 

  158. /**
    159. 

  159.  * \brief   Classe abstraite, base des modules "monetique/VAD".
    160. 

  160.  * \details Cette classe permet d'unifier les appels et retours des différents modules de paiements en ligne (ATOS/SIPS, SystemPay et Paybox).
    161. 

  161.  */
    162. 

  162. 

  163. abstract class XModMonetique extends XModtable{
    164. 

  164.   // Options communes à tout (ou presque) les modules de paiements
    165. 

  165.   const CATCH_PAYMENT = 'capture';
    166. 

  166.   const AUTHORIZATION_ONLY = 'autorisation';
    167. 

  167. 

  168.   // Constantes correspondant au type de transaction.
    169. 

  169.   const DUPLICATE = 'subscdebit'; ///< Prelèvement 'manuel' sur un abonné / enrollé.
    170. 

  170.   const WEB_PAYMENT = 'webpayment';    ///< Paiement de base par internet.
    171. 

  171.   const REFUND = 'refund';   ///< Remboursement.
    172. 

  172.   
    173. 

  173.   // Constantes pour la gestion du retour vers la boutique.
    174. 

  174.   const ASYNC_RESPONSE = 'async'; ///< Notifier la boutique en arrière plan. 
    175. 

  175.   const SYNC_RESPONSE = 'sync';   ///< Notifier la boutique dès le retour.
    176. 

  176.   const RESPONSE_NONE = 'none';   ///< Ne pas notifier la boutique.
    177. 

  177. 

  178.   // Status de notification de la réponse vers la boutique.
    179. 

  179.   const RESPONSE_STATUS_SENT = 'sent';     ///< Boutique notifiée.
    180. 

  180.   const RESPONSE_STATUS_TO_SEND = 'tosend'; ///< Boutique à notifier.
    181. 

  181.   const RESPONSE_STATUS_NOT_TO_SEND = 'nottosend'; ///< Boutique à notifier.
    182. 

  182. 

  183.   // Constantes correspondant à l'état d'une transaction
    184. 

  184.   const RUNNING = 'running';  ///< En cours de traitement (on attend le retour banque, qui ne viendra peut être jamais, si le client n'arrive pas au bout de la transaction).
    185. 

  185.   const WAITTING = 'waitting'; ///< Opération en attente (Soit le serveur ATOS n'est pas disponible, soit il faut attendre que la transaction est un status permettant l'opération en attente pour SystemPay.
    186. 

  186.   const SUCCESS = 'success';   ///< Opération réalisée avec succés, que ce soit un paiement web, un remboursement ou une duplication.
    187. 

  187.   const ERROR = 'error';    ///< Opération échoué, motifs exacte dans compelement de status (statusComplement) \link MTransaction::$statusComplement \endlink
    188. 

  188.   const INVALID = 'invalid';    ///< Correspond à une erreur de vérification de signature.
    189. 

  189.   
    190. 

  190.   /**
    191. 

  191.    * \brief Type de carte géré par le module XmodMonetique. 
    192. 

  192.    * \details Ce tableau est utilisable UNIQUEMENT avec SystemPay. Les autres modules de gestion, ne permette de préciser qu'un seul type de carte.
    193. 

  193.    * Pour utiliser ce tableau, il faut que la boutique est le même tableau avec les cartes qu'elle autorise à 'true'.
    194. 

  194.    */
    195. 

  195.   public $cardsType = array(
    196. 

  196. 			    'AMEX' => false, 
    197. 

  197. 			    'AURORE' => false,
    198. 

  198. 			    'BUYSTER' => false,
    199. 

  199. 			    'CB' => false, 
    200. 

  200. 			    'COFINOGA' => false,
    201. 

  201. 			    'MASTERCARD' => false, 
    202. 

  202. 			    'JCB' => false,
    203. 

  203. 			    'VISA' => false, 
    204. 

  204. 			    'FINAREF' => false,
    205. 

  205. 			    'FNAC' => false,
    206. 

  206. 			    'CYRILLUS' => false,
    207. 

  207. 			    'PRINTEMPS' => false,
    208. 

  208. 			    'KANGOUROU' => false,
    209. 

  209. 			    'SURCOUF' => false,
    210. 

  210. 			    'POCKETCARD' => false,
    211. 

  211. 			    'CONFORAMA' => false,
    212. 

  212. 			    'NUITEA' => false,
    213. 

  213. 			    'PASS' => false,
    214. 

  214. 			    'PASS2' => false,
    215. 

  215. 			    'PASS3FOIS' => false,
    216. 

  216. 			    'CBPASS' => false,
    217. 

  217. 			    'PEUGEOT' => false,
    218. 

  218. 			    'ACCORD' => false,
    219. 

  219. 			    'FRANFINANCE' => false,
    220. 

  220. 			    '1EUROCOM' => false,
    221. 

  221. 			    '4ETOILES' => false,
    222. 

  222. 			    'COFIDIS_3X' => false,
    223. 

  223. 			    'PROFILPLUS' => false,
    224. 

  224. 			    'LIBRAVOU' => false,
    225. 

  225. 			    'DINERS' => false,
    226. 

  226. 			    'SOLO' => false,
    227. 

  227. 			    'SWITCH' => false,
    228. 

  228. 			    'DELTA' => false,
    229. 

  229. 			    'BANCONTACTMISTERCASH'  => false,
    230. 

  230. 			    'VISA_ELECTRON' => false,
    231. 

  231. 			    'COF3XCB' => false,
    232. 

  232. 			    'COF3XCB_SB' => false,
    233. 

  233. 			    'MAESTRO' => false,
    234. 

  234. 			    'E-CARTEBLEUE' => false,
    235. 

  235. 			    'ONEY' => false,
    236. 

  236. 			    'ONEY_SANDBOX' => false,
    237. 

  237. 			    'PAYPAL' => false,
    238. 

  238. 			    'PAYPAL_SB' => false,
    239. 

  239. 			    'PAYSAFECARD' => false,	
    240. 

  240. 			    'SOFINCO' => false,	   
    241. 

  241. 			    'AVANTAGES' => false,
    242. 

  242. 			    'CDGP' => false,
    243. 

  243. 			    'RIVE GAUCHE' => false,
    244. 

  244. 			    'WEXPAY' => false,
    245. 

  245. 			    'KADEOS' => false,
    246. 

  246. 			    'SVS' => false,
    247. 

  247. 			    'LASER' => false,
    248. 

  248. 			    'KWIXO' => false,
    249. 

  249. 			    'LEETCHI' => false,
    250. 

  250. 			    'MAXICHEQUE' => false,
    251. 

  251. 			    'PAYBUTTON ING' => false,
    252. 

  252. 			    'iDEAL' => false
    253. 

  253. 			    );
    254. 

  254. 

  255.   // Constante définissants le mode de capture
    256. 

  256.   public $siteId = null; ///< Identifiant du site marchand.
    257. 

  257.   public $urlPayed = null; ///< Url de redirection du client pour un paiement accepté.
    258. 

  258.   public $urlCancelled = null; ///< Url de redirection du client en cas d'annulation.
    259. 

  259.   public $urlRefused = null; ///< Url de redirection du client en cas d'erreur.
    260. 

  260.   public $urlAutoResponse = null; ///< Url de retour automatique serveur.
    261. 

  261.   public $lang  = "fr"; ///< Langue par defaut.
    262. 

  262.   public $defaultForeignLang = "en"; ///< Langue par defaut si pas de traduction disponible.
    263. 

  263.   public $defaultCurrencyCode = "978"; ///< La devise par défaut en l'euro.
    264. 

  264.   protected $defaultTemplate = null; ///< Template par defaut. 
    265. 

  265.   
    266. 

  266.   /// Constructeur standard d'un module console.
    267. 

  267.   function __construct($ar=NULL){
    268. 

  268.     parent::__construct($ar);
    269. 

  269.   }
    270. 

  270. 

  271.   /* Fonctions de paiements boutique */
    272. 

  272. 

  273.   /**
    274. 

  274.    * \brief Méthode de génération des données de paiement.
    275. 

  275.    * Cette fonction permet de générer les données d'un paiement et l'insert dans la table TRANSACMONETIQUE.
    276. 

  276.    * \param MOrderInfos $order :  Objet des données issues de la commande. 
    277. 

  277.    * \param MCustomerInfos $customer : Objet des données issues du client.
    278. 

  278.    * \param MShopInfos $shop : Objet comportant les paramètres de la boutique.
    279. 

  279.    * \note
    280. 

  280.    * - Gestion du paiement à multiple écheances. \link MOrderInfos::$options \endlink
    281. 

  281.    * - Mémorise le nombre de retour banque (Spécifique à Paybox, maximum 3).
    282. 

  282.    * - Gestion de l'enrollement. \link insertAbonne($donnees) \endlink, \link MOrderInfos::$options \endlink
    283. 

  283.    * \exception:  
    284. 

  284.    * - Error : \link webPaymentHandling(MOrderInfos $order, MCustomerInfos $customer, MShopInfos $shop, $transactionOid) \endlink.	
    285. 

  285.    * \return array :
    286. 

  286.    * - String ok/ko.
    287. 

  287.    * - Array $formulaireAppel : Contient le formulaire envoyé en banque
    288. 

  288.    * - String $template : Le template correspondant correspondant un module de traitement
    289. 

  289.    * - String $tplentry : L'entrée smarty du template.
    290. 

  290.    * - Sring $transaction->oid : L'oid de la transaction \link MTransaction::$oid \endlink
    291. 

  291.    * \note
    292. 

  292.    * - Vérifie que toutes les infos nécésaires sont bien présentes
    293. 

  293.    * - Paramètres la transaction, l'insère en base et récupère son oid.
    294. 

  294.    * - Délègue au module approprié la création du formaulaire.
    295. 

  295.    * - Mémorise les données brutes d'appel et le status.
    296. 

  296.    */
    297. 

  297.   public function paymentCall(MOrderInfos $order, MCustomerInfos $customer, MShopInfos $shop){
    298. 

  298.     // Vérifie que toutes les infos nécésaires sont bien présentes.
    299. 

  299.     $this->checkPaymentData($order, $customer, $shop);
    300. 

  300.     $transaction = new MTransaction();
    301. 

  301. 

  302.     if(isset($shop->cardsType)){
    303. 

  303.       $transaction->cardsType = $shop->cardsType;
    304. 

  304.     }
    305. 

  305.     // Définition des paramètres de la transaction
    306. 

  306.     if($this->testMode(true)){
    307. 

  307.       $transaction->testMode = True;
    308. 

  308.     }else{
    309. 

  309.       $transaction->testMode = False;
    310. 

  310.     }
    311. 

  311.     $transaction->status = self::RUNNING;
    312. 

  312.     $transaction->type = self::WEB_PAYMENT;
    313. 

  313.     /* Vérification des paramètres de la commande */
    314. 

  314.     $transaction->orderOid = $order->oid;
    315. 

  315.     $transaction->orderReference = $order->reference;
    316. 

  316.     $transaction->amount = $order->amount;
    317. 

  317.     // Préparation des paiement à multiples échéances
    318. 

  318.     if (isset($order->options['nbDeadLine']) && $order->options['nbDeadLine']>1) { 
    319. 

  319.       $transaction->nbDeadLine = $order->options['nbDeadLine'];
    320. 

  320.       // Définition de la fréquence de prélèvement en jours
    321. 

  321.       if(empty($order->options['frequencyDuplicate'])){
    322. 

  322. 	$transaction->frequencyDuplicate = '30';
    323. 

  323.       }else{
    324. 

  324. 	$transaction->frequencyDuplicate = $order->options['frequencyDuplicate'];
    325. 

  325.       }
    326. 

  326.       // Par défaut le jour de prélèvement est la date courante
    327. 

  327.       if(!empty($order->options['captureDay'])){
    328. 

  328. 	$transaction->captureDay = $order->options['captureDay'];
    329. 

  329.       }
    330. 

  330.       else{
    331. 

  331. 	$transaction->captureDay =  date('d');
    332. 

  332.       }
    333. 

  333.     } else {
    334. 

  334.       // Paiement à une seule échéances par défaut
    335. 

  335.       $transaction->nbDeadLine = '1';
    336. 

  336.     }
    337. 

  337.     // Si la commande indique que la capture doit être différé
    338. 

  338.     if(isset($order->options['captureDelay'])){
    339. 

  339.       $transaction->captureDelay =  $order->options['captureDelay'];
    340. 

  340.     }else{
    341. 

  341.       $transaction->captureDelay =  '0';
    342. 

  342.     }
    343. 

  343.     // Gestion du mode de capture (Capture par défaut, sinon autorisation seulement)
    344. 

  344.     if( $order->options['noCapture'] == true){
    345. 

  345.       $transaction->captureMode =  self::AUTHORIZATION_ONLY;
    346. 

  346.     }
    347. 

  347.     else{
    348. 

  348.       $transaction->captureMode =  self::CATCH_PAYMENT;
    349. 

  349.     }
    350. 

  350.     // Vérification de l'option enrollement
    351. 

  351.     if (isset($order->options['refAbonnement']) && $order->options['enrollement'] == true) {
    352. 

  352.       $transaction->enrollement = true;
    353. 

  353.       $transaction->refAbonneBoutique = $order->options['refAbonnement'];
    354. 

  354.     }   
    355. 

  355.     $transaction->customerOid = $customer->oid;
    356. 

  356.     if(isset($customer->email)){
    357. 

  357.       $transaction->customerEmail = $customer->email;
    358. 

  358.     }
    359. 

  359.     if(isset($shop->class)){
    360. 

  360.       $transaction->shopClass = $shop->class;
    361. 

  361.     }
    362. 

  362.     // Paramètres de traitement de la réponse.
    363. 

  363.     $transaction->autoResponseMode = $shop->autoResponseMode;
    364. 

  364.     $transaction->shopCallBack = $shop->autoResponseCallBack;
    365. 

  365.     $transaction->shopName = $shop->name;
    366. 

  366.     $transaction->shopMoid = $shop->moid;
    367. 

  367.     $transaction->dateCreated = date('Y-m-d H:i:s');
    368. 

  368.     // champs plus spécifiques (pas communs à strictement toutes les vads)
    369. 

  369.     if (isset($order->options['specificsfields'])){
    370. 

  370.       if (isset($order->options['specificsfields']['transId'])){
    371. 

  371. 	$transaction->transId = $order->options['specificsfields']['transId'];
    372. 

  372.       }
    373. 

  373.     }
    374. 

  374.     // Créer la transaction en base et récupère son oid pour les paramètres d'appel.
    375. 

  375.     $transaction->oid = $this->insertWebPayment($transaction);
    376. 

  376.     // Tentative de crétion du formulaire.
    377. 

  377.     try{
    378. 

  378.       // Appel au module concerné
    379. 

  379.       list($transaction, $formulaireAppel, $template, $tplentry) = $this->webPaymentHandling($transaction);
    380. 

  380.       $returnValue = array('ok', $formulaireAppel, $template, $tplentry, $transaction->oid);
    381. 

  381. 

  382.     } catch(Exception $e){
    383. 

  383.       $transaction->status = self::ERROR;
    384. 

  384.       $transaction->statusComplement = $e->getMessage().' '.$e->getCode();
    385. 

  385.       XLogs::critical(get_class($this).' ::paymentCall ',XLabels::getSysLabel('xmodmonetique','exceptionPaymentCall').$transaction->statusComplement);
    386. 

  386.      
    387. 

  387.       $transactionParams = (array) $transaction;
    388. 

  388.       $transactionParams['_options'] = array('local'=>1);
    389. 

  389.       $transactionParams['options'] = array('callParms'=>array('raw'=>true,'toxml'=>true));
    390. 

  390.       $this->xset->procEdit($transactionParams);
    391. 

  391.       throw new Exception(get_class($this).' ::paymentCall : '.$transaction->statusComplement);
    392. 

  392.     }
    393. 

  393. 

  394.     // Mémorisation de la date d'émission
    395. 

  395.     $transaction->dateTimeOut = date('Y-m-d H:i:s');
    396. 

  396.     // Gestion de l'enrollement.
    397. 

  397.     if (isset($order->options['refAbonnement']) && $order->options['enrollement'] == true) {
    398. 

  398.       $transaction->refAbonnement = $order->options['refAbonnement'];
    399. 

  399.       $this->insertAbonne($transaction); 
    400. 

  400.     }
    401. 

  401.     // Enregistrement des paramètres d'appel
    402. 

  402.     $transactionParams = (array) $transaction;
    403. 

  403.     $transactionParams['_options'] = array('local'=>1);
    404. 

  404.     $transactionParams['options'] = array('callParms'=>array('raw'=>true,'toxml'=>true));
    405. 

  405.     $this->xset->procEdit($transactionParams);
    406. 

  406.     return $returnValue;
    407. 

  407.   }
    408. 

  408. 

  409.   /**
    410. 

  410.    * \brief Fonction de traitement du retour banque automatique.
    411. 

  411.    * Cette fonction permet de faire le traitement du retour banque en passant par le module approprié.
    412. 

  412.    * \exception:
    413. 

  413.    * - Transaction introuvable.
    414. 

  414.    * - Montant d'appel et de réponse incohérents.
    415. 

  415.    * - Nombre de retour Paybox supérieur à 3.
    416. 

  416.    * - Trop grand nombre de retour pour une transaction.
    417. 

  417.    * \todo 
    418. 

  418.    * - Exception si une transaction d'un module différent de paybox possède un statut différent de running. Ce cas se présente quand :
    419. 

  419.    *  - Une réponse à déjà été reçue.
    420. 

  420.    * \return boolean : True (Pour un succès) ou False ( Error : \link webPaymentUnFoldReponse() \endlink )
    421. 

  421.    * \note
    422. 

  422.    * - Traite la réponse avec le module approprié. \link webPaymentUnFoldReponse() \endlink. 
    423. 

  423.    * - Si l'oid de la transaction est introuvable, elle crée une nouvelle transaction pour mémoriser le paramètres reçus et lève une exception.
    424. 

  424.    * - Récupère les informations de la transaction d'origine. \link getTransaction($transactionOid) \endlink
    425. 

  425.    * - Lève une exception si une transaction d'un module différent de paybox possède un statut différent de running.
    426. 

  426.    * - Lève une exception si il y a une incohérence du montant, entre les paramètres d'appel et de réponse du serveur bancaire.
    427. 

  427.    * - Mémorise le retour.
    428. 

  428.    * - Gestion de l'enrollement. \link editAbonne($transaction) \endlink. 
    429. 

  429.    * - Recupère tous les champs de la transaction non renseigné dans la reponse.
    430. 

  430.    * - Si la signature est vérifié, gestion de la notification boutique.
    431. 

  431.    * \todo Voir l'équivalent de instanceof pour voir si une classe appartient à une classe mère (pour Paybox).
    432. 

  432.    */
    433. 

  433.   public function autoresponse() { 
    434. 

  434.     // Tentative de traitement de la réponse par le module approprié
    435. 

  435.     try{
    436. 

  436.       $transaction = $this->webPaymentUnFoldReponse();
    437. 

  437.       $ret = array(true, $transaction->oid);
    438. 

  438.     }catch(Exception $e){
    439. 

  439.       // Erreur de traitement de la réponse
    440. 

  440.       $transaction->status = self::ERROR;
    441. 

  441.       $transaction->statusComplement = 'Message : '.$e->getMessage().' Code : '.$e->getCode();
    442. 

  442.       $transactionParams = (array) $transaction;
    443. 

  443.       $transactionParams['_options'] = array('local'=>1);
    444. 

  444.       $transactionParams['options'] = array('callParms'=>array('raw'=>true,'toxml'=>true));
    445. 

  445.       $this->xset->procEdit($transactionParams);
    446. 

  446.       XLogs::critical(get_class($this).' ::autoresponse ' , $transaction->statusComplement);
    447. 

  447.       return false;
    448. 

  448.     }
    449. 

  449.     XLogs::critical(get_class($this).' ::autoresponse ', print_r($transaction, true));
    450. 

  450.     // Vérification de la réponse de la banque
    451. 

  451.     if($transaction->responseCode == '00'){
    452. 

  452.       $transaction->status = self::SUCCESS;
    453. 

  453.     }
    454. 

  454.     else{
    455. 

  455.       $transaction->status = self::ERROR;
    456. 

  456.     }
    457. 

  457.     // Si l'oid de la transaction n'a pas été trouvé par le module approprié, on crée une nouvelle transaction pour mémoriser le paramètres reçus.
    458. 

  458.     if ($transaction->oid == null){
    459. 

  459.       $transaction->statusComplement .= XLabels::getSysLabel('xmodmonetique','exceptionUnknowTransaction');
    460. 

  460.       $paramToMemorize = (array) $transaction;
    461. 

  461.       $paramToMemorize['options'] = array('responseParms'=>array('raw'=>true,'toxml'=>true));
    462. 

  462.       $r = $this->xset->procInput( (array) $paramToMemorize);
    463. 

  463.       XLogs::critical(get_class($this).' ::autoresponse '. XLabels::getSysLabel('xmodmonetique','exceptionUnknowTransaction'), print_r($transaction, true));
    464. 

  464.       // En cas de problème d'insertion de cette réponse, on log les paramètres reçus
    465. 

  465.       if (empty($r)) {
    466. 

  466. 	XLogs::critical(get_class($this).' ::autoresponse : Problème d\'insertion de la transaction : ', print_r($transaction, true));
    467. 

  467.       }
    468. 

  468.       throw new Exception(get_class($this).' ::autoresponse :'.XLabels::getSysLabel('xmodmonetique','exceptionUnknowTransaction'));
    469. 

  469.     }
    470. 

  470.     // Si la transaction à été trouvée, on récupère les informations de la transaction d'origine
    471. 

  471.     $paramsOri = $this->getTransaction($transaction->oid);
    472. 

  472.     // Incrémentation du nombre de retour (3 maximum pour un paiement Web)
    473. 

  473.     if(empty($paramsOri->nbReturn)){
    474. 

  474.       $transaction->nbReturn = 1; ///< Premier retour 
    475. 

  475.     }else{
    476. 

  476.       $transaction->nbReturn++; ///< Retours suivants
    477. 

  477.     }
    478. 

  478.     // Si le nombres de retour Paybox est supérieur à 3 on lève une exception
    479. 

  479.     if ( (($transaction->nbReturn > 3) && ($transaction->nbDeadLine == 1) || ($transaction->nbReturn > $transaction->nbDeadLine+2 )  ) && ((get_class($this)=='XModPaybox') || ($this instanceof XModPaybox == 1)) ){ 
    480. 

  480.       XLogs::update('update', $transaction->oid, $this->array2html($transaction->responseParms, true));
    481. 

  481.       XLogs::critical(get_class($this)."::autoresponse ".XLabels::getSysLabel('xmodmonetique','overmuchResponse'), print_r($transaction, true));
    482. 

  482.       throw new Exception(get_class($this).' ::autoresponse '.XLabels::getSysLabel('xmodmonetique','overmuchResponse').$transaction->oid);
    483. 

  483.     }
    484. 

  484.     // Si une transaction d'un module différent de paybox possède un statut différent de running (C'est qu'une réponse à déjà été reçu, ou qu'elle comportait une erreur de paramètre), donc on lève une execption  
    485. 

  485.     if ( ( ($paramsOri->status != self::RUNNING) && ($paramsOri->nbDeadLine < $transaction->nbReturn))  && ((get_class($this)!='XModPaybox') &&  ($this instanceof XModPaybox != 1)) ) {
    486. 

  486.       $transaction->autoResponseMode = self::RESPONSE_NONE;
    487. 

  487.       $transaction->statusComplement = 'Erreur, trop de retour pour cette transaction on déjà été traité : '.$transaction->status.'/'.$transaction->statusComplement;
    488. 

  488.       // on garde la "reponse" dans les log de la transaction
    489. 

  489.       XLogs::update('update', $transaction->oid, print_r($transaction->responseParms, true));
    490. 

  490.       XLogs::critical(get_class($this).' ::autoresponse '.$transaction->statusComplement, print_r($transaction, true));
    491. 

  491.       throw new Exception('::autoresponse '.$transaction->statusComplement);
    492. 

  492.     }     
    493. 

  493. 

  494.     XLogs::critical(get_class($this).' ::autoresponse->transaction(initialiser par unfold) ', print_r($transaction, true));
    495. 

  495.     XLogs::critical(get_class($this).' ::autoresponse params ori', print_r($paramsOri, true));
    496. 

  496. 

  497.     // Paypal ne fournisant pas le montant total pour un paiement multiple, il faut recalculer le montant de l'échéance
    498. 

  498.     if($paramsOri->nbDeadLine > 1){
    499. 

  499.       if((get_class($this)=='XModPaypal') || ($this instanceof XModPaypal == 1)){
    500. 

  500. 	$montant = $paramsOri->amount / $paramsOri->nbDeadLine; 
    501. 

  501. 	$montant = round($montant , 2);
    502. 

  502. 	// Calcule de la différence du aux arrondis
    503. 

  503. 	$diff= $paramsOri->amount - ($montant* $paramsOri->nbDeadLine); 
    504. 

  504. 	if( !empty($transaction->responseParms['mc_amount1']) && ($transaction->responseParms['mc_amount1']==$montant+$diff) && ($transaction->responseParms['mc_amount1']==$montant) ){
    505. 

  505. 	  $transaction->amount= $paramsOri->amount;
    506. 

  506. 	  XLogs::critical(get_class($this).' ::autoresponse ', 'Montants OK');
    507. 

  507. 	}else{
    508. 

  508. 	  list($firstDeadLine,$otherDeadLine) = $this->getAmountDeadLine($transaction->oid);
    509. 

  509. 	  if(  $transaction->amount==$firstDeadLine || $transaction->amount==$otherDeadLine){
    510. 

  510. 	    $transaction->amount= $paramsOri->amount;
    511. 

  511. 	  }
    512. 

  512. 	}
    513. 

  513.       }
    514. 

  514.     }
    515. 

  515.     // Vérification de la cohérence du montant, entre les paramètres d'appel et de réponse du serveur bancaire
    516. 

  516.     if (!$this->checkResponseAmount($transaction->amount, $paramsOri->amount)){
    517. 

  517.       $amountCall = XLabels::getSysLabel('xmodmonetique','amountCall').$paramsOri->amount;
    518. 

  518.       $amountResponse =XLabels::getSysLabel('xmodmonetique','amountResp').$transaction->amount ;
    519. 

  519.       $transaction->statusComplement = XLabels::getSysLabel('xmodmonetique','errorAmount').$amountCall.' : '.$amountResponse;
    520. 

  520.       $this->xset->procEdit(array('_options'=>array('local'=>1),
    521. 

  521. 				  'oid'=> $transaction->oid,
    522. 

  522. 				  'responseParms'=>$transaction->responseParms,
    523. 

  523. 				  'status'=>self::ERROR,
    524. 

  524. 				  'dateTimeIn'=>date('Y-m-d H:i:s'),
    525. 

  525. 				  'statusComplement'=>$transaction->statusComplement,
    526. 

  526. 				  'nbReturn'=>$transaction->nbReturn,
    527. 

  527. 				  'responseStatus'=>'NA'
    528. 

  528. 				  ));
    529. 

  529.       XLogs::critical(get_class($this)."::autoresponse ",  $transaction->statusComplement);
    530. 

  530.       throw new Exception(get_class($this).' ::autoresponse '.$transaction->statusComplement);
    531. 

  531.     }
    532. 

  532.     // Affectation du libellé du code erreur dans le statusComplement si il est vide
    533. 

  533.     if(empty( $transaction->statusComplement)){
    534. 

  534.       $transaction->statusComplement = $this->getErrorCode($transaction->responseCode);
    535. 

  535.     }
    536. 

  536.     // Mémorisation de la réponse
    537. 

  537.     $transaction->dateTimeIn = date('Y-m-d H:i:s');
    538. 

  538.     $infosToMemorize = (array) $transaction;
    539. 

  539.     $infosToMemorize['_options'] = array('local'=>1);
    540. 

  540.     $infosToMemorize['options'] = array('responseParms'=>array('raw'=>true,'toxml'=>true));
    541. 

  541.     $this->xset->procEdit($infosToMemorize);
    542. 

  542.     // Récupération des informations d'origine afin de traiter l'enrollement s'il y a lieu
    543. 

  543.     foreach ($paramsOri as $key => $value){
    544. 

  544.       // On vérifie que le champs est vide afin de ne pas écraser d'informations.
    545. 

  545.       if(empty($transaction->$key)){
    546. 

  546. 	$transaction->$key = $value;
    547. 

  547.       }
    548. 

  548.     }
    549. 

  549.     // Si la transaction d'origine indique qu'il faut mettre à jour la table des enrollements
    550. 

  550.     if (!empty($transaction->refAbonneBoutique)){
    551. 

  551.       // Si la transaction est un echec on le mémorise également dans la table des enrollements
    552. 

  552.       if($transaction->status != self::SUCCESS){
    553. 

  553. 	$transaction->porteur= XLabels::getSysLabel('xmodmonetique','enrollementError');
    554. 

  554. 	$transaction->dateVal = XLabels::getSysLabel('xmodmonetique','enrollementError');
    555. 

  555. 	$transaction->cvv = XLabels::getSysLabel('xmodmonetique','enrollementError'); 
    556. 

  556. 	$transaction->numCarte = XLabels::getSysLabel('xmodmonetique','enrollementError');
    557. 

  557.       }
    558. 

  558.       // Mise à jour de l'enrollement
    559. 

  559.       $this->editAbonne($transaction); 
    560. 

  560.     }
    561. 

  561.     // Si nécessaire on notifie le retour à la boutique
    562. 

  562.     if ($transaction->autoResponseMode === self::SYNC_RESPONSE){
    563. 

  563.       $this->notifyShop($transaction);
    564. 

  564.     } 
    565. 

  565.     // Sinon on valorise le statut de réponse à : RESPONSE_STATUS_TO_SEND, afin qu'il soit traité de manière asynchrone
    566. 

  566.     elseif($transaction->autoResponseMode === self::ASYNC_RESPONSE){
    567. 

  567.       $this->xset->procEdit(array('_options'=>array('local'=>true), 'oid'=>$transaction->oid, 'responseStatus'=>self::RESPONSE_STATUS_TO_SEND));  
    568. 

  568.     }
    569. 

  569.     $GLOBALS['XSHELL']->response = (object)array('complete' => true, 'content' => '');
    570. 

  570.     return true;
    571. 

  571.   }
    572. 

  572.  
    573. 

  573.   /**
    574. 

  574.    * \brief Fonction d'insertion d'une transaction en base.
    575. 

  575.    * Cette fonction permet d'inserer une transaction avant l'appel en banque.
    576. 

  576.    * \param MTransaction $transaction : La transaction paramètré par paymentCall.
    577. 

  577.    * \return String Oid de la transaction associée à ce paiement.
    578. 

  578.    */
    579. 

  579.   protected function insertWebPayment(MTransaction $transaction){
    580. 

  580.     $transaction->monetiqueMoid = $this->_moid;
    581. 

  581.     $transaction->responseStatus = self::RESPONSE_NONE;
    582. 

  582.     $r = $this->xset->procInput( (array) $transaction);
    583. 

  583.     if (empty($r)) {
    584. 

  584.       XLogs::critical(get_class($this).XLabels::getSysLabel('xmodmonetique','errorInsertWebPayment'), print_r($transactionParams, true));
    585. 

  585.       ;
    586. 

  586.     }
    587. 

  587.     return $r['oid'];
    588. 

  588.   }
    589. 

  589. 

  590.   /**
    591. 

  591.    * \brief Fonction de création d'un abonné.
    592. 

  592.    * Cette fonction permet d'inserer un nouvel abonné avant l'appel en banque.
    593. 

  593.    * \param MTransaction $transaction : La transaction contenant les paramètres d'enrollement :
    594. 

  594.    * - $transaction->customerOid. \link MTransaction::$customerOid \endlink
    595. 

  595.    * - $transaction->refAbonneBoutique.  \link MTransaction::$refAbonneBoutique \endlink
    596. 

  596.    * - $transaction->oid']. \link MTransaction::$oid \endlink
    597. 

  597.    * \note
    598. 

  598.    * - Récupère la table des abonnés.
    599. 

  599.    * - Prépare les paramètres à mémoriser.
    600. 

  600.    * - Insère les informations.
    601. 

  601.    * \return String Oid du nouvel enrollement.
    602. 

  602.    */
    603. 

  603.   protected function insertAbonne($transaction) {
    604. 

  604.     // Récupération de la table des abonnés
    605. 

  605.     $tableAbonne = XDataSource::objectFactoryHelper8('BCLASS=XDSTable&SPECS='.'ENROMONETIQUE');   
    606. 

  606.     // Préparation des paramètres à mémoriser
    607. 

  607.     $infosAbonne = array(
    608. 

  608. 			 'customerOid' => $transaction->customerOid,
    609. 

  609. 			 'refAbonne'=> $transaction->refAbonneBoutique,
    610. 

  610. 			 'transOri' => $transaction->oid
    611. 

  611. 			 );
    612. 

  612.     // Insertion des informations
    613. 

  613.     $r = $tableAbonne->procInput($infosAbonne);
    614. 

  614.     if (empty($r)) {
    615. 

  615.       XLogs::critical(get_class($this).XLabels::getSysLabel('xmodmonetique','errorInsertAbonne'), print_r($infosAbonne), true);
    616. 

  616.     }
    617. 

  617.     return $r['oid'];
    618. 

  618.   }
    619. 

  619.   
    620. 

  620.   /**
    621. 

  621.    * \brief Fonction de mise à jour d'un abonné.
    622. 

  622.    * Cette fonction permet de mettre à jour un abonné à la suite d'un retour banque.
    623. 

  623.    * \param MTransaction $transaction : La transaction donné par le retour banque.
    624. 

  624.    * - Doit contenir:
    625. 

  625.    *  - $transaction->customerOid. \link MTransaction::$customerOid \endlink
    626. 

  626.    *  - $transaction->refAbonneBoutique. \link MTransaction::$refAbonneBoutique \endlink
    627. 

  627.    * \note
    628. 

  628.    * - Récupère la table des abonnés.
    629. 

  629.    * - Vérifie que l'enrollement à été créé avant l'appel en banque.
    630. 

  630.    * - Prépare les paramètres à mémoriser
    631. 

  631.    * - Insère les informations.
    632. 

  632.    * \return String Oid du nouvel enrollement.
    633. 

  633.    */
    634. 

  634.   protected function editAbonne($transaction) {
    635. 

  635.     // Récupération de la table des abonnés
    636. 

  636.     $tableAbonne = XDataSource::objectFactoryHelper8('BCLASS=XDSTable&SPECS='.'ENROMONETIQUE');
    637. 

  637.     // On vérifie que l'enrollement à été créé avant l'appel bancaire
    638. 

  638.     $custEnro =  $this->getEnrollement($transaction->customerOid,$transaction->refAbonneBoutique);
    639. 

  639.     if(!empty($custEnro)){
    640. 

  640.       // Préparation des paramètres à mémoriser
    641. 

  641.       $lar = array('_options'=>array('local'=>1),
    642. 

  642. 		   'oid'=>$custEnro->KOID,
    643. 

  643. 		   'refAbonne'=>$transaction->refAbonneBoutique,
    644. 

  644. 		   'customerOid'=> $transaction->customerOid,
    645. 

  645. 		   'porteur'=>$transaction->porteur,
    646. 

  646. 		   'dateVal'=>$transaction->dateVal,
    647. 

  647. 		   'cvv'=>$transaction->cvv,
    648. 

  648. 		   'numCarte'=>$transaction->numCarte,
    649. 

  649. 		   );
    650. 

  650.       // Insertion des informations
    651. 

  651.       $r = $tableAbonne->procEdit($lar);
    652. 

  652.       if (empty($r)) {
    653. 

  653. 	XLogs::critical(get_class($this).' ::editAbonne : '.XLabels::getSysLabel('xmodmonetique','errorUpdateAbonne'), print_r($lar), true);
    654. 

  654.       }
    655. 

  655.     }
    656. 

  656.     else{
    657. 

  657.       XLogs::critical(get_class($this).XLabels::getSysLabel('xmodmonetique','errorUnknowAbonne'), print_r($transaction), true);
    658. 

  658.     }    
    659. 

  659.     return $r['oid'];
    660. 

  660.   }
    661. 

  661. 

  662.   /**********************************************************
    663. 

  663.    *************** Fonctions de remboursement ***************
    664. 

  664.    *********************************************************/
    665. 

  665. 

  666.   /**
    667. 

  667.    * \brief Fonction création d'un remboursement.
    668. 

  668.    * Cette fonction permet de mettre à jour un abonné à la suite d'un retour banque.
    669. 

  669.    * \param String $transactionOriginOid : Identifiant de la transaction d'origine. \link MTransaction::$oid \endlink
    670. 

  670.    * \param MOrderInfos $order : Commande à l'origine du remboursement, avec le montant du remboursement.
    671. 

  671.    * - $order->amount est obligatoire.\link MOrderInfos::$amount \endlink
    672. 

  672.    * \param MShopInfos $shop : Comporte les paramètres de la boutique (autoResponseCallBack, autoResponseMode, ...).\link MShopInfos \endlink
    673. 

  673.    * \return Array :
    674. 

  674.    * - String ok/ko.
    675. 

  675.    * - String oid de la nouvelle transaction. \link MTransaction::$oid \endlink
    676. 

  676.    * \exception: 
    677. 

  677.    * - Error : \link refundHandling(& $transaction) \endlink.
    678. 

  678.    * - Impossible de trouver la transaction d'origine.
    679. 

  679.    * - Si $order->amount n'est pas initialisé. \link MOrderInfos::$amount \endlink
    680. 

  680.    * - Si la signature est invalide, levée par \link refundHandling(& $transaction) \endlink
    681. 

  681.    * \note
    682. 

  682.    * - Si $transactionOriginOid (\link MTransaction::$oid \endlink) est null, cherche la transaction à partir de l'order->reference (\link MTransaction::$reference \endlink).
    683. 

  683.    * - Vérification que le montant à rembourser à été saisi.
    684. 

  684.    * - Initialise les paramètres de base de la nouvelle transaction.
    685. 

  685.    * - Copie les informations manquantes à partir de la transaction d'origine.
    686. 

  686.    * - Crée la transaction en base. \link insertRefund ($transaction, $shop) \endlink. 
    687. 

  687.    * - Formate le montant passé en paramètres. \link formatOrderAmount($amount); \endlink
    688. 

  688.    * - Met à jour les attributs de $newTransaction. \link refundHandling(& $transaction) \endlink.
    689. 

  689.    * - Mémorise les données brutes de reponse et le status.
    690. 

  690.    * - Si la signature est vérifié, gestion de la notification boutique.
    691. 

  691.    * \see
    692. 

  692.    * - getIdTransactionWithOrderRef($orderReference);
    693. 

  693.    * - getTransaction ($transactionOid);
    694. 

  694.    * - refundHandling(& $transaction);
    695. 

  695.    * \todo Factoriser le contrôle du montant dans monétique
    696. 

  696.    */
    697. 

  697.   public function refundCall($transactionOriginOid, $order, $shop){
    698. 

  698.     // Recherche la transaction d'origine
    699. 

  699.     // Si l'on ne possède que l'order->reference, on cherche la transaction à partir de celui-ci
    700. 

  700.     if(!empty($order->reference) && empty($transactionOriginOid)){
    701. 

  701.       // Récupération de l'oid de la transaction d'origine
    702. 

  702.       $transactionOriginOid = $this->getIdTransactionWithOrderRef($order->reference); 
    703. 

  703.       // Récupération de toutres les infos relatives à cette transaction
    704. 

  704.       $transactionOrigin = $this->getTransaction($transactionOriginOid);
    705. 

  705.       // Mémorisation de l'oid d'origine
    706. 

  706.       $transactionOrigin->oid = $transactionOriginOid; 
    707. 

  707.     }
    708. 

  708.     // Sinon on cherche la transaction à partir de son oid
    709. 

  709.     else if(!empty($transactionOriginOid)){
    710. 

  710.       // Récupération de toutres les infos relatives à cette transaction
    711. 

  711.       $transactionOrigin = $this->getTransaction($transactionOriginOid);
    712. 

  712.       // Mémorisation de l'oid d'origine
    713. 

  713.       $transactionOrigin->oid = $transactionOriginOid; 
    714. 

  714.     }
    715. 

  715.     // Problème de paramètres, impossible de trouver la transaction d'origine
    716. 

  716.     if(empty($transactionOrigin->oid)){
    717. 

  717.       throw new Exception(get_class($this).' ::refundCall '.XLabels::getSysLabel('xmodmonetique','exceptionUnknowTransaction').' Order reference : '.$order->reference.' Transaction oid : '.$transactionOriginOid);
    718. 

  718.     }    
    719. 

  719.     // Vérification que le montant à rembourser à été saisi
    720. 

  720.     if(empty($order->amount)){
    721. 

  721.       throw new Exception(get_class($this).' ::refundCall :'.XLabels::getSysLabel('xmodmonetique','noAmount'));
    722. 

  722.     }    
    723. 

  723.     /* Initialisation des paramètres de base de la nouvelle transaction */
    724. 

  724.     // Mémorisation de la transaction d'origine
    725. 

  725.     $newTransaction->transOri = $transactionOrigin->oid;
    726. 

  726.     // Affectation de la date de création du remboursement
    727. 

  727.     $newTransaction->dateCreated =  date('Y-m-d H:i:s');
    728. 

  728.     // Affectation du montant à rembourser 
    729. 

  729.     $newTransaction->amount = $order->amount; 
    730. 

  730.     // Récupération de l'oid de la commande à remboursée
    731. 

  731.     $newTransaction->orderOid = $transactionOrigin->orderOid;
    732. 

  732.     // Génération de la référence de la commande de remboursement
    733. 

  733.     $newTransaction->orderReference = 'N/A'; //$this->genOrderRef('Y%m%d%H%i%s');
    734. 

  734.     // Le remboursement est immédiat
    735. 

  735.     $newTransaction->captureMode = self::CATCH_PAYMENT;
    736. 

  736.     // Le traitement est en cours
    737. 

  737.     $newTransaction->status = self::RUNNING;
    738. 

  738.     // Le type de transaction est un remboursement
    739. 

  739.     $newTransaction->type = self::REFUND;
    740. 

  740.     // Il n'y a pas de dalai, si c'est faisable, on le fait
    741. 

  741.     $newTransaction->captureDelay = 0;
    742. 

  742.     // Récupération de l'oid du client à remboursée
    743. 

  743.     $newTransaction->customerOid = $transactionOrigin->customerOid;
    744. 

  744.     // On regarde s'il y a des infos supplémentaires au sujet du client
    745. 

  745.     if(isset($transactionOrigin->refAbonneBoutique)){
    746. 

  746.       $newTransaction->refAbonneBoutique = $transactionOrigin->refAbonneBoutique;
    747. 

  747.     }
    748. 

  748.     if(isset($transactionOrigin->customerEmail)){
    749. 

  749.       $newTransaction->customerEmail = $transactionOrigin->customerEmail;
    750. 

  750.     }
    751. 

  751.     /* Paramètres de la boutique */
    752. 

  752.     // On mémorise dans la transaction le mode de réponse attendu par la boutique.
    753. 

  753.     $newTransaction->autoResponseMode = $shop->autoResponseMode;
    754. 

  754.     // On mémorise dans la transaction la fonction de traitement de la reponse attendu par la boutique.
    755. 

  755.     $newTransaction->shopCallBack = $shop->autoResponseCallBack;
    756. 

  756.     $newTransaction->monetiqueMoid = $this->_moid;
    757. 

  757.     $newTransaction->shopMoid = $shop->moid;
    758. 

  758.     $newTransaction->shopName = $shop->name;
    759. 

  759.     $newTransaction->shopClass = $shop->class;
    760. 

  760.     // Tant qu'on n'a pas de réponse on ne cherche pas à notifier la boutique
    761. 

  761.     $newTransaction->responseStatus = self::RESPONSE_NONE;
    762. 

  762.     // Créer la transaction en base. On a besoin de son oid pour les paramètres d'appel
    763. 

  763.     $newTransaction->oid = $this->insertRefund($newTransaction, $shop);
    764. 

  764.     // Traiter la requête
    765. 

  765.     try{
    766. 

  766.       // Cette méthode retourne la transaction après l'appel en banque
    767. 

  767.       $transaction = $this->refundHandling($newTransaction);
    768. 

  768.       $returnValue = array('ok', $newTransaction->oid);
    769. 

  769.     } 
    770. 

  770.     catch(Exception $e){
    771. 

  771.       XLogs::critical(get_class($this).'::refundCall ',print_r($newTransaction,true) );
    772. 

  772.       $newTransaction->status = self::ERROR;
    773. 

  773.       XLogs::critical(get_class($this), '::refundCall -> ::refundHandling '.$e->getMessage().' Code '.$e->getCode());
    774. 

  774.       $newTransaction->statusComplement = $e->getMessage();
    775. 

  775.       // Mémorise les données brutes de reponse et le status
    776. 

  776.       $this->xset->procEdit(array('_options'=>array('local'=>1),
    777. 

  777. 				  'oid'=>$newTransaction->oid,
    778. 

  778. 				  'responseParms'=>$newTransaction->responseParms,
    779. 

  779. 				  'status'=> $newTransaction->status,
    780. 

  780. 				  'dateTimeIn'=>date('Y-m-d H:i:s'),
    781. 

  781. 				  'statusComplement'=> $newTransaction->statusComplement,
    782. 

  782. 				  'responseCode'=>$newTransaction->responseCode,
    783. 

  783. 				  'options'=>array('responseParms'=>array('raw'=>true,'toxml'=>true))
    784. 

  784. 				  ));
    785. 

  785.       $returnValue = array('ko', $newTransaction->oid);
    786. 

  786.       throw new Exception(get_class($this).' ::refundCall : '.$newTransaction->statusComplement);
    787. 

  787.     }
    788. 

  788.     XLogs::critical(get_class($this).' ::refundCall', print_r($transaction,true));
    789. 

  789.     // Mémorise les données brutes de reponse et le status
    790. 

  790.     $this->xset->procEdit(array('_options'=>array('local'=>1),
    791. 

  791. 				'oid'=>$transaction->oid,
    792. 

  792. 				'responseParms'=>$transaction->responseParms,
    793. 

  793. 				'status'=> $transaction->status,
    794. 

  794. 				'dateTimeIn'=>date('Y-m-d H:i:s'),
    795. 

  795. 				'statusComplement'=> $transaction->statusComplement,
    796. 

  796. 				'responseCode'=>$transaction->responseCode,
    797. 

  797. 				'options'=>array('responseParms'=>array('raw'=>true,'toxml'=>true))
    798. 

  798. 				));
    799. 

  799.     // si nécessaire notifier le retour à la boutique
    800. 

  800.     if ($newTransaction->autoResponseMode === self::SYNC_RESPONSE){
    801. 

  801.       $this->notifyShop($newTransaction);
    802. 

  802.     } 
    803. 

  803.     // Sinon mise à jour pour traitement asynchrone
    804. 

  804.     elseif($newTransaction->autoResponseMode === self::ASYNC_RESPONSE){
    805. 

  805.       $this->xset->procEdit(array('_options'=>array('local'=>true), 
    806. 

  806. 				  'oid'=>$newTransaction->oid, 
    807. 

  807. 				  'responseStatus'=>self::RESPONSE_STATUS_TO_SEND
    808. 

  808. 				  ));  
    809. 

  809.     }
    810. 

  810.     return $returnValue;
    811. 

  811.   }
    812. 

  812. 

  813.   /**
    814. 

  814.    * \brief Fonction d'insertion d'un remboursement en base.
    815. 

  815.    * Cette fonction permet d'inserer une transaction avant l'appel en banque.
    816. 

  816.    * \param MTransaction $transaction : Contient les informations relatives au remboursement. \link MTransaction \endlink
    817. 

  817.    * \return String Oid de la transaction associée à ce remboursement.  \link MTransaction::$oid \endlink
    818. 

  818.    */
    819. 

  819.   protected function insertRefund($transaction, $shop){
    820. 

  820.     $r = $this->xset->procInput( (array) $transaction);
    821. 

  821.     if (empty($r)) {
    822. 

  822.       XLogs::critical(get_class($this).' ::insertRefund :'.XLabels::getSysLabel('xmodmonetique','noAmount'), print_r($infosToMemorize), true);
    823. 

  823.     }
    824. 

  824.     return $r['oid'];
    825. 

  825.   }
    826. 

  826. 

  827.   /**
    828. 

  828.    * \brief Fonction de ré-émission des remboursements ayant le status waitting.
    829. 

  829.    * Cette fonction permet de rejouer les remboursement en attente.
    830. 

  830.    * \return Array :
    831. 

  831.    * - Int $nbTotal : Nombre total de transactions rejouée.
    832. 

  832.    * - Int $nbSucces : Nombre total de succès.
    833. 

  833.    * - Array $error : Le details des erreurs (statusComplement de chaque transaction échouée).
    834. 

  834.    * \throws: 
    835. 

  835.    * - Error : \link refundHandling(& $transaction) \endlink.
    836. 

  836.    * - Impossible de trouver la transaction d'origine.
    837. 

  837.    * \note
    838. 

  838.    * - Séléctionne des transaction à rejouer.
    839. 

  839.    * - Pour chaque transaction :
    840. 

  840.    *  - Formate le montant de la transaction en centimes.
    841. 

  841.    *  - Transforme les paramètres d'appels mémorisés en XML en tableau associatif.
    842. 

  842.    *  - Appel à la fonction refundReplay spécifique au module de la transaction.
    843. 

  843.    *  - Mémorise la réponse et les paramètres de la transaction.
    844. 

  844.    *  - Si la signature est vérifié, gestion de la notification boutique.
    845. 

  845.    * \see
    846. 

  846.    * - XModMonetique::refundReplay(& $transaction);
    847. 

  847.    */
    848. 

  848.   public function refundAsyncHandling(){
    849. 

  849.     // Séléction des transaction à rejouer
    850. 

  850.     $rs = selectQuery('select * from '.$this->xset->getTable().' where status = "'.self::WAITTING.'" and type = "'.self::REFUND.'" and monetiqueMoid =  "'.$this->_moid.'" ');
    851. 

  851.     // Initialisation des variables locales
    852. 

  852.     $nbTotal = $rs->rowcount();
    853. 

  853.     $nbSucces = '0';
    854. 

  854.     $error = array();
    855. 

  855.     // Tant qu'il y a des transactions à rejouer
    856. 

  856.     while($ors = $rs->fetch()){
    857. 

  857.       foreach ($ors as $key => $value){
    858. 

  858. 	// Si c'est le montant on le formate en centimes et on le mémorise dans la transaction
    859. 

  859. 	$transaction->$key = $value;
    860. 

  860.       }
    861. 

  861.       // On transforme les paramètres d'appels mémorisés en XML en tableau associatif
    862. 

  862.       $transaction->callParms = XSystem::xml2array($transaction->callParms);	
    863. 

  863.       // Appel à la fonction refundReplay spécifique au module de la transaction
    864. 

  864.       $transaction = $this->refundReplay($transaction);
    865. 

  865.       // Mémorise la réponse et les paramètres de la transaction
    866. 

  866.       $this->xset->procEdit(array(
    867. 

  867. 				  '_options'=>array('local'=>1),
    868. 

  868. 				  'oid'=>$transaction->KOID,
    869. 

  869. 				  'responseParms'=>$transaction->responseParms,
    870. 

  870. 				  'statusComplement'=> $transaction->statusComplement,
    871. 

  871. 				  'status'=>$transaction->status,
    872. 

  872. 				  'options'=>array('responseParms'=>array('raw'=>true,'toxml'=>true))
    873. 

  873. 				  ));
    874. 

  874.       if($transaction->status == self::SUCCESS){
    875. 

  875. 	$nbSucces++;
    876. 

  876.       }else{
    877. 

  877. 	$error[$ors['KOID']][$transaction->status] = $transaction->statusComplement;
    878. 

  878.       }
    879. 

  879.       // si nécessaire notifier le retour à la boutique
    880. 

  880.       if ($ors->autoResponseMode === self::SYNC_RESPONSE){
    881. 

  881. 	$this->notifyShop($ors->oid);
    882. 

  882.       } 
    883. 

  883.       elseif($ors->autoResponseMode === self::ASYNC_RESPONSE){
    884. 

  884. 	$this->xset->procEdit(array('_options'=>array('local'=>true), 'oid'=>$ors->oid, 'responseStatus'=>self::RESPONSE_STATUS_TO_SEND));  
    885. 

  885.       }
    886. 

  886.     }
    887. 

  887.     return array($nbTotal, $nbSucces, $error);
    888. 

  888.   }
    889. 

  889. 

  890.   /* Fonctions de débit forcé d'un abonné */
    891. 

  891.   
    892. 

  892.   /**
    893. 

  893.    * \brief Fonction de génération des données de prelevement.
    894. 

  894.    * Cette fonction permet de dupliquer un paiement à partir d'un paiement web ayant généré un enrollement.
    895. 

  895.    * \param MOrderInfos $order : Commande relative à la duplication, avec le montant de la duplication. 
    896. 

  896.    * - $order->amount est obligatoire.
    897. 

  897.    * \param MCustomerInfos $customer : Le client qui va être débité.
    898. 

  898.    * - $customer->oid et $customer->refAbonne sont obligatoire.
    899. 

  899.    * \param MShopInfos $shop : Comporte les paramètres de la boutique (autoResponseCallBack, autoResponseMode, ...).
    900. 

  900.    * \return MTransaction $transaction : La transaction après l'appel banque avec tous ses paramètres renseignés.
    901. 

  901.    * \exception:
    902. 

  902.    * - Error : \link refundHandling(& $transaction) \endlink
    903. 

  903.    * - Si $order->amount n'est pas initialisé. 
    904. 

  904.    * - Si \link XModMonetique::getEnrollement($customerOid,$refAbonne)  \endlink retourne null.
    905. 

  905.    * - Impossible de trouver la transaction d'origine.
    906. 

  906.    * \note
    907. 

  907.    * - Vérifie que le montant est saisi.
    908. 

  908.    * - Récupère les informations concernant l'abonné. \link getEnrollement($customerOid,$refAbonne); \endlink
    909. 

  909.    * - Initialise les paramètres de base de la nouvelle transaction.
    910. 

  910.    * - Formate le montant passé en paramètres. \link formatOrderAmount($amount); \endlink
    911. 

  911.    * - Récupère les informations de la transaction d'origine. \link getTransaction($transactionOid) \endlink
    912. 

  912.    * - Crée la transaction en base, avant l'appel en banque.  \link insertDuplicate($transaction); \endlink
    913. 

  913.    * - L'appel à \link marshallRemboursement(& $newTransaction); \endlink permet de laissé le traitement de la duplication au module concerné. Cette appel renseigne le retour dans $newTransaction.
    914. 

  914.    * - Mémorise les données brutes de reponse et le status.
    915. 

  915.    * - Si la signature est vérifié, gestion de la notification boutique.
    916. 

  916.    * \see
    917. 

  917.    * - getEnrollement($customerOid,$refAbonne);
    918. 

  918.    * - formatOrderAmount($amount);
    919. 

  919.    * - getTransaction ($transactionOid);
    920. 

  920.    * - refundHandling($transaction);
    921. 

  921.    */
    922. 

  922.   public function duplicateCall(MOrderInfos $order, MCustomerInfos $customer, MShopInfos $shop){
    923. 

  923.     // Vérification que le montant est saisi
    924. 

  924.     if(empty($order->amount)){
    925. 

  925.       throw new Exception(get_class($this).' ::duplicateCall :'.XLabels::getSysLabel('xmodmonetique','noAmount'));
    926. 

  926.     }
    927. 

  927.     // Récupération des informations concernant l'abonné
    928. 

  928.     $customerEnrollment = $this->getEnrollement($customer->oid, $customer->refAbonne);
    929. 

  929.     // Si l'abonné existe dans ENROMONETIQUE
    930. 

  930.     if (!empty($customerEnrollment)){
    931. 

  931.       $newTransaction = new MTransaction();
    932. 

  932.       // Préparation des paiement à multiples échéances
    933. 

  933.       if (isset($order->options['nbDeadLine'])) { 
    934. 

  934. 	$newTransaction->nbDeadLine = $order->options['nbDeadLine'];
    935. 

  935. 	// Définition de la fréquence de prélèvement en jours
    936. 

  936. 	if(empty($order->options['frequencyDuplicate'])){
    937. 

  937. 	  $newTransaction->frequencyDuplicate = '30';
    938. 

  938. 	}else{
    939. 

  939. 	  $newTransaction->frequencyDuplicate = $order->options['frequencyDuplicate'];
    940. 

  940. 	}
    941. 

  941. 	// Par défaut le jour de prélévement est la date courante
    942. 

  942. 	if(!empty($order->options['captureDay'])){
    943. 

  943. 	  $newTransaction->captureDay = $order->options['captureDay'];
    944. 

  944. 	}
    945. 

  945. 	else{
    946. 

  946. 	  $newTransaction->captureDay =  date('d');
    947. 

  947. 	}
    948. 

  948.       }
    949. 

  949.       // Paiement à une seule échéances par défaut
    950. 

  950.       else {
    951. 

  951. 	$newTransaction->nbDeadLine = '1';
    952. 

  952.       }
    953. 

  953.       // Si la commande indique que la capture doit être différé
    954. 

  954.       if(isset($order->options['captureDelay'])){
    955. 

  955. 	$newTransaction->captureDelay =  $order->options['captureDelay'];
    956. 

  956.       }else{
    957. 

  957. 	$newTransaction->captureDelay =  '0';
    958. 

  958.       }
    959. 

  959.       // Gestion du mode de capture (Capture par défaut, sinon autorisation seulement)
    960. 

  960.       if( $order->options['noCapture'] == true){
    961. 

  961. 	$newTransaction->captureMode =  self::AUTHORIZATION_ONLY;
    962. 

  962.       }
    963. 

  963.       else{
    964. 

  964. 	$newTransaction->captureMode =  self::CATCH_PAYMENT;
    965. 

  965.       }
    966. 

  966.       // Affectation du type de transaction : DEBIT
    967. 

  967.       $newTransaction->type = self::DUPLICATE; 
    968. 

  968.       // Mémorisation de la transaction d'origine
    969. 

  969.       $newTransaction->transOri =$customerEnrollment->transOri;
    970. 

  970.       // Mémorisation de la référence abonné 
    971. 

  971.       $newTransaction->refAbonneBoutique =$customerEnrollment->refAbonne; 
    972. 

  972.       // Mémorisation du cvv
    973. 

  973.       $newTransaction->cvv =$customerEnrollment->cvv; 
    974. 

  974.       // Mémorisation du porteur
    975. 

  975.       $newTransaction->porteur =$customerEnrollment->porteur; 
    976. 

  976.       // Mémorisation de la date de validitée de la carte
    977. 

  977.       $newTransaction->dateVal =$customerEnrollment->dateVal;
    978. 

  978.       // Affectation du montant à rembourser
    979. 

  979.       $newTransaction->amount =$order->amount; 
    980. 

  980.       // Définition du status
    981. 

  981.       $newTransaction->status = self::RUNNING; 
    982. 

  982.       // Pas de notification tant qu'il n'y a pas de reponse
    983. 

  983.       $newTransaction->responseStatus = self::RESPONSE_NONE; 
    984. 

  984.       // Récupération de la référence
    985. 

  985.       $newTransaction->orderReference = $order->reference;
    986. 

  986.       // Récupération de l'oid de la commande
    987. 

  987.       $newTransaction->orderOid = $order->oid; 
    988. 

  988.       // Si la boutique fournis le mode de réponse attendu. Sinon on utilisera le même mode que la transaction d'origine.
    989. 

  989.       if(isset($shop->autoResponseMode)){
    990. 

  990. 	$newTransa…
    991.