console-seolan /class.xmodpaypal.inc

Language PHP Lines 595
MD5 Hash 21cd5f873e4310bd25da6cbcf74e975e
Repository https://github.com/jcplat/console-seolan.git View Raw File
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
<?php

/**
 * \file     class.xmodpaypal.inc
 * \name     XModPaypal
 * \author   Vladimir Monari
 * \version  1.0
 * \date     1 Septembre 2013
 */

/**
 * \brief Classe XModPaypal.
 * Classe de gestion des transactions Paypal.
 * \version 1.0
 */
class XModPaypal extends XModMonetique{
  public $defaultTemplate = "xmodmonetique/xmodmonetique-paypal-basic-form.html"; ///< Template Paypal par défaut.
  public $formUrlPreProd = NULL; //"https://www.sandbox.paypal.com/cgi-bin/webscr"; ///< url de soumission de pré-production.
  public $formUrlProd = NULL; ///< url de soumission de pré-production.
  public $password = NULL; ///< url de soumission de pré-production.
  public $signature = NULL; ///< url de soumission de pré-production.
  public $user = NULL;
  public $urlApiPaypalPreProd = NULL;
  public $urlApiPaypalProd = NULL;

  protected function webPaymentHandling(MTransaction $transaction){
    // Initialisation des paramètres d'appel
    $callParms = $this->paypalForm($transaction);
    $transaction->callParms = $callParms;
    
    // Création du formulaire à envoyer en banque
    foreach ($callParms as $key => $value) {
      $paypalForm['fields'] .= '<input type="hidden" name="'.$key.'" value="'.$value.'" />';
    }
    if ($this->testMode(true)) {
      $paypalForm['url'] = $this->formUrlPreProd;
    }else{
      $paypalForm['url'] = $this->formUrlProd;
    }
    $transaction->callParms['url'] =  $paypalForm['url'];
    $paypalForm['method'] = "POST";

    $transaction->callParms['method'] = "POST";
    if ($this->testMode(true)) {
      $transaction->callParms['url'] = $this->formUrlPreProd;
    }else{
      $transaction->callParms['url'] = $this->formUrlProd;
    }
    // Retourne la transaction en cours, le formulaire envoyé en banque ainsi que le template et son entrée
    return array($transaction, $paypalForm, TZR_SHARE_DIR.$this->defaultTemplate, 'paypalForm');
  }

  private function paypalForm($transaction){
    $params = array();
    // Gestion du paiement multiple si la commande indique plusieurs échéances
    if($transaction->nbDeadLine > 1){
      // Préparation des paramètres de multi paiement
      /* Calcule du montant des prochain prélévement */
      // On divise le montant total en centimes par le nombre d'écheances
      $montant = $transaction->amount / $transaction->nbDeadLine; 
      $montant = round($montant , 2);
      // Calcule de la différence du aux arrondis
      $diff= $transaction->amount - ($montant* $transaction->nbDeadLine); 
      // Calcule de la fréquence des prélévement ( $order->options['frequencyDuplicate'] est en jours)
      $frequenceDivise = $transaction->frequencyDuplicate /30;
      // On récupère la partie entière qui sera le nombre de mois entre chaque prélévement
      $frequenceDivise = explode('.', $frequenceDivise);
      // Fréquence des prélèvements en mois
      $frequencyDuplicate = sprintf('%02d',$frequenceDivise[0]); 
      // Mise en forme des paramètre d'appel de multi-paiement
      $params['cmd'] = '_xclick-subscriptions';
      // Montant des prélévements
      $params['a1'] = $montant+$diff ;
      // Durée de l'abonnement
      $params['p1'] = $frequencyDuplicate;
      // Fréquence de prelevement mensuelle
      $params['t1'] = 'M';
      // Montant des prélévements
      $params['a3'] = $montant ;
      // Durée entre chaques prelevement
      $params['p3'] = $frequencyDuplicate;
      // Fréquence de prelevement
      $params['t3'] = 'M';
      // Paiement de souscription réccurents
      $params['src'] = '1';
      // Nombre d'échéances
      $params['srt'] = $transaction->nbDeadLine-1;
      // Si un paiement récurrent échoue, PayPal tente de recouvrer la somme deux fois avant d'annuler l'abonnement.
      $params['sra'] = '1';
      // Référence de l'abonné
      $params['invoice'] = $transaction->refAbonneBoutique; 
    
    }
    // Sinon paiement unique
    else{
      // Paiement en une fois si seulement la référence est renseigné dans 'PBX_CMD'
      $params['cmd'] = '_xclick';
      // Le montant (utiliser le point comme séparateur décimal)
      $params['amount'] = $transaction->amount; 
    }

    // Paramètres de base
    $params['user'] = $this->user;
    $params['pwd'] = $this->password;
    $params['signature'] = $this->signature;
    $params['country'] = 'FR';
    // Devise en Euros par défaut
    $params['currency_code'] = 'EUR';
    // Je considère que les taxes éventuelles ont déjà été calculé
    $params['tax'] = '0.00';
    // La page de retour si paiement accepté: name="return"
    $params['return'] = $this->urlPayed;
    // La page de retour si la transaction est annulée: name="cancel_return"
    $params['cancel_return'] = $this->urlCancelled;
    // La page qui sera appelée par l'IPN: name="notify_url"
    $params['notify_url'] = $this->urlAutoResponse;
    // Ladresse e-mail de votre compte PayPal
    $params['business'] = $this->siteId;
    // Le descriptif de la transaction, visible par lacheteur
    $params['item_name'] = $transaction->oid;
    // un identifiant interne, non visible par lacheteur (option)
    $params['item_number'] =  $transaction->orderReference;
 
    // PayPal ne demande pas à lacheteur de saisir un message à votre intention si = 1
    $params['no_note'] = '1';
    // Si « 0 », alors PayPal demande à lacheteur de saisir une adresse de livraison, et vous la communique
    // Si « 1 », alors PayPal ne demande pas à lacheteur de saisir une adresse de livraison
    $params['no_shipping'] = '0';
    //  définit le langage à présenter par défaut à lacheteur: Fr, eN, eS, iT, de etc... (option) 
    $params['lc'] = $this->lang;
    // Paramètre pour le bouton  
    $params['bn'] = "PP-BuyNowBF";
    // Memorise le customerOid 
    $params['custom'] = $transaction->customerOid;
    if( $transaction->captureMode == self::AUTHORIZATION_ONLY){
      $params['paymentaction'] = 'authorization';
    }else{
      $params['paymentaction'] = 'sale';
    }
  
    // Redirection du client avec les paramètres en POST
    $params['rm'] = '1';
    // Si la commande nécéssite l'abonnement du client
    if (isset($transaction->refAbonneBoutique) && $transaction->enrollement == true) {
      /* A FINALISER : ATTENTE DE REPONSE (MAIL) PAYPAL */
      // $params=array();
      $token = $this->setUpPaymentAuthorization();
      $params['cmd'] = '_express-checkout';
      $params['token']=$token;
      $transaction->porteur=$token;
    } 
    return $params;
  }

  private function setUpPaymentAuthorization(){
    $callParms = $this->paypalFormEnrollement(); 
    $paypalForm = $this->prepareCurlForm($callParms);
    // Envoi du formulaire et mise à jour du retour dans $transaction
    $responseParms = $this->sendCurlForm($paypalForm);
    //   if(stripos($responseParms['ACK'],'Success')){
      return $responseParms['TOKEN'];
    /* }else{ */
    /*   throw new Exception(get_class($this).' ::setUpPaymentAuthorization : '.print_r($responseParms,true)); */
    /* } */
  }

  private function paypalFormEnrollement($transaction){
    $callParms = array();
    // Construction du formulaire
    $callParms['USER'] = urlencode($this->user);
    $callParms['PWD'] = urlencode($this->password);
    $callParms['SIGNATURE'] = urlencode($this->signature);
    $callParms['METHOD'] = "SetExpressCheckout";
    $callParms['VERSION'] = '86';
    //Payment authorization
    $callParms['PAYMENTREQUEST_0_PAYMENTACTION'] = 'AUTHORIZATION';
    // Montant de l'autorisation    
    $callParms['PAYMENTREQUEST_0_AMT'] = 1000; 
    $callParms['PAYMENTREQUEST_0_CURRENCYCODE'] = "EUR";
    //The type of billing agreement
    $callParms['L_BILLINGTYPE0'] = "MerchantInitiatedBilling"; 
    $callParms['L_BILLINGAGREEMENTDESCRIPTION0'] = "Forfait vierge";
    // La page de retour si paiement accepté: name="return"
    $callParms['returnUrl'] = $this->urlPayed;
    // La page de retour si la transaction est annulée: name="cancel_return"
    $callParms['cancelUrl'] = $this->urlCancelled;
    return $callParms; 
  }
 
  protected function webPaymentUnFoldReponse() {
    $transaction = new MTransaction();
    // lire le formulaire provenant du système PayPal et ajouter 'cmd'
    $req = 'cmd=_notify-validate';
 
    // Dans la boucle foreach, nous allons récupérer tous les paramètres passés par la méthode POST et les stocker dans la variable $req. Cette dernière nous permettra de renvoyer toutes les données à PayPal pour vérification.
    foreach ($_POST as $key => $value) {
      $value = urlencode(stripslashes($value));
      $req .= "&$key=$value";
      if($this->isUrlEncoded($value)){
	$transaction->responseParms{$key} = urldecode($value);
      }else{
	$transaction->responseParms{$key} = $value;
      }  
    } 
    // $transaction->responseParms['token'] = $req;
    // renvoyer au système PayPal pour validation
    // Maintenant, nous préparons le header à renvoyer au système de paypal pour obtenir la vérification de l'intégrité des données reçues. Nous ouvrons ensuite une connexion avec le serveur sandbox paypal (A remplacer par www.paypal.com en production).
    $header = "POST /cgi-bin/webscr HTTP/1.1\r\n";
    $header .= "Content-Type: application/x-www-form-urlencoded\r\n";
    $header .= "Host: www.sandbox.paypal.com\r\n";  // www.paypal.com for a live site
    $header .= "Content-Length: " . strlen($req) . "\r\n";
    $header .= "Connection: close\r\n\r\n";
    if ($this->testMode(true)) {
      $payPalHOST = 'ssl://www.sandbox.paypal.com';
    } else {
      $payPalHOST = 'ssl://www.paypal.com';
    }
 
    $fp = fsockopen ($payPalHOST, 443, $errno, $errstr, 30);
    // On récupère toutes les données que l'on va traiter. 
    $transaction->oid = $_POST['item_name'];
    $transaction->orderReference = $_POST['item_number'];
    $payment_status = $_POST['payment_status'];
    $transaction->amount = abs($_POST['mc_gross']);
    $payment_currency = $_POST['mc_currency'];
    $transaction->transId = $_POST['txn_id'];
    $receiver_email = $_POST['receiver_email'];
    $payer_email = $_POST['payer_email'];
    $transaction->customerOid = $_POST['custom'];
    // Si la connexion au service paypal a réussie, on lui envoi le header préparé précedemment, puis on récupère les information renvoyée par PayPal. Si le résultat est "VERIFIED" alors, la transaction est valide, les données envoyées et récupérées sont correctes. Dans le cas contraire, paypal renverra le code "INVALID".
    if (!$fp) {
      // ERREUR HTTP
      $transaction->statusComplement = "Erreur HTTP";
      throw new Exception(get_class($this).' ::webPaymentUnFoldReponse : '.$transaction->statusComplement);
    } else {
      fputs ($fp, $header . $req);
      while (!feof($fp)) {
	$res = fgets ($fp, 1024);
	if (stripos($res, "VERIFIED") !== false) {
	  // transaction valide
	  // vérifier que payment_status a la valeur Completed ou Pending (Pour une simple demande d'autorisation)
	  if ( $payment_status == "Completed" ||  $payment_status == "Pending") {
	    XLogs::critical(get_class($this).'::webPaymentUnFoldReponse', 'status de la transaction ayant pour KOID '.$transaction->oid." : ".$payment_status." et capture mode = ".$this->getCaptureMode($transaction));
	    if( ($this->getCaptureMode($transaction) == self::CATCH_PAYMENT && $payment_status == "Completed") || ($this->getCaptureMode($transaction) == self::AUTHORIZATION_ONLY) && $payment_status == "Pending"){
	      $transaction->status = self::SUCCESS;
	      if($this->getCaptureMode($transaction) == self::AUTHORIZATION_ONLY){
	        $transaction->statusComplement = "Demande d'autorisation acceptée.";
	      }
	    }else if ( ($this->getCaptureMode($transaction) == self::CATCH_PAYMENT) && $payment_status == "Pending"){
	      $transaction->status = self::RUNNING;
	      $transaction->statusComplement = "En attente d'autorisation de la banque.";
	    }else{
	      $transaction->status = self::ERROR;
	      $transaction->statusComplement = "Erreur à vérifiée.";
	    }
	    // On vérifie que txn_id n'a pas été précédemment traité
	    if($this->responseAlreadyReceived($transaction)){
	      $transaction->statusComplement = "Response already received";
	      throw new Exception(get_class($this).' ::webPaymentUnFoldReponse : '.$transaction->statusComplement);
	    } else {
	      // vérifier que receiver_email est votre adresse email PayPal principale
	      if ( $this->siteId == $receiver_email) {
		// vérifier que payment_amount et payment_currency sont corrects
		// traiter le paiement
		$transaction->responseCode = '00';
		$transaction->status = self::SUCCESS;
		/*	if($transaction->responseParms['txn_type']=='subscr_payment'){	}*/
	      }
	      else {
		// Mauvaise adresse email paypal
		$transaction->statusComplement = "Il y a eu une erreur d'email paypal vous concernant , ce n'est pas vous qui avait encaissé ce paiement.";
		throw new Exception(get_class($this).' ::webPaymentUnFoldReponse : '.$transaction->statusComplement);
	      }
	    }
	  }else if ( $payment_status == "Refunded" ) {
	    $transaction->statusComplement = "Remboursement de commande: ".$transaction->orderReference;
	    $transaction->oid = $this->getRefundWithTransOri($transaction->oid);
	    if(empty($transaction->oid)){
	      $transaction->status = self::ERROR;
	    }else{
	      $transaction->status = self::SUCCESS;
	      $transaction->responseCode = '00';
	    }
	  }else if ( $payment_status == "Refunded" ) {
	    $transaction->statusComplement = "Remboursement de commande: ".$transaction->orderReference;
	    $transaction->oid = $this->getRefundWithTransOri($transaction->oid);
	    if(empty($transaction->oid)){
	      $transaction->status = self::ERROR;
	    }else{
	      $transaction->status = self::SUCCESS;
	      $transaction->responseCode = '00';
	    }
	  }else if( $_POST['txn_type'] == 'subscr_signup'){
	    if($_POST['payer_status'] == 'verified'){
	      $transaction->status = self::RUNNING;
	      $transaction->responseCode = '';
	      $transaction->amount =  $transaction->responseParms['mc_amount1'] ;
	      $transaction->amount += $transaction->responseParms['mc_amount3'] *$transaction->responseParms['recur_times'];
	    }
	  }else {
	    // Statut de paiement: Echec
	    $transaction->status = self::ERROR;
	    $transaction->statusComplement = "Retour de la reponse non vérifiée.";
	    $transaction->responseCode = '-1';
	  }
	}
	else if (stripos($res, "INVALID") !== false) {
	  // Transaction invalide   
	  $transaction->status = self::INVALID; 
	  $transaction->statusComplement = "Signature invalide.";
	  $transaction->responseCode = '-1'; 
	}
      }
      fclose ($fp);
    }
    return $transaction;
  }

  private function responseAlreadyReceived($transaction){
    $rs = selectQuery('select status from '.$this->xset->getTable().' where `KOID`="'.$transaction->oid.'"'); 
    $res = null;
    if($rs->rowCount()==1){
      $res  = $rs->fetch();
      if($res['status'] == self::RUNNING){
	return false;
      }else{
	return true;
      }
    }else{
      XLogs::critical(get_class($this).'::responseAlreadyReceived', 'status de la transaction d\'origine ayant pour KOID '.$transaction->transOri.' non trouvé!');
      throw new Exception(get_class($this).'::responseAlreadyReceived : status de la transaction d\'origine ayant pour KOID '.$transaction->transOri.' non trouvé!');
    }
  }

  protected function refundHandling($transaction){
    // Mémorisation des paramètres nécéssaire au remboursement
    list($paramsRetourOrigin, $amountOri) = $this->getResponseParmsOrigin($transaction); 
   
    if($amountOri <  $transaction->amount){
      $transaction->statusComplement = ' ::refundHandling : Le montant du remboursement ne peut être supérieur au montant d\'origine : '.$transaction->amount.' > '.$amountOri;
      throw new Exception(get_class($this). $transaction->statusComplement);
    }
    // Création du formulaire de remboursement (Mise à jour de l'attribut $transaction->callParms)
    $transaction->callParms = $this->refundPaypalForm($paramsRetourOrigin, $transaction); 
    // Mémorisation des paramètres d'appel
    $appel['oid'] = $transaction->oid ;
    $appel['callParms'] = $transaction->callParms;
    $appel['options'] =array('callParms'=>array('raw'=>true,'toxml'=>true));
    $this->xset->procEdit($appel);
    // Préparation du formulaire de remboursement
    $paypalForm = $this->prepareCurlForm($transaction->callParms);
    // Envoi du formulaire et mise à jour du retour dans $transaction
    $transaction->responseParms = $this->sendCurlForm($paypalForm);
 

    if("SUCCESS" == strtoupper($transaction->responseParms["ACK"])) {
      exit('Refund Completed Successfully: '.print_r($httpParsedResponseAr, true));
      $transaction->status = self::SUCCESS;
      $transaction->statusComplement = 'Remboursement réalisé avec succès';
    }else if("SUCCESSWITHWARNING" == strtoupper($transaction->responseParms["ACK"])){
      $transaction->status = self::SUCCESS;
      $transaction->statusComplement = 'Remboursement réalisé avec succès, mais à vérifier.';
    }else{
      $transaction->status = self::ERROR;
      $transaction->statusComplement = 'Remboursemment échoué.';
    }
    XLogs::critical(get_class($this).'::refundHandlingFIN', print_r($transaction,true));
    // Traitement de la réponse contenu dans $transaction
    return $transaction;
  }


  private function refundPaypalForm($paramsRetourOrigin, $transaction){
    $callParms = array();
    // Construction du formulaire
    $callParms['USER'] = urlencode($this->user);
    $callParms['PWD'] = urlencode($this->password);
    $callParms['SIGNATURE'] = urlencode($this->signature);
    $callParms['METHOD'] = "RefundTransaction";
    $callParms['VERSION'] = '94';
    $callParms['TRANSACTIONID'] = $paramsRetourOrigin['txn_id'];
    $callParms['REFUNDTYPE'] = "Partial";
    $callParms['AMT'] = $transaction->amount;
    return $callParms;
  }

  private function getResponseParmsOrigin($transaction){
    $rs = selectQuery('select responseParms, amount from '.$this->xset->getTable().' where `KOID`="'.$transaction->transOri.'"'); 
    $res = null;
    if($rs->rowCount()==1){
      $res  = $rs->fetch();
      $params = XSystem::xml2array($res['responseParms']);
      return array($params, $res['amount']);
    }else{
      XLogs::critical(get_class($this).'::getResponseParmsOrigin', 'responseParms, amount de la transaction d\'origine ayant pour KOID '.$transaction->transOri.' non trouvé!');
      throw new Exception(get_class($this).'::getResponseParmsOrigin : responseParms, amount de la transaction d\'origine ayant pour KOID '.$transaction->transOri.' non trouvé!');
    }
  }

  private function getRefundWithTransOri($transOri){
    $rs = selectQuery('select KOID from '.$this->xset->getTable().' where `transOri`="'.$transOri.'"'); 
    $transactionOid = null;
    if($rs->rowCount()==1){
      $transactionOid  = $rs->fetch(PDO::FETCH_COLUMN);
    }
    else{
      XLogs::critical(get_class($this), 'Transaction de remboursement ayant '.$transOri.' comme origine non trouvée.');
    }
    return $transactionOid;
  }

  private function isUrlEncoded($string){
    $test_string = $string;
    while(urldecode($test_string) != $test_string){
      $test_string = urldecode($test_string);
    }
    return (urlencode($test_string) == $string)?True:False; 
  }

  protected function refundReplay($transaction){

  }

  protected function duplicateHandling($transaction ){
  
  }

  private function duplicatePaypalForm($transaction){

  }

  protected function duplicateReplay($transaction){
  
  }
  
  public function initOptions() {
    parent::initOptions();
    $alabel = XLabels::getSysLabel('xmodpaypal.modulename');
    $this->_options->setOpt(XLabels::getSysLabel('xmodpaypal','formurlpreprod'),'formUrlPreProd','text', NULL,NULL,$alabel);
    $this->_options->setOpt(XLabels::getSysLabel('xmodpaypal','formurlprod'),'formUrlProd','text', NULL,NULL,$alabel);
    $this->_options->setOpt(XLabels::getSysLabel('xmodpaypal','user'),'user','text', NULL,NULL,$alabel);
    $this->_options->setOpt(XLabels::getSysLabel('xmodpaypal','password'),'password','text', NULL,NULL,$alabel);
    $this->_options->setOpt(XLabels::getSysLabel('xmodpaypal','signature'),'signature','text', NULL,NULL,$alabel);
    $this->_options->setOpt(XLabels::getSysLabel('xmodpaypal','urlapipaypalpreprod'),'urlApiPaypalPreProd','text', NULL,NULL,$alabel);
    $this->_options->setOpt(XLabels::getSysLabel('xmodpaypal','urlapipaypalprod'),'urlApiPaypalProd','text', NULL,NULL,$alabel);
  
  }


  /**
   * \brief Fonction de préparation du formulaire Curls à envoyer à Paybox.
   * Concatène les champs du formulaire Paybox à soumettre.
   * \param Array $payboxParams : Le tableau contenant les paramètres à envoyer.
   * \return Sring $payboxForm : La chaine contenant la requête à envoyer.
   */
  private function prepareCurlForm($paypalParams){
    $paypalForm ='';
    foreach($paypalParams as $key => $value){
      $paypalForm .= $key.'='.$value.'&';
    }
    // On enlève le dernier '&'
    $paypalForm = substr($paypalForm,0,strlen($paypalForm)-1); 
    return $paypalForm;
  }

  /**
   * \brief Fonction d'émission d'une requête à Paypal.
   * Envoi une requête CURL à Paypal.
   * \param String $paypalForm : La chaine contenant les paramètres de la transaction.
   * \param MTransaction &$transaction : La transaction en cours qui va être mise à jour.
   * \return MTransaction &$transaction : La transaction passé en paramètre et mise à jour.
   */
  private function sendCurlForm($paypalForm){
    // Recherche du serveur disponible
    if($this->testMode(true)){
      $url = $this->urlApiPaypalPreProd;
    }
    else{
      $url = $this->urlApiPaypalProd;
    }

    if($url){
      // Initialisation d'une session CURL
      $ch = curl_init();
      curl_setopt($ch, CURLOPT_URL, $url);
      // TRUE pour afficher tous les événements. Écrit la sortie sur STDERR ou dans le fichier spécifié en utilisant CURLOPT_STDERR. False pour le contraire
      curl_setopt($ch, CURLOPT_VERBOSE, 1);
      // Turn off the server and peer verification (TrustManager Concept).
      curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, FALSE);
      curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, FALSE);
      
      curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
      curl_setopt($ch, CURLOPT_POST, 1);

      // Set the request as a POST FIELD for curl.
      curl_setopt($ch, CURLOPT_POSTFIELDS, $paypalForm);
      
      // Get response from the server.
      $httpResponse = curl_exec($ch);
    
      if(!$httpResponse) {
	$transaction->statusComplement = $paypalForm->callParms['METHOD']." ".curl_error($ch).'('.curl_errno($ch).')';
	throw new Exception(get_class($this).' ::sendCurlForm : '.$transaction->statusComplement);
      }

      // Extract the response details.
      $httpResponseAr = explode("&", $httpResponse);
      
      $httpParsedResponseAr = array();
      foreach ($httpResponseAr as $i => $value) {
	$tmpAr = explode("=", $value);
	if(sizeof($tmpAr) > 1) {
	  $httpParsedResponseAr[$tmpAr[0]] = $tmpAr[1];
	}
      }
      
      if((0 == sizeof($httpParsedResponseAr)) || !array_key_exists('ACK', $httpParsedResponseAr)) {
	$transaction->statusComplement ="Invalid HTTP Response for POST request(".$paypalForm.") to ".$url;
	throw new Exception(get_class($this).' ::sendCurlForm : '.$transaction->statusComplement);
      }else{
	$transaction->responseParms = $httpParsedResponseAr;
      }
      return $this->formatParams($httpParsedResponseAr);
    }

  }

  private function formatParams($response ) {
    $formatedParams = array();
    foreach($response as $k => $v){
      if($k == "REFUNDTRANSACTIONID"){
	$formatedParams[$k]=$v;
      }
      if($k == "FEEREFUNDAMT"){
	$formatedParams[$k]=urldecode($v);
      }
      if($k == "GROSSREFUNDAMT"){
	$formatedParams[$k]=urldecode($v);
      }
      if($k == "NETREFUNDAMT"){
	$formatedParams[$k]=urldecode($v);
      }
      if($k == "CURRENCYCODE"){
	$formatedParams[$k]=$v;
      }
      if($k == "TOTALREFUNDEDAMOUNT"){
	$formatedParams[$k]=urldecode($v);
      }
      if($k == "TIMESTAMP"){
	$formatedParams[$k]=urldecode($v);
      }
      if($k == "CORRELATIONID"){
	$formatedParams[$k]=$v;
      }
      if($k == "ACK"){
	$formatedParams[$k]=$v;
      }
      if($k == "VERSION"){
	$formatedParams[$k]=$v;
      }
      if($k == "BUILD"){
	$formatedParams[$k]=$v;
      }
      if($k == "REFUNDSTATUS"){
	$formatedParams[$k]=$v;
      }
      if($k == "PENDINGREASON"){
	$formatedParams[$k]=$v;
      }   
      else{
	$k = str_replace ('=&gt;', '', $k);
	$formatedParams[urldecode($k)]=urldecode($v);
      }
    }
    return $formatedParams;
  }


  protected function getAmountDeadLine($transOid){
    $rs = selectQuery('select responseParms from '.$this->xset->getTable().' where `KOID`="'.$transaction->transOri.'"'); 
    $res = null;
    if($rs->rowCount()==1){
      $res  = $rs->fetch();
      $params = XSystem::xml2array($res['callParms']);
      $firstDeadLine = $params['a1'];
      $otherDeadLine = $params['a3'];
      return array($firstDeadLine,$otherDeadLine);
    }else{
      XLogs::critical(get_class($this).'::getResponseParmsOrigin', 'responseParms, amount de la transaction d\'origine ayant pour KOID '.$transaction->transOri.' non trouvé!');
      throw new Exception(get_class($this).'::getResponseParmsOrigin : responseParms, amount de la transaction d\'origine ayant pour KOID '.$transaction->transOri.' non trouvé!');
    }
  }
}

?>
Back to Top