/class.xmodpaybox.inc

Large files files are truncated, but you can click here to view the full file

<?php

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

/**
 * \brief Classe XModPaybox.
 * Classe de gestion des transactions Paybox.
 * \version 1.0
 */
class XModPaybox extends XModMonetique{
  // Options spécifiques au module
  public $rang = NULL; ///< Rang du site, fournis par la banque.
  public $identifiant = NULL; ///< Identifiant, fournis par la banque.
  public $keyFile = NULL; ///< Fichier contenant la clé permettant de verifiée la signature.
  public $formMethode = 'POST'; ///< méthode de soumission.
  public $formFirstUrl = NULL; ///< url de soumission principale.
  public $form2NdUrl = NULL; ///< url de soumission secondaire.
  public $formUrlPreProd = NULL; ///< url de soumission de pré-production.

  /// Gestion des paramètres de retour (C'est le maximum d'infos que paybox nous retourne).
  private $champsRetour = array(
				"P_M" => "M", // Montant de la transaction
				"P_R" => "R", // Référence commande (Passée par PBX_CMD)
				"P_A" => "A", // Numéro d'autorisation
				"P_T" => "T", // Identifiant de la transaction
				"P_Q" => "Q", // Heure du traitement de la transaction
				"P_W" => "W", // Date du traitement de la transaction
				"P_B" => "B", // Numéro d'abonnement (fournis par Paybox Service)
				"P_P" => "P", // Type de paiement
				"P_C" => "C", // Type de carte
				"P_S" => "S", // Numéro de transaction
				"P_Y" => "Y", // Code pays de la banque éméttrice de la carte
				"P_E" => "E", // Code erreure de la transaction
				"P_F" => "F", // Etat d'authentification 3D secure
				"P_G" => "G", // Garantie de paiement 3D secure
				"P_O" => "O", // Enrolement du porteur 3D secure
				"P_D" => "D", // Date de fin de validitée
				"P_U" => "U", // Référence donner par Paybox Direct Plus
				"P_I" => "I", // Code pays de l'IP du client
				"P_N" => "N", // 6 premier numéros de carte
				"P_J" => "J", // 2 derniers numéros de carte
				"P_H" => "H", // Empreinte de la carte
				"P_Z" => "Z", // Index lors de l'utilisation de paiement mixtes
				"P_K" => "K"  // Signature du message
				);

 private $cardsTypePaybox = array(
			    /* Tous */
			    'AMEX' => 'AMEX',
			    'AURORE' => 'AURORE-MULTI',
			    'BUYSTER' => 'BUYSTER',
			    'CB' => 'CB', ///< On accepte les CB par défaut
			    'COFINOGA' => 'COFINOGA',
			    'E-CARTEBLEUE' => 'E-CARTEBLEUE',
			    'MASTERCARD' => 'MASTERCARD', ///< On accepte les MASTERCARD par défaut
			    'JCB' => 'JCB',
			    'MAESTRO' => 'MAESTRO',
			    'ONEY' => 'ONEY',
			    'ONEY_SANDBOX' => 'ONEY_SANDBOX',
			    'PAYPAL' => 'PAYPAL',
			    'PAYPAL_SB' => 'PAYPAL_SB',
			    'PAYSAFECARD' => 'PAYSAFECARD',
			    'VISA' => 'VISA', ///< On accepte les VISA par défaut
			    'VISA_ELECTRON' => 'VISA_ELECTRON',
			    'COF3XCB' => 'COF3XCB',
			    'COF3XCB_SB' => 'COF3XCB_SB',
			    );

  // Variables relatives à la signature
  public $hashKey = NULL; ///< Signature de l'envoi en banque
  public $algoHash = NULL; ///< Algorithme de hachage

  /// Tableaux permettant la séléction de l'algorithme dans la console  
  public $libelleHash = array('Sha512','RIPEMD160','Sha256','Sha384','Sha224','MDC2');
  public $codeHash = array('Sha512','RIPEMD160','Sha256','Sha384','Sha224','MDC2');

  // Urls de serveurs PPPS (Serveur à serveur)
  public $urlPPPStest = NULL; ///< Url d'appel pour le mode TEST.
  public $urlPPPS1 = NULL; ///< Url principale d'appel pour le mode PRODUCTION.
  public $urlPPPS2 = NULL; ///< Url secondaire d'appel pour le mode PRODUCTION.
  public $clePPPS = NULL; ///< Clé de vérification pour le dial de serveur à serveur (PPPS).

  public $defaultTemplate = "xmodmonetique/xmodmonetique-paybox-basic-form.html"; ///< Template Paybox par défaut.

  /// Constructeur standard d'un module console.
  function __construct($ar=null){
    parent::__construct($ar);
  }

  /* Fonctions de paiement version HMAC */

  /**
   * \brief Méthode de génération des données de paiement.
   * Cette fonction permet de générer les données d'un paiement Paybox.
   * \param MOrderInfos $order :  Objet des données issues de la commande. 
   * \param MCustomerInfos $customer : Objet des données issues du client.
   * \param MShopInfos $shop : Objet comportant les paramètres de la boutique.
   * \param MTransaction $transaction : La transaction en cours de paramètrage.
   * \return Array :
   * - MTransaction $transaction : La transaction contenant tous les paramètres d'appel.
   * - Array $payboxForm : Contient le formulaire envoyé en banque.
   * - String $template : Le template correspondant correspondant un module de traitement (TZR_SHARE_DIR.$this->defaultTemplate).
   * - String $tplentry : L'entrée smarty du template : 'pbf'.
   * \note
   * - Initialise les paramètres d'appel.
   * - Crée le formulaire à envoyer en banque.
   * - Recherche le serveur Paybox disponible. \link XModPaybox::serveurDispo() \endlink
   * - Retourne la transaction en cours, le formulaire envoyé en banque ainsi que le template et son entrée
   * \note
   * Définition des types de cartes proposés:
   * - $params['PBX_TYPEPAIEMENT'] = 'CARTE';
   * - $params['PBX_TYPECARTE'] = 'NOM DE LA CARTE VOULUE';
   */
  protected function webPaymentHandling(MTransaction $transaction){
    // Initialisation des paramètres d'appel
    $callParms = $this->payboxForm($transaction);
    $transaction->callParms = $callParms;
    $transaction->callParms['method'] = $this->formMethode;
    $transaction->callParms['url'] = $this->serveurDispo();
    // Création du formulaire à envoyer en banque
    foreach ($callParms as $key => $value) {
      $payboxForm['fields'] .= '<input type="hidden" name="'.$key.'" value="'.$value.'" />';
    }
    // Méthode POST par défaut pour soumettre le formulaire
    $payboxForm['method'] =  $transaction->callParms['method']; 
    // Recherche du serveur disponible
    $payboxForm['url'] = $transaction->callParms['url'];
    // Retourne la transaction en cours, le formulaire envoyé en banque ainsi que le template et son entrée
    return array($transaction, $payboxForm, TZR_SHARE_DIR.$this->defaultTemplate, 'pbf');
  }

  /**
   * \brief Méthode de génération du formulaire de paiement.
   * Cette fonction permet de générer le formulaire de paiement Paybox.
   * \param MOrderInfos $order :  Objet des données issues de la commande. 
   * \param MCustomerInfos $customer : Objet des données issues du client.
   * \param MShopInfos $shop : Objet comportant les paramètres de la boutique.
   * \param MTransaction $transaction : La transaction en cours de paramètrage.
   * \return Array :
   * - Array $payboxForm : Contient le formulaire envoyé en banque.
   * \note
   * - Mise en forme du montant (centimes). \link XModMonetique::formatOrderAmount($amount); \endlink
   * - Paiement en euros par défaut.
   * - Si $order->options['noCapture'] est valorisé à true alors on ne fait qu'une demande d'autorisation, sinon capture par défaut.
   * - Gestion du paiement multiple si la commande indique plusieurs échéances. \link MOrderInfos::$options \endlink
   * - Gestion du mode TEST ou PRODUCTION.
   * - Gestion des abonnement.
   * - Gestion des délais de capture.
   * - Génération de la signature.
   */
  private function payboxForm($transaction){
    $params = array();
    // Limite le choix au paiement par carte
    $params['PBX_TYPEPAIEMENT'] = 'CARTE';
    // Identifiant du site fournis par la banque
    $params['PBX_SITE'] = $this->siteId; 
    // Rang du site fournis par la banque
    $params['PBX_RANG'] = $this->rang; 
    // Identifiant du commerçant
    $params['PBX_IDENTIFIANT'] = $this->identifiant; 
    // Mise en forme du montant (centimes)
    $params['PBX_TOTAL'] = $this->formatOrderAmount($transaction->amount); 
    // Paiement en euros par défaut
    $params['PBX_DEVISE'] = $this->defaultCurrencyCode; 
    // Si $order->options['noCapture'] est valorisé à true alors on ne fait qu'une demande d'autorisation
    if( $transaction->captureMode == self::AUTHORIZATION_ONLY){
      $params['PBX_AUTOSEULE'] = 'O';
    }
    // Sinon capture par défaut
    else{
      $params['PBX_AUTOSEULE'] = 'N';
    }
    // 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
      $montantDivise = $this->formatOrderAmount($transaction->amount) / $transaction->nbDeadLine; 
      // On récupère la partie entière qui sera le montant des futurs prélévement
      $montantDivise = explode('.', $montantDivise); 
      // Montant des prochains prélèvements en centimes (0 = montant identique au paiement initial précisé dans PBX_TOTAL).
      $montant =sprintf('%010d',$montantDivise[0]);
      // 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]);
      // Nombre de jours entre la demande d'autorisation et le prélévement effectif 
      $delais = sprintf('%03d', $transaction->captureDelay);  
      // Nombre de prélèvements (0 = toujours)
      $pbx_nbpaie = sprintf('%02d',$transaction->nbDeadLine);   
      // Mise en forme des paramètre d'appel de multi-paiement
      $params['PBX_CMD'] = $transaction->orderReference.'PBX_2MONT'.$montant.'PBX_NBPAIE'.$pbx_nbpaie.'PBX_FREQ'.$frequencyDuplicate.'PBX_QUAND'.$transaction->captureDay.'PBX_DELAIS'.$delais;
    }
    // Sinon paiement unique
    else{
      // Paiement en une fois si seulement la référence est renseigné dans 'PBX_CMD'
      $params['PBX_CMD'] = $transaction->orderReference; 
    }
    $params['PBX_PORTEUR'] = $transaction->customerEmail;
    $params['PBX_EFFECTUE'] = $this->urlPayed;
    $params['PBX_REFUSE'] = $this->urlCancelled;
    $params['PBX_ANNULE'] = $this->urlCancelled;
    // Gestion du mode TEST ou PRODUCTION
    $params['PBX_REPONDRE_A'] = $this->urlAutoResponse;
    $params['PBX_TIME'] = date("c");
    $params['PBX_HASH'] = $this->algoHash; ///< Algorithme utilisé pour le calcul de la clé
    $params['PBX_RUF1'] =  $this->formMethode; 
   
    // Si la commande nécéssite l'abonnement du client
    if (isset($transaction->refAbonneBoutique) && $transaction->enrollement == true) {
      $params['PBX_REFABONNE'] = $transaction->refAbonneBoutique;
    }   
    // Si la commande indique que la capture doit être différé
    if(isset($transaction->captureDelay)){
      $params['DIFF'] = $transaction->captureDelay;///< Nombre de jours pour la capture différée    
    }else{
      $params['DIFF'] = 0;
    }
    // variables attendus en retour (Toutes celles fournis par paybox)
    $retour = '';
    foreach ($this->champsRetour as $key => $value) {
      $retour .= $key.":".$value.";";
    }
    $retour = substr($retour,0,strlen($retour)-1); ///< Suppression du dernier ';'
    $params['PBX_RETOUR'] = $retour;
    // Concatenation des champs du formulaire pour générer la signature
    $contenu_signature = "";
    foreach ($params as $key=>$value) {
      $contenu_signature .= $key."=".$value."&";
    }
    $contenu_signature = substr($contenu_signature,0,strlen($contenu_signature)-1); ///< Suppression du dernier '&'   
    /// La clé est en ASCII, On la transforme en binaire
    $binKey = pack("H*", $this->hashKey);    
    /* On calcule l’empreinte (à renseigner dans le paramètre PBX_HMAC) grâce à la fonction hash_hmac et la clé binaire.
     * On envoie via la variable PBX_HASH l'algorithme de hachage qui a été utilisé. */
    $key = hash_hmac($this->algoHash, $contenu_signature, $binKey);
    // La chaîne sera envoyée en majuscules, d'où l'utilisation de strtoupper()
    $signature = strtoupper($key); 
    $params['PBX_HMAC'] = $signature;
    return $params;
  }

  /**
   * \brief Méthode de traitement du retour banque paybox.
   * Méthode de traitement du retour banque paybox, afin de transamettre des paramètres standards à \link XModMonetique::autoresponse() \endlink
   * \return MTransaction $transaction : La transaction concernée par le retour automatique.
   * \note
   * - Récupère de toutes les valeurs attendu par PayBox, présentes dans $_REQUEST.
   * - Mémorise les paramètres de retour de la transaction sous une forme normalisée pour faciliter le traitement en aval et dans Xmodmonetique. \link XModPaybox::formatParams(& $transaction); \endlink
   * - Vérifie la signature de la reponse. \link XModPaybox::verificationSignature($retour, $signature); \endlink
   * - Affecte le status de la transaction.
   * - Récupère l'oid de la transaction grâce à la référence commande. \link XModmonetique::getIdTransactionWithOrderRef($orderReference); \endlink	
   * - Incrémente le nombre de retour.
   */
  protected function webPaymentUnFoldReponse() {
    // Récupération de toutes les valeurs retournés par PayBox et présentes dans $_REQUEST
    $params = array_intersect_key($_REQUEST, $this->champsRetour); 
    // Mémorisation des paramètres de retour de la transaction sous une forme normalisé pour faciliter le traitement en aval et dans Xmodmonetique
    $formatedReturn = $this->formatParams($params); 
 
    $transaction = new MTransaction();
    foreach($formatedReturn as $k => $v){
      $transaction->{$k} = $v;
    }
   
    $transaction->responseParms = $params;
    // Vérification de la signature
    $errcode = $this->verificationSignature($formatedReturn['stringToVerify'], $formatedReturn['signature']);

    // Si la signature est invalide
    if ($errcode != 1) {
      $transaction->status = self::INVALID; ///< Définition de status invalide
      $transaction->statusComplement = 'Error à la vérification de la signature, risque de fraude. Chaine à vérifierPréc : '.$formatedReturn['stringToVerify'].' Signature = '.$formatedReturn['signature'].' Code d\'erreur : '.$errcode;
      $transaction->autoResponseMode = self::RESPONSE_NONE;
      $this->xset->procEdit(array('_options'=>array('local'=>1),
				  'oid'=>$transaction->oid,
				  'responseParms'=>$transaction->responseParms,
				  'status'=>$transaction->status,
				  'dateTimeIn'=>date('Y-m-d H:i:s'),
				  'statusComplement'=>$transaction->statusComplement,
				  'responseStatus'=>'NA'
				  ));
      XLogs::critical(get_class($this)."::webPaymentUnFoldReponse $transaction->statusComplement. ", print_r($transaction, true));
      throw new Exception(get_class($this).'::webPaymentUnFoldReponse : '.$transaction->statusComplement);
    }
    // Vérification de la coherence de la réponse (Le numéro d'autorisation ne peut être XXXXXX si l'identifiant de la boutique n'est pas celui de test)
    if (($formatedReturn['N_A'] == 'XXXXXX') && ($this->siteId != '1999888')) {
      $transaction->status =self::ERROR;
      $transaction->statusComplement = 'PAYBOX RETOUR: Reception d\'une autorisation de test, alors que PBX_SITE n\'est pas celui de test!';
      $transactionResponse->autoResponseMode = self::RESPONSE_NONE;
      $this->xset->procEdit(array('_options'=>array('local'=>1),
				  'oid'=>$transaction->oid,
				  'responseParms'=>$transaction->responseParms,
				  'status'=>$transaction->status,
				  'dateTimeIn'=>date('Y-m-d H:i:s'),
				  'statusComplement'=>$transaction->statusComplement,
				  'nbReturn'=>$transaction->nbReturn,
				  'responseStatus'=>'NA'
				  ));
      XLogs::critical(get_class($this)."::webPaymentUnFoldReponse $transaction->statusComplement. ", print_r($transaction, true));
      throw new Exception(get_class($this).'::webPaymentUnFoldReponse : '.$$transaction->statusComplement);
      throw new Exception(get_class($this).' ::webPaymentUnFoldReponse : Error message : '.$transaction->statusComplement);
    }
  
    return $transaction;
  }
  
  /* Appel de serveur à serveur (PPPS) */
  /* Fonctions de remboursement d'un abonné */
  
  /**
   * \brief Méthode de traitement d'un remboursement Paybox.
   * \param MTransaction &$transaction : La nouvelle transaction correspondant au remboursement. 
   * Doit contenir dans responseParms les paramètre de retour de la transaction à l'origine du remboursement.
   * \return MTransaction $transaction : La transaction concernée par le remboursement après l'appel banque.
   * \note
   * - Mémorise les paramètres nécéssaire au remboursement.
   * - Ré-initialise les champs de retour
   * - Création du formulaire de remboursement (Mise à jour de l'attribut $transaction->callParms) \link XModPaybox::refundPayboxForm (&$transaction, $paramsRetourOrigin); \endlink
   * - Mémorise les paramètres d'appel.
   * - Prépare le formulaire curl. \link XModPaybox::XModPaybox::prepareCurlForm ($payboxParams) \endlink
   * - Envoi le formulaire curl. \link XModPaybox::sendCurlForm ($payboxForm, &$transaction) \endlink
   * - Traite le retour curl. \link XModPaybox::handlingCurlReturn (&$transaction) \endlink
   */
  protected function refundHandling($transaction){
    // Mémorisation des paramètres nécéssaire au remboursement
    list($paramsRetourOrigin, $amountOri) = $this->getResponseParmsOrigin($transaction); 
    if($amountOri <  $transaction->amount){
      throw new Exception(get_class($this).'::refundHandling : Le montant du remboursement ne peut être supérieur au montant d\'origine : '.$transaction->amount.' > '.$amountOri);
    }
    // Création du formulaire de remboursement (Mise à jour de l'attribut $transaction->callParms)
    $transaction->callParms = $this->refundPayboxForm($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
    $payboxForm = $this->prepareCurlForm($transaction->callParms);
    // Envoi du formulaire et mise à jour du retour dans $transaction
    $this->sendCurlForm($payboxForm, $transaction);
    XLogs::critical(get_class($this).'::refundHandling', print_r($transaction,true));
    // Traitement de la réponse contenu dans $transaction
    $this->handlingCurlReturn($transaction);
    return $transaction;
  }


 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é!');
      }
 }

  /**
   * \brief Méthode de génération du formulaire de remboursement qui sera envoyé à la banque.
   * \param MTransaction &$transaction : La transaction correspondant au remboursement. 
   * \param MTransaction $paramsRetourOrigin : Les paramètres de retour de la transaction à l'origine du remboursement. 
   * \return MTransaction $transaction : La transaction concernée par le remboursement après la mise à jour du formulaire, mémorisé dans $transaction->callParms.
   */
 private function refundPayboxForm($paramsRetourOrigin, $transaction){
    $callParms = array();
    // Construction du formulaire
    $callParms['DATEQ'] = date('dmY');
    $callParms['TYPE'] = 14;
    $callParms['NUMQUESTION'] = date('His');
    $callParms['MONTANT'] = $this->formatOrderAmount($transaction->amount);
    $callParms['REFERENCE'] = $transaction->orderReference;
    $callParms['SITE'] = $this->siteId;
    $callParms['RANG'] = $this->rang;
    $callParms['VERSION'] = '00104';
    $callParms['CLE'] = $this->clePPPS;
    $callParms['IDENTIFIANT'] = $this->identifiant;
    $callParms['DEVISE'] = $this->defaultCurrencyCode;
    $callParms['NUMAPPEL'] = $paramsRetourOrigin['P_T'];
    $callParms['NUMTRANS'] = $paramsRetourOrigin['P_S'];
    return $callParms;
  }

  /**
   * \brief Méthode de ré-émissions des remboursement en attente (serveur non disponible lors de l'appel).
   * \param MTransaction &$transaction : La transaction correspondant au remboursement qui sera mise à jour pendant la ré-émission. 
   * \return MTransaction $transaction : La transaction concernée par le remboursement après sa ré-émission.
   * \see
   * - Prépare le formulaire curl. \link XModPaybox::XModPaybox::prepareCurlForm ($payboxParams) \endlink
   * - Envoi le formulaire curl. \link XModPaybox::sendCurlForm ($payboxForm, &$transaction) \endlink
   * - Traite le retour curl. \link XModPaybox::handlingCurlReturn (&$transaction) \endlink
 
   */
  protected function refundReplay($transaction){
    /// Mise à jour du numéro de question
    $transaction->callParms['NUMQUESTION'] = date('Hisd'); 
    /// Préparation du formulaire de remboursement
    $payboxForm = $this->prepareCurlForm( $transaction->callParms);
    /// Envoi du formulaire et mise à jour du retour dans $transaction
    $this->sendCurlForm($payboxForm, $transaction);
    /// Traitement de la réponse contenu dans $transaction
    $this->handlingCurlReturn($transaction);
    return $transaction;
  }

  /* Fonctions de débit forcé d'un abonné */

  /**
   * \brief Méthode de traitement d'une duplication Paybox.
   * \param MTransaction &$transaction : La nouvelle transaction correspondant à la duplication. 
   * \return MTransaction $transaction : La transaction concernée par la duplication après l'appel banque.
   * \note
   * - Création du formulaire envoyé pour le débit (Mise à jour de l'attribut $transaction->callParms).
   * - Mémorise les paramètres d'appel.
   * - Prépare le formulaire curl. \link XModPaybox::XModPaybox::prepareCurlForm ($payboxParams) \endlink
   * - Envoi le formulaire curl. \link XModPaybox::sendCurlForm ($payboxForm, &$transaction) \endlink
   * - Traite le retour curl. \link XModPaybox::handlingCurlReturn (&$transaction) \endlink
   */
  protected function duplicateHandling($transaction ){
    $transaction->callParms = $this->duplicatePayboxForm($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
    $payboxForm = $this->prepareCurlForm($transaction->callParms);
    // Envoi du formulaire et mise à jour du retour dans $transaction
    $this->sendCurlForm($payboxForm, $transaction); 
    // Traitement de la réponse contenu dans $transaction
    $this->handlingCurlReturn($transaction); 
    return $transaction;
  }

  /**
   * \brief Méthode de génération du formulaire de remboursement qui sera envoyé à la banque.
   * \param MTransaction &$transaction : La transaction correspondant au remboursement. 
   * \param MTransaction $paramsRetourOrigin : Les paramètres de retour de la transaction à l'origine du remboursement. 
   * \return MTransaction $transaction : La transaction concernée par le remboursement après la mise à jour du formulaire, mémorisé dans $transaction->callParms.
   */
  private function duplicatePayboxForm($transaction){
    $callParms =array();
    $callParms = array();
    $callParms ['DATEQ'] = date('dmY');
    $callParms['TYPE'] = '00053';
    $callParms['NUMQUESTION'] = date('Hisd');
    $callParms['MONTANT'] = $transaction->amount;
    $callParms['SITE'] = $this->siteId;
    $callParms['RANG'] = $this->rang;
    $callParms['REFERENCE'] = $transaction->orderReference;
    $callParms['REFABONNE'] =  $transaction->refAbonneBoutique;
    $callParms['VERSION'] = '00104';
    $callParms['CLE'] = $this->clePPPS;
    $callParms['IDENTIFIANT'] = $this->identifiant;
    $callParms['DEVISE'] = $this->defaultCurrencyCode;
    $callParms['PORTEUR'] = $transaction->porteur;
    $callParms['DATEVAL'] = $transaction->dateVal;
    $callParms['CVV'] = $transaction->cvv;
    return $callParms;
  }

  /**
   * \brief Méthode de ré-émissions des duplications en attente (serveur non disponible lors de l'appel).
   * \param MTransaction &$transaction : La transaction correspondant à la duplication qui sera mise à jour pendant la ré-émission. 
   * \return MTransaction $transaction : La transaction concernée par la duplication après sa ré-émission.
   * \see
   * - Prépare le formulaire curl. \link XModPaybox::XModPaybox::prepareCurlForm ($payboxParams) \endlink
   * - Envoi le formulaire curl. \link XModPaybox::sendCurlForm ($payboxForm, &$transaction) \endlink
   * - Traite le retour curl. \link XModPaybox::handlingCurlReturn (&$transaction) \endlink
   */
  protected function duplicateReplay($transaction){
    // Mise à jour du numéro de question (doit être unique chaque jours)
    $transaction->callParms['NUMQUESTION'] = date('Hisd');
    // Préparation du formulaire de remboursement
    $payboxForm = $this->prepareCurlForm( $transaction->callParms);
    // Envoi du formulaire et mise à jour du retour dans $transaction
    $this->sendCurlForm($payboxForm, $transaction);
    // Traitement de la réponse contenu dans $transaction
    $this->handlingCurlReturn($transaction);
    return $transaction;
  }

  /* Fonctions utilitaires */
  
  /**
   * \brief Méthode qui retourne une url d'appel disponible pour un paiement web PayBox.
   * \exception:
   * Si aucun serveur n'est disponible.
   * \return String $serveurOK : L'url du serveur disponible.
   * \note
   * - Gère le mode TEST et PRODUCTION.
   * - Test la disponibilité du serveur.
   * - Test la disponibilité des services. (Selon la documentation).
   */
  private function serveurDispo (){
    // Si la boutique est en production
    if (!$this->testMode(true)) {
      // On récupère les urls d'appel
      $serveurs = array($formFirstUrl,$form2NdUrl);
      $serveurOK = "";
      // Pour tous les serveurs de production
      foreach ($serveurs as $serveur) {
	// On applique la procédure indiquée dans la documentation PayBox
	$doc = new DOMDocument();
	$doc->loadHTMLFile($serveur.'load.html');
	$server_status = "";
	$element = $doc->getElementById('server_status');
	// On récupère la réponse du serveur
	if ($element) {
	  $server_status = $element->textContent;
	}
	// Si le serveur est prêt et les services opérationnels
	if ($server_status == "OK") {
	  $serveurOK = $serveur;
	  break;
	}
	// Le serveur est disponible mais les services ne le sont pas.
	else{
	  XLogs::critical('::serveurDispo : ', 'Le serveur '.$serveur.' est disponible mais les services ne le sont pas.');  
	}
      }
      if (!$serveurOK) {
	throw new Exception('Serveur payBox de production indisponible à l\'adresse: '.$serveur ,10);
      }
    }
    // Si la boutique est en TEST
    else{
      // On applique la procédure indiquée dans la documentation PayBox
      $serveur = $this->formUrlPreProd;
      $doc = new DOMDocument();
      $posDernierSlash = strrpos ($serveur,"/");
      $url = substr ($serveur, 0, $posDernierSlash);
      $doc->loadHTMLFile($url.'load.html');
      // Si le serveur est disponible
      if (!empty($doc)) {
	$serveurOK = $serveur;
      }
      // Si le serveur est indisponible
      else if (!$serveurOK) {
	throw new Exception('Serveur payBox de test indisponible à l\'adresse: '.$this->formUrlPreProd,10);
      }
    }
    // Url du serveur disponible
    return $serveurOK; 
  }

  /**
   * \brief Fonction de vérication de la signature Paybox.
   * \param String $retour : La reponse du serveur Paybox.
   * \param String $signature : La signature attachée à la réponse Paybox.
   * \return Int $returnValue : 1 si valide, 0 si invalide et -1 si erreur.
   * \note
   * - Charge la clé de vérification Paybox. \link XModPaybox::loadKey \endlink
   * - Log en critical si le chargement de la clé échoue.
   * \todo Vérifier s'il ne faut vraiment pas de clé privée.
   */
  private function verificationSignature($retour, $signature) {
    // Chargement de la clé
    $key = $this->loadKey($this->keyFile); 
    // Si le chargement de la clé échoue
    if( !$key ){
      XLogs::critical(get_class($this), '::verificationSignature chargement de la clé échoué '.$this->keyFile);
      return -1;
    }
    // Retour = 1 si valide, 0 si invalide, -1 si erreur
    $returnValue = openssl_verify($retour, $signature, $key ); 
    openssl_free_key($key);
    return $returnValue;
  }

  /**
   * \brief  Fonction de récupération de la clé de décryptage  (chargement de la clé publique par défaut).
   * \param String $keyFile : Le chemin du fichier de la clé.
   * \param Bool $pub : Valorisé à True (par défaut, charge la clé publique).
   * \param String $pass : Le mot de passe permettant d'accéder à la clé privée.
   * \return String $key : La clé ou False.
   */
  private function loadKey( $keyFile, $pub=true, $pass='' ) {
    // Vérifie que le fichier contenant la clé existe
    $filedata = file_get_contents($keyFile);
    if( !$filedata ) {
      return false;
    }
    // Récuperation de la clé publique
    if( $pub ){
      $key = openssl_pkey_get_public( $filedata );
    }
    // ou de la clé privée
    else {
      $key = openssl_pkey_get_private( array( $filedata, $pass ));
    }
    // renvoi cle ( ou erreur )
    return $key;
  }

  /**
   * \brief Mise en forme des paramètres de retour en vue de mémorisation.
   * Transforme les paramètres Paybox en paramètres mémorisable par XModMonetique.
   * \param MTransaction &$transaction : La transaction en cours.
   * \return MTransaction &$transaction: La transaction avec ses paramètres renseignés.
   * \note
   * - $transaction->retour permettra de vérifier la signature.
   * - Pour tous les paramètres reçus:
   *  - La première structure conditionnelle permet d'extraire les champs retour, mémorisés pour la vérification de la signature.
   *  - Dans la suite de la boucle, dans la seconde structure conditionnelle, on met en forme les paramètres reçus dans $transaction.
   * - Mise en forme du retour pour le calcul de la signature.
   */
  private function formatParams($params) {
    $formatedReturn = array();
    $formatedReturn['stringToVerify'] = null;
    // Extraction des paramètres reçus
    // $transaction->retour permettra de vérifier la signature
    // $transaction contiendra les informations retournés à XModMonetique
    foreach ($params as $key => $value) {
      // La première structure conditionnelle permet d'extraire les champs retour, mémorisés pour la vérification de la signature
      if ((!strcmp($key,'P_K') == 0) && (!strcmp($key,'P_C') == 0) ) {
	$formatedReturn['stringToVerify'] .= $key."=".urlencode($params[$key])."&";
      }
      // Récupération de la signature (elle n'est pas intégré au calcul de vérification)
      else if (strcmp($key,'P_K') == 0) {
	// Contrairement à la documentation PayBox, on ne urldecode pas la signature (La console le fait implicitement)
	$formatedReturn['signature'] =  base64_decode($params[$key]);
      }
      else if (strcmp($key,'P_C') == 0) {
	// Type de carte utilisée
	// Pas d'url encodage des types de cartes pour la vérification de signature
	$formatedReturn['stringToVerify'] .= $key."=". $params[$key]."&"; 
      }
      /* Dans la suite de la boucle on met en forme les paramètres reçus dans $transaction */
      // On mémorise déjà le montant retourné
      if (strcmp($key,'P_M') == 0) {
	$formatedReturn['amount'] = $params[$key]/100;
      }
      // Mémorisation du code réponse retourné par la banque
      if (strcmp($key,'P_E') == 0) {
	$formatedReturn['responseCode'] = substr($params[$key],3);
      }
      // Récupération de la référence (Le cas paiement multiple est géré)  
      if (strcmp($key,'P_R') == 0) {
	$refInfos = explode("PBX_2MONT", $params[$key]);
	// Contient la référence de la commande
	$formatedReturn['orderReference'] = $refInfos[0];
	if(!empty($refInfos[1])){
	  // Contient les infos de paiement multiple si c'est la cas
	  $moreInfos = $refInfos[1]; 
	  $formatedReturn['nbDeadLine'] = $this->extractMultiPayement($moreInfos);
	}
	else{
	  $formatedReturn['nbDeadLine'] = '1';
	}
      }
      // Numéro d'appel de la transaction (retourné par la banque)
      if (strcmp($key,'P_T') == 0){
	$formatedReturn['numAppel'] = $params[$key];
      }
      // Numéro d'autorisation (retourné par la banque)
      if (strcmp($key,'P_A') == 0){
	$formatedReturn['authId'] = $params[$key];
      }
      // Numéro de transaction (retourné par la banque)
      if (strcmp($key,'P_S') == 0){
	$formatedReturn['numTrans'] = $params[$key];
      }
      // P_N Contient les 4 premiers numéros de carte
      if (strcmp($key,'P_N') == 0){
	$formatedReturn['numCarte'] =$params[$key];
      }
      // P_J contient les 2 derniers numéros de carte
      if (strcmp($key,'P_J') == 0){
	$formatedReturn['numCarte'] = $formatedReturn['numCarte'].'XXXXXXXX'.$params[$key];
	$formatedReturn['numCarte'] = chunk_split($formatedReturn['numCarte'], 4, ' ');
      }
      // P_U Contient les informations nécéssaires à la duplication d'une transaction
      if(strcmp($key,'P_U') == 0){
	$infos = explode('  ', $params[$key]);
	// Mémorisation du porteur (crypté par PayBox)
	$formatedReturn['porteur'] = $infos[0];
	$anneeVal = substr($infos[1], 0, 2);
	$moisVal = substr($infos[1], 2, 4);
	// Mémorisation de la date de validitée
	$formatedReturn['dateVal'] = $moisVal.$anneeVal;
	// Mémorisation du code cvv de la carte
	$formatedReturn['cvv'] = $infos[2];
      }
      // Référence de l'abonné (dans le cadre d'un paiement multiple )
      if (strcmp($key,'P_B') == 0){
	$formatedReturn['refAbonne'] = $params[$key];
      }
      // Identifiant de la transaction (retourné par la banque)
      if(strcmp($key,'P_T') == 0){
	$formatedReturn['transId'] =  $params[$key];
      }
    }
    // Mise en forme du retour pour le calcul de la signature
    // On enlève le dernier '&'
    $formatedReturn['stringToVerify'] = substr($formatedReturn['stringToVerify'] ,0,strlen($formatedReturn['stringToVerify'] )-1);
    // On remplace les espaces par des + pour pouvoir vérifier la signature
    $formatedReturn['stringToVerify']  = str_replace (' ', '+', $formatedReturn['stringToVerify'] ); 
    // Récupération de l'oid de la transaction grâce à la référence commande
    $formatedReturn['oid'] = $this->getIdTransactionWithOrderRef($formatedReturn['orderReference']); 
    return $formatedReturn;
  }

  protected function getNbretour($transactionOid){
    $rs = selectQuery('select nbReturn from '.$this->xset->getTable().' where `KOID`="'.$transactionOid.'"'); 
    $nbReturn = null;
    if($rs->rowCount()==1){
      $nbReturn  = $rs->fetch(PDO::FETCH_COLUMN);
    }
    else{
      XLogs::critical(get_class($this).' ::getNbretour :', 'Transaction ayant pour KOID : '.$transactionOid.' non trouvé!');
    }
    return $nbReturn;
  }
  
  /**
   * \brief Méthode extrait les paramètres de multi-paiement contenue dans la reponse Paybox.
   * \param String $moreInfos : Contient les informations à extraire.
   * \return $nbDeadLine.
   */
  private function extractMultiPayement($moreInfos){
    $infos = explode('PBX_NBPAIE', $moreInfos);
    $nbDeadLine = $infos[1];
    $nbDeadLine = substr($nbDeadLine, 0,2);
    return $nbDeadLine;
  }
  /**
   * \brief Méthode qui génére un numero de question Paybox unique pour la journée.
   * \todo A implémenter.
   */
  private function genNumRequest(){
    
  }

  /**
   * \brief Méthode qui test le serveur disponible pour un dial PPPS (De serveur à serveur).
   * Transforme les paramètres Paybox en paramètres mémorisable par XModMonetique.
   * \param String $url : L'url à tester.
   * \param Int $timeout :
   * - Le temps maximum d'exécution de la fonction CURL.
   * - Le nombre de secondes à attendre durant la tentative de connexion. 
   * \param Int $maxredirs : Le nombre maximal de redirections HTTP à suivre. Utilisez cette option avec l'option CURLOPT_FOLLOWLOCATION.
   * \return Bool $test : True si returnValue = 200 (message : ok -> Requête traitée avec succès), False sinon.
   * \note
   * - Vérifie que l'url apellée est bien en HTTPS.
   * - Initialise la ressources CURL.
   * - Execute la requête.
   * - Si le serveur n'emet aucune reponse c'est qu'il est indisponible :
   *  - Fermeture de la session.
   *  - Retourne False.
   * - Sinon vérifie le code HTTP reçu et retourne le résultat.
   */
  private function urlPPPSdispo($url, $timeout = 10, $maxredirs = 10)
  {
    $returnValue = FALSE;
    // On vérifie que l'url apellée est bien en HTTPS
    if (strpos($url, 'https://') === 0) {
      // Initialisation de la ressource curl
      $ch = curl_init($url);
      // Le temps maximum d'exécution de la fonction CURL.
      curl_setopt($ch, CURLOPT_TIMEOUT, $timeout); 
      // Le nombre de secondes à attendre durant la tentative de connexion. 
      curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, $timeout); 
      // TRUE pour que le corps du transfert ne soit pas inclus dans la value de retour. La méthode de demande est définie à HEAD. 
      curl_setopt($ch, CURLOPT_NOBODY, TRUE); 
      // TRUE pour suivre toutes les en-têtes "Location: " que le serveur envoie dans les en-têtes HTTP (notez que cette fonction est récursive et que PHP suivra toutes les en-têtes "Location: " qu'il trouvera à moins que CURLOPT_MAXREDIRS ne soit définie).
      curl_setopt($ch, CURLOPT_FOLLOWLOCATION, TRUE); 
      // Le nombre maximal de redirections HTTP à suivre. Utilisez cette option avec l'option CURLOPT_FOLLOWLOCATION.
      curl_setopt($ch, CURLOPT_MAXREDIRS, $maxredirs);
      // 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, false); 
      // TRUE pour sortir les informations de certification SSL vers STDERR pour les transferts sécurisés.
      curl_setopt($ch, CURLOPT_CERTINFO, false); 
      // CURL doit vérifier le certificat. Par défaut depuis curl 7.1
      curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, true);
      // 2 pour vérifier l'existence d'un key commun et vérifier qu'il correspond avec le key d'hôte fourni. En environnement de production, la value de cette option doit être conservée à 2 (value par défaut).
      curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 2); 
      //  La version de SSL (2 ou 3) à utiliser.
      curl_setopt($ch, CURLOPT_SSLVERSION, 3); 
      // La réponse du serveur sera dans $result
      $result = curl_exec ($ch); 
      // Si le serveur n'emet aucune reponse c'est qu'il est indisponible
      if($result === false){
	XLogs::critical('Error curl: ', curl_error($ch));
	// Fermeture de la session
	curl_close ($ch); 
	return false;
      }
      // Sinon si le serveur à donné une réponse:
      else{
	$returnValue = curl_getinfo($ch, CURLINFO_HTTP_CODE); // Retourne le dernier code HTTP reçu
      }
      // Fermeture de la ressource curl
      curl_close($ch);
    }else{
      XLogs::critical('L\'url PPPS', 'doit être HTTPS');
    }
    // Retourne true si returnValue = 200 (message : ok -> Requête traitée avec succès), False sinon.
    return ($returnValue == 200);
  }

  /**
   * \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($payboxParams){
    $payboxForm ='';
    foreach($payboxParams as $key => $value){
      $payboxForm .= $key.'='.$value.'&';
    }
    // On enlève le dernier '&'
    $payboxForm = substr($payboxForm,0,strlen($payboxForm)-1); 
    return $payboxForm;
  }

  /**
   * \brief Fonction d'émission d'une requête à Paybox.
   * Envoi une requête CURL à Paybox.
   * \param String $payboxForm : 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.
   * \note
   * - Recherche du serveur disponible (Gestion des mode tests et production).
   * - Si l'url du serveur est accéssible :
   *  - Initialisation d'une session CURL.
   *  - La réponse du serveur sera dans $result.
   *  - Les erreur (s'il y en a) seront dans $error.
   *  - S'il y a une erreur de certificat, $testSSL est valorisé à SSL.
   *  - S'il n'y pas d'erreur et que le résultat n'est pas faux:
   *   - Traitement du retour.
   *  - S'il y a une erreur SSL :
   *   - $transaction->dial = 'erreurSSL';
   *   - $transaction->responseParms = $error;
   *  - Sinon :
   *   - $transaction->responseParms =  $result.$error;
   *   - $transaction->dial = 'ko';
   * \note complémentaire:
   * - Test pour générer une erreur de certificat:
   *  - curl_setopt($ch, CURLOPT_CAPATH, 'test');
   */
  private function sendCurlForm($payboxForm, &$transaction){
    // Recherche du serveur disponible
    if($this->testMode(true)){
      $url = $this->urlPPPStest;
      $urlDispo = $this->urlPPPSdispo($url);
    }
    else{
      $url = $this->$urlPPPS1;
      $urlDispo = $this->urlPPPSdispo($url);
      if (!$urlDispo){
	$url = $this->$urlPPPS2;
	$urlDispo = $this->urlPPPSdispo($url);
      }
    }
    if($urlDispo){
      // Initialisation d'une session CURL
      $ch = curl_init($url);
      // Définition de la méthode POST
      curl_setopt($ch, CURLOPT_POST, 1);
      // Insertion des champs du formulaire
      curl_setopt($ch, CURLOPT_POSTFIELDS, $payboxForm); 
      // Définit que le retour doit être mis dans une variable
      curl_setopt($ch, CURLOPT_RETURNTRANSFER, true); 
      // 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, false);
      // TRUE pour sortir les informations de certification SSL vers STDERR pour les transferts sécurisés.
      curl_setopt($ch, CURLOPT_CERTINFO, false); 
      // CURL doit vérifier le certificat. Par défaut depuis curl 7.1
      curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, true); 
      // 2 pour vérifier l'existence d'un key commun et vérifier qu'il correspond avec le key d'hôte fourni. En environnement de production, la value de cette option doit être conservée à 2 (value par défaut).
      curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 2); 
      //  La version de SSL (2 ou 3) à utiliser.
      curl_setopt($ch, CURLOPT_SSLVERSION, 3); 
      // La réponse du serveur sera dans $result
      $result = curl_exec ($ch);
      // Les erreur (s'il y en a) seront dans $error
      $error = curl_error($ch);
      // S'il y a une erreur de certificat, $testSSL est valorisé à SSL
      $testSSL = substr(curl_error($ch),0 , 3);
      // S'il n'y pas d'erreur et que le résultat n'est pas faux
      if ( ($error == 0) && ($result !== false) ) {
	// Traitement du retour
	$champs = explode('&', $result);
	$transaction->statusComplement = '';
	foreach($champs as $kv){
	  $keyVal = explode('=', $kv);
	  if(!empty($keyVal[1])){
	    $transaction->responseParms[$keyVal[0]] = $keyVal[1];
	  }
	}
	// Fermeture de la session
	curl_close ($ch);
	$transaction->dial = 'ok';
      }
      else if ($testSSL == 'SSL') {
	XLogs::critical('Error curl SSL: ', curl_error($ch));
	// Fermeture de la session
	curl_close ($ch); 
	$transaction->dial = 'erreurSSL';
	$transaction->responseParms = $error;
      }
      else{
	XLogs::critical('Error curl: ', curl_error($ch));
	// Fermeture de la session
	curl_close ($ch); 
	$transaction->responseParms =  $result.$error;
	$transaction->dial = 'ko';
      }
    }
  }

 /* Fonctions de traitement du retour Curl */

  /**
   * \brief Méthode de traitement d'un retour curl Paybox.
   * \param MTransaction &$transaction : La transaction à emettre. 
   * \return MTransaction $transaction : La transaction émise, mise à jour.
   * \note
   * - Extraction du code réponse (retourné par la banque et déffinisant le status de la transaction).
   * - Extraction du commentaire (encodage en utf8, pour une insertion correcte en base).
   * - Si le dial de serveur à serveur s'est déroulé correctement et que la transaction en un succés:
   *  - Mise à jour du status SUCCESS.
   *  - Mémorisation du commentaire dans la complément de status.
   * - Si le dial de serveur à serveur s'est déroulé correctement et que la transaction n'est pas un succés:
   *  - Mise à jour du status ERROR.
   *  - Mémorisation du type d'erreur dans la complément de status.
   * - Si le dial de serveur à serveur indique une erreur de certificat HTTPS:
   *  - $transaction->status = ERROR.
   *  - Il n'y a pas de code bancaire correspondant.
   *  - Mémorisation du message d'erreur retourné par curl dans le statusComplement.
   * - Si le dial n'est pas un succés (Error Curl):
   *  - $transaction->status = WAITTING (La transaction sera à rejouée).
   *  - Dans ce cas reponseParms contient $result.$erreur (retourné par curl).
   * - Si le dial n'a pas du tout abouti (Serveur indisponible):
   *  - Mise à jour du status WAITTING (La transaction sera à rejouée).
   * - Dans tous les autres cas (La transaction est en erreur).
   *  - $transaction->status = ERROR.
   *  - On log les paramètres de cette transaction qui est en erreur.
   */
  private function handlingCurlReturn(&$transaction){
    XLogs::critical(get_class($this).'::handlingCurlReturn', print_r($transaction,true));
    // Extraction du code réponse (retourné par la banque et déffinisant le status de la transaction)
    $transaction->responseCode = $transaction->responseParms['CODEREPONSE'];
    // Extraction du commentaire (encodage en utf8, pour une insertion correcte en base)
    $transaction->responseParms['COMMENTAIRE'] = utf8_encode($transaction->responseParms['COMMENTAIRE']);
    // Si le dial de serveur à serveur s'est déroulé correctement et que la transaction en un succés
    if(( $transaction->responseCode == '00000') && ($transaction->dial == 'ok')) {
      // Mise à jour du status SUCCESS
      $transaction->status = self::SUCCESS;
      // Mémorisation du commentaire dans la complément de status
      $transaction->statusComplement =  $transaction->responseParms['COMMENTAIRE'];
    }
    // Si le dial de serveur à serveur s'est déroulé correctement et que la transaction n'est pas un succés
    else if ($transaction->dial == 'ok') {
      // Mise à jour du status ERROR
      $transaction->status = self::ERROR;
      XLogs::critical(get_class($this).'::handlingCurlReturn', substr($transaction->responseCode,2,1));
      // Mémorisation du type d'erreur dans la complément de status
      if(substr($transaction->responseCode,2,1) != '1'){
	$transaction->statusComplement = $this->getErrorCodePPS(substr($transaction->responseCode,3));
      }
      else{
	$transaction->statusComplement = $this->getErrorCode(substr($transaction->responseCode,3));
      }
    }
    // Si le dial de serveur à serveur indique une erreur de certificat HTTPS
    else if ($transaction->dial == 'erreurSSL') {
      /// \todo Choisir les messsages d'erreur (Pour l'instant ERROR)
      $transaction->status = self::ERROR; 
      // Il n'y a pas de code bancaire correspondant
      $transaction->responseCode ='';
      // Mémorisation du message d'erreur retourné par curl dans le statusComplement
      $transaction->statusComplement = $retour;      
    }
    // Si le dial n'est pas un succés (Error Curl)
    else if ($transaction->dial == 'ko')  {
      $transaction->status = self::WAITTING;
      // Dans ce cas reponseParms contient $result.$erreur (retourné par curl)
      $transaction->statusComplement = $transaction->responseParms; 
    }
    // Si le dial n'a pas du tout abouti (Serveur indisponible)
    else if(empty($transaction->dial )){
      // Mise à jour du status WAITTING (La transaction sera à rejouée)
      $transaction->status = self::WAITTING; 
      $transaction->statusComplement = 'Serveur PPPS indisponible';
      XLogs::critical('Serveur PPPS', 'Indisponible à :'.date('H:i:s d-m-y'));
      XLogs::critical('Error curl', $transaction->responseParms);
    }
    // Dans tous les autres cas (La transaction est en erreur)
    else{
      $transaction->status = self::ERROR;
      $transaction->responseCode ='XXXXX';
      $transaction->statusComplement = 'Error inconnue :'.$transaction->responseParms;
      // On log les paramètres de cette transaction qui est en erreur
      XLogs::critical('::handlingCurlReturn Error inconnue : ', $transaction->responseParms);  
      XLogs::critical('::handlingCurlReturn', print_r($transaction, true) );
    }
  }

 /**
   * \brief Fonction qui retourne le libellé d'une erreur à partir de son code.
   * \param Int $errorCode…

Large files files are truncated, but you can click here to view the full file