Laisser un commentaire

Installer l'API PHP ATOS (sogenactif)

Un beau matin, vous vous dites - ou on vous dit - que vous aller devoir installer un kit de paiement ATOS. Et là vous pensez : gaaalèère… Mais non, suivez moi, j’ai déjà galéré pour vous et je vais vous guider. Ça passera comme une bonne bière après le boulot !

Préparatifs

Télécharger l’API

Avant toute chose, il faut télécharger l’API qui va bien. Vous avez normalement dû recevoir un mail de votre banque qui vous donne un identifiant de connexion à l’interface de téléchargement, et un papier par la poste qui vous donne le mot de passe.

Premier constat, lorsqu’on se logue sur l’interface de téléchargement de l’API : Wahou ! ça sent bon l’austérité ici…

page de telechargement de l'api

Il faut donc télécharger l’API PHP sogenactif_615_PLUGIN_linux-2.6.9.tar. Il y en a aussi une en 64 bits, vous pouvez alternativement prendre celle-ci si vous avez un système 64 bits (quoique le 32 devrait aussi marcher sur un système 64 bits).

Détarrer l’archive

Détarrez l’archive, vous devriez obtenir cette arborescence :

schéma de l'arborescence de l'api ATOS 615

Attention : vous voyez que dans les sous-dossiers de bin, glibc-2.3.4 et static, vous avez les mêmes exécutables request et response. Eh bien que neni m’sieur ! Oui ça paraît logique qu’ils soient différents mais attention de bien choisir le votre. Si vous avez glibc sur votre serveur, ce sont les exécutables du dossier glibc qu’il faudra utiliser. Donc dans mon cas, pour un mutualisé OVH, c’est glibc. Ça vous évitera des incompréhensions face à cette page d’erreur laconique qui ne vous dit rien de plus que “erreur appel request” et “exécutable request non trouvé”.

Quelques fichiers de test

Je vous conseille de vous créer un fichier php qui vérifie les chemins, comme ça, si vous avez une erreur du genre, vous êtes fixé rapidement.

<?php echo file_exists('chemin a verifier'); ?>

Profitez-en pour créer deux autres fichiers php. Un que l’on appelera info.php et qui contient la fonction phpinfo :

<?php phpinfo(); ?>

L’autre peut être facultatif, il permettra de trouver les chemins absolus de votre serveur mais vous pourrez aussi les obtenir par ssh, c’est à vous de voir ce qui est le plus pratique, ou alors, si votre hébergeur ne vous fournis pas d’accès ssh, la question est réglée. Nous appellerons ce fichier chemin.php.

<?php echo realpath('chemin.php') ; ?>

Placer les fichiers sur le serveur

Placez le fichier info.php sur votre hébergement et appelez-le via votre navigateur. Si le safe mode est à ON, vous devrez copier les fichiers exécutables request et response dans le répertoire défini à la ligne safe_mode_exec_dir, sinon, vous pouvez mettre les exécutables où vous voulez sur l’hébergement.

phpinfo safe mode

Dernière étape avant que nous entrions dans le vif du sujet, copiez les dossiers et fichiers sur votre hébergement. Créons un dossier payment, et dans lequel nous plaçons le dossier logo, les fichiers certif.fr.014213245611111.php et parmcom.014213245611111, parmcom.sogenactif ainsi que pathfile et les exécutables request et response. Rappelez-vous que si votre hébergement a la directive safe mode à ON, il faudra placer les exécutables dans le répertoire indiqué. Réglez le CHMOD de request et response à 755.

Note : le fichier certif.fr.014213245611112.php (fini par un 2) est utilisé pour simuler un paiement 3D secure, le reste de la procédure est identique.

Note 2 : les contrats nouvellement souscrits sont automatiquement 3D secure (en tout cas à la Société Génerale). Faites donc vos tests avec le certificat 3D secure.

Configuration des fichiers

Nous avons trois fichiers de configuration à renseigner. Il s’agit de :

Leur configuration est relativement aisée et rapide, il suffit de faire attention à renseigner les champs correctement sans se tromper, sinon, l’API retournera des erreurs assez évasives, et ce sera parti pour la chasse à l’épingle dans le foin…
Note : l’API n’apprécie pas du tout les espaces dans les chemins, donc gare !

Le fichier pathfile

Le fichier pathfile renseigne l’API sur les chemins de différents fichiers et dossiers dont il a besoin pour fonctionner. Il prend 6 paramètres :

#########################################################################
#
#    Pathfile
#
#    Liste fichiers parametres utilises par le module de paiement
#
#########################################################################
#
#
#-------------------------------------------------------------------------
# Activation (YES) / DÈsactivation (NO) du mode DEBUG
#-------------------------------------------------------------------------
#
DEBUG!NO!
#
# ------------------------------------------------------------------------
# Chemin vers le rÈpertoire des logos depuis le web alias
# Exemple pour le rÈpertoire www.merchant.com/sogenactif/payment/logo/
# indiquer:
# ------------------------------------------------------------------------
#
D_LOGO!/payment/logo/!
#
# --------------------------------------------------------------------------
#  Fichiers paramËtres liÈs a l'api sogenactif paiement
# --------------------------------------------------------------------------
#
# certificat du commercant
#
F_CERTIFICATE!/homez.374/monsite/www/payment/certif!
#
# type du certificat
#
F_CTYPE!php!
#
# fichier paramËtre commercant
#
F_PARAM!/homez.374/monsite/www/payment/parmcom!
#
# fichier des paramËtres sogenactif
#
F_DEFAULT!/homez.374/monsite/www/payment/parmcom.sogenactif!
#
#########################################################################
# End of file
#########################################################################

Note : Les chemins sont ici des chemins physiques absolus. Pour les trouver, deux méthodes :

Le fichier parmcom.sogenactif

Ce fichier prend de nombreux paramètres, rassurez-vous, la plupart sont pré-renseignés et vous n’aurez pas besoin d’y toucher. Pour plus de renseignements, tournez-vous vers le dictionnaire des données. Le seul paramètre qu’il nous faut réellement configurer concerne la liste des moyens de paiement acceptés (PAYMENT_MEANS). Elle proposera les différent moyens de paiements à vos internautes. Configurez bien cette liste en adéquation avec votre contrat. Si vous avez souscrit un contrat pour CB et VISA seulement, ne mettez pas Mastercard, vous aurez sinon une erreur par la suite.

Ce code vaut pour CB et VISA seulement :

PAYMENT_MEANS!CB,2,VISA,2!

Et celui-ci ajoute les cartes Mastercard et American Express :

PAYMENT_MEANS!CB,2,VISA,2,MASTERCARD,2,AMEX,2!

Les blocs 1 à 8 (CB,2 désigne un bloc) permettent d’afficher différents messages et d’ordonner l’affichage des cartes. Un exemple avec le code suivant :

PAYMENT_MEANS!CB,2,VISA,2,MASTERCARD,1,AMEX,1!
page de payement sélection des cartes

Vous constatez aussi que le paramètre block_order ordonne les blocs. Mastercard et Amex, qui sont dans le bloc 1 sont affichés au-dessus de CB et VISA, respectivement dans le bloc 2.

Ce fichier parmcom.sogenactif permet la personnalisation de votre page de paiement :

personnalisation de la page de payement 
###############################################################################
#
#    Fichier des parametres Sogenactif paiement
#
#    Remarque :    Ce fichier paramËtre est sous la responsabilitÈ de la
#                Societe Generale
#
###############################################################################


# Logo de la Societe Generale

ADVERT!sg.gif!

# couleur du fond d'ecran (blanc)

BGCOLOR!ffffff!

# Mode d'affichage des blocs de paiment

BLOCK_ALIGN!center!

# Ordre d'affichage des blocs de paiement

BLOCK_ORDER!1,2,3,4,5,6,7,8!

# Mode de securite

CONDITION!SSL!

# Code devise  ( 978=EURO )

CURRENCY!978!

# flag d'edition des libelles des blocs de paiement

HEADER_FLAG!yes!

# Code langage de l'acheteur (fr=francais)

LANGUAGE!fr!

# Logo Interactis paiement

LOGO2!sogenactif.gif!

# Code pays du commercant

MERCHANT_COUNTRY!fr!

# Code langage du commercant

MERCHANT_LANGUAGE!fr!

# Liste des moyens de paiement acceptes

PAYMENT_MEANS!CB,2,VISA,2!

# Passage en une seule frame securisee au moment du paiement

TARGET!_top!

# Couleur du text (noir)

TEXTCOLOR!000000!


# END OF FILE

Note : Les logos prennent en paramètre uniquement leurs noms plus leurs extensions car ils seront mis sur le serveur de paiement de la banque. Avant de passer en production, vous enverrez un mail au support technique avec les logos à intégrer sur la page de paiement. logo_id1 se renseigne dans le parmcom commerçant.

Attention : Le fichier parmcom.sogenactif permet de renseigner certaines options que l’on peut aussi renseigner dans le script call_request.php (langue du commerçant, devise…), si les renseignements ne coïncident pas, les paramètres de call_request seront pris en compte.

commerçant

Le fichier parmcom.014213245611111 demande 4 paramètres :

###############################################################################
#
#    Fichier des parametres du commercant
#
#    Remarque :    Ce fichier paramËtre est sous la responsabilitÈ du
#                commercant
#
###############################################################################

# Logo du commercant (il apparait en haut a gauche des pages de paiement)

LOGO!logo.gif!

# URL de retour automatique de la reponse du paiement

AUTO_RESPONSE_URL!http://www.votre-site.com/call_autoresponse.php!

# URL de retour suite a paiement refuse

CANCEL_URL!http://www.votre-site.com/cancel.php!

# URL de retour suite a paiement accepte

RETURN_URL!http://www.votre-site.com/call_response.php!


# END OF FILE

Note : les chemins sont ici des chemins internet absolus.

Nos scripts php

Vous trouverez les scripts php dans le dossier sample de votre API. Contrairement aux autres fichiers et dossiers, nous placerons ces fichiers à la racine de notre site. On pourra donc appeler le call_request via un navigateur internet, comme cela : http://www.mon-site.fr/call_request.php

Vous pouvez les placer dans un autre répertoire de votre choix, cependant, la démarche est plus simple comme cela. C’est pourquoi nous procéderons ainsi.

Attention : ATOS ne mettant pas (régulièrement) à jour sa documentation, vous veillerez à remplacer $HTTP_POST_VARS par $_POST dans vos codes. En effet, cette variable permettant de récupérer les valeurs passées en POST est obsolète depuis la version 4.1.0 de PHP et a été totalement supprimée dans la 5.6.

Si vous l’utilisez avec une version de php > 5.5, vous obtiendrez une erreur “Error get DATA response parameter“ sur les pages call_response.php et call_autoresponse.php.

call_request.php

Dans le dossier sample, vous trouverez un fichier php nommé call_request.php. C’est lui qui va initier la phase de paiement en appelant l’exécutable request et qui affichera la page de sélection des cartes.

construction du formulaire call request

Le fichier call_request.php prend de nombreux paramètres. Parmi ceux-ci, beaucoup sont facultatifs, nous n’en parlerons donc pas. Vous pouvez pour cela vous référer au dictionnaire des données.

//Affectation des paramètres obligatoires
$parm="merchant_id=014213245611111";
$parm="$parm merchant_country=fr";
$parm="$parm amount=100";
$parm="$parm currency_code=978";

Nous avons d’abord les paramètre obligatoires qui seront transmis à l’exécutable request :

Attention : petite particularité, le montant doit être transmis en centimes. Par exemple, pour un montant total de 100€, vous transmettrez le chiffre 10000 à votre variable. Vous pouvez utiliser number_format pour mettre votre total au bon format.

$amount = number_format($amount, 2, '', ' ');

Vous devez ensuite renseigner le chemin absolu (attention chemin physique, pas internet) des fichiers pathfile et reqest. Utilisez chemin.php comme nous l’avons vu précédemment.

Le transaction_id est un numéro de transaction qui doit être unique sur la journée. Comme le commentaire le précise, il n’est pas obligatoire de fournir ce numéro de transaction. Si vous n’en fournissez pas, le système se chargera d’en générer un pour vous à partir de l’heure. Cependant, si deux visiteurs cliquent en même temps, nous risquons d’avoir deux transaction_id identiques. Pour évitez cela, nous allons générer le notre :

//ID unique de transaction
//Nous allons nous baser sur le temps UNIX pour générer notre numéro,
//cependant, ce timestamp a le même problème que celui généré par le systeme.
//Pour y remédier, nous allons le multiplier par un nombre aléatoire
//(j’ai choisi entre 0 et 10, c’est tout à fait arbitraire)
$transactionID = time() * rand (1,99);

//ID unique de transaction est nombre compris entre 0 et 999 999.
//Nous allons donc tronquer notre nombre pour qu’il soit toujours inférieur à 1 million.
$transactionID = substr($transactionID, -6);

Nous utiliserons également le champ order_id, qui est facultatif, car il peut contenir jusqu’à 32 caractères. C’est bien plus pratique que le transaction_id pour identifier de manière unique une transaction. Ce champ est retourné tel quel dans la réponse lorsque le serveur de la banque appelle autoresponse. Pour générer de manière unique un identifiant, on peut utiliser la fonction uniqid() de php, laquelle fournit une chaine de 23 caractères basée sur l’heure courante en microseconde.

Vous trouverez ci-dessous l’intégralité de la partie métier du call_request. Pensez bien que pour des raisons de brièveté, je n’inclue ici pas l’intégralité du html. Cependant, n’oubliez pas de servir une page html valide à vos clients !

if ($_POST['amount']) {
    // on arrive dans cet exemple sur le call_request
    // par un formulaire qui transmet le montant
    // on le récupère donc
    $amount = (int)$_POST['amount'];

    $parm="merchant_id=014213245611111";
    $parm="$parm merchant_country=fr";

    // montant total formaté en centimes --> 100€ = 10000
    $parm="$parm amount=".$amount;
    $parm="$parm currency_code=978";

    // Initialisation du chemin du fichier pathfile (à modifier)
    $parm="$parm pathfile=/homez.374/monsite/www/payment/pathfile";

    // Si aucun transaction_id n'est affecté, request en génère
    // un automatiquement à partir de heure/minutes/secondes
    // Référez vous au Guide du Programmeur pour
    // les réserves émises sur cette fonctionnalité
    $transactionID = time() * rand (1,99);
    $transactionID = substr($transactionID, -6);
    $parm="$parm transaction_id=".$transactionID;

    // comme expliqué plus haut il est plus facile d'identifier
    // la commande avec un order_id
    $order_id = uniqid();
    $parm="$parm order_id=".$order_id;

    $path_bin ="/homez.374/monsite/www/payment/request";

    // Appel du binaire request
    $parm = escapeshellcmd($parm);
    $result=exec("$path_bin $parm");

    // sortie de la fonction : $result=!code!error!buffer!
    // - code=0 : la fonction génère une page html contenue dans la variable buffer
    // - code=-1 : La fonction retourne un message d'erreur dans la variable error
    // On separe les differents champs et on les met dans une variable tableau
    $tableau = explode ("!", "$result");

    // récupération des paramètres
    $code = $tableau[1];
    $error = $tableau[2];
    $message = $tableau[3];

    //  analyse du code retour
    if (($code == "") && ($error == "")) {
        print ("<BR><CENTER>erreur appel request</CENTER><BR>");
        print ("executable request non trouve $path_bin");
    }

    // Erreur, affiche le message d'erreur
    else if ($code != 0) {
        print ("<center><b><h2>Erreur appel API de paiement.</h2></center></b>");
        print ("<br><br><br>");
        print (" message erreur : $error <br>");
    }

    // OK, affiche le formulaire HTML
    else {
        print ("<br><br>");

        # OK, affichage du mode DEBUG si activÈ
        print (" $error <br>");
        print ("  $message <br>");
    }

    // on peut faire ici ses enregistrements en base de données
    // bien enregistrer order_id car c'est lui qui lie le paiement
    // aux autres informations de la commande et du client
}

Avertissement : Prenez soin de mettre en base de données toutes les informations concernant votre client avant de l’envoyer sur la page de paiement. En effet, il se peut que celui-ci ne revienne pas sur votre site après que le serveur de la banque lui ait donné confirmation du paiement. Le serveur de la banque appellera automatiquement votre script autoresponse.php pour vous notifier du succès ou de l’échec du paiement. Cependant, votre seul moyen d’identifier le client sera le transaction_id ou l’order_id. C’est pourquoi il est impératif d’enregistrer en base de données avant que le client ne soit envoyé sur le serveur de paiement, sans quoi, vous ne saurez pas qui a payé, et qui n’a pas payé…

Dans cet exemple, nous enregistrons les informations dans le call_request. On pourrait également générer le order_id et enregistrer les informations en amont. Ce dernier serait alors transmis en $_POST avec le montant de la commande. Vous pouvez aussi gérer ça avec des sessions, bref, tout est possible tant que vous enregistrez les infos en base avant que le client ne parte sur le serveur de la banque.

MAJ

Comme vous pouvez le constater dans les commentaires, un lecteur m’a fait part d’une procédure un peu différente chez lui (pourtant aussi sur un mutualisé OVH…) Donc ceux qui n’arrivent pas à passer l’étape de l’erreur avec le message “erreur appel request“, vous pouvez tenter cette procédure alternative.

En plus des exécutables request et response, Thierry a dû mettre les droits du pathfile à 755 aussi. En outre, concernant les chemins du call_request, au lieu de renseigner les chemins physiques absolus, ils sont comme ceci :

$parm="$parm pathfile=./pathfile";
$path_bin = "./request";

call_response.php

Le fichier call_response.php est la page web sur laquelle le visiteur est redirigé après son paiement s’il clique sur « retourner sur le site du commerçant ». Cette page retourne certaines variables utiles, comme le succès ou l’échec du paiement. Cependant, comme précisé plus haut, le visiteur peut ne pas revenir sur notre site et cette page ne sera jamais appelée. Aussi, il préférable d’effectuer les traitements de base de données avec le script autoresponse.php, qui retourne les mêmes informations, mais qui sera systématiquement appelé par le serveur de la banque.

Nous nous contenterons ici de renseigner les variables indispensables. À savoir : le pathfile et l’exécutable response. Ces chemins se renseignent de la même manière que dans le script call_request.php.

// Initialisation du chemin du fichier pathfile (à modifier)
//   ex :
//    -> Windows : $pathfile="pathfile=c:/repertoire/pathfile";
//  -> Unix    : $pathfile="pathfile=/home/repertoire/pathfile";

$pathfile="pathfile=/homez.374/monsite/www/payment/pathfile";

// Initialisation du chemin de l'executable response (à modifier)
// ex :
// -> Windows : $path_bin = "c:/repertoire/bin/response";
// -> Unix    : $path_bin = "/home/repertoire/bin/response";

$path_bin = "/homez.374/monsite/www/payment/response";

Nous afficherons tout de même un message à notre client selon que le paiement s’est déroulé correctement ou non. La variable $bank_response_code nous informe de l’état du paiement. Vous allez le constater, nous ne gardons ici pas grand chose du fichier d’exemple d’origine. Peu de variables servent finalement puisque nous n’effectuons pas de traitement sur cette page. Elles peuvent en revanche trouver leur utilité lors de la phase de test.

// Récupération de la variable cryptée DATA
//$message="message=$HTTP_POST_VARS[DATA]";

// Attention, la variable $HTTP_POST_VARS n'existe plus dans les versions récentes de php
$message="message=$_POST[DATA]";

// Initialisation du chemin du fichier pathfile (à modifier)
$pathfile="pathfile=/homez.374/monsite/www/payment/pathfile";

// Initialisation du chemin de l'executable response (à modifier)
$path_bin = "/homez.374/monsite/www/payment/response";
  
// Appel du binaire response
$message = escapeshellcmd($message);
$result=exec("$path_bin $pathfile $message");

// on separe les differents champs et on les met dans une variable tableau
$tableau = explode ("!", $result);

// Récupération des données de la réponse
$code = $tableau[1];
$error = $tableau[2];
$bank_response_code = $tableau[18];

// analyse du code retour
if (($code == "") && ($error == "")) {
    print ("<BR><CENTER>erreur appel response</CENTER><BR>");
    print ("executable response non trouve $path_bin");
}

// Erreur, affiche le message d'erreur
else if ($code != 0) {
    print("<center><b><h2>Erreur appel API de paiement.</h2></center></b>");
    print("<br><br><br>");
    print(" message erreur : $error <br>");
}

// OK, affichage des champs de la réponse
else {
    if ($bank_response_code == 00) {?>
        <h1>La transaction s'est effectuée avec succès !</h1>
        <h2>
            Nous vous remercions de la confiance que vous
            nous accordez. Vous recevrez un e-mail de confirmation
            pour vous avertir du traitement de votre commande.
        </h2>
    <?php
    }

    else {
        echo'<h1>Une erreur s\'est produite durant la phase de paiement.</h1>
        <h2>Vous pouvez nous contacter par téléphone pour remédier au problème : 00 00 00 00 00.</h2>';
    }
}

Autoresponse.php

De la même manière que dans le script call_response, verifiez si la variable $bank_response_code contient le code 00, et si oui, mettez à jour votre base de données pour confirmer que le paiement du client a bien été accepté.

Le call_autoresponse.php complet :

<!--
-------------------------------------------------------------
 Topic     : Exemple PHP traitement de l'autoréponse de paiement
 Version : P615

         Dans cet exemple, les données de la transaction    sont
        décryptées et sauvegardées dans un fichier log.

-------------------------------------------------------------
-->

<?php

// Récupération de la variable cryptée DATA
// $message="message=$HTTP_POST_VARS[DATA]";

// Attention, la variable $HTTP_POST_VARS n'existe plus dans les versions récentes de php
$message="message=$_POST[DATA]";

// Initialisation du chemin du fichier pathfile (à modifier)
//   ex :
//    -> Windows : $pathfile="pathfile=c:/repertoire/pathfile"
//    -> Unix    : $pathfile="pathfile=/home/repertoire/pathfile"

$pathfile="pathfile=/homez.374/monsite/www/payment/pathfile";

// Initialisation du chemin de l'executable response (à modifier)
//ex :
//-> Windows : $path_bin = "c:/repertoire/bin/response"
//-> Unix    : $path_bin = "/home/repertoire/bin/response"

$path_bin = "/homez.374/monsite/www/payment/response";

// Appel du binaire response
$message = escapeshellcmd($message);
$result=exec("$path_bin $pathfile $message");

// Sortie de la fonction : !code!error!v1!v2!v3!...!v29
//- code=0    : la fonction retourne les données de la transaction dans les variables v1…
//        : Ces variables sont décrites dans le GUIDE DU PROGRAMMEUR
//- code=-1     : La fonction retourne un message d'erreur dans la variable error

//on separe les differents champs et on les met dans une variable tableau

$tableau = explode ("!", $result);

$code = $tableau[1];
$error = $tableau[2];
$merchant_id = $tableau[3];
$merchant_country = $tableau[4];
$amount = $tableau[5];
$transaction_id = $tableau[6];
$payment_means = $tableau[7];
$transmission_date= $tableau[8];
$payment_time = $tableau[9];
$payment_date = $tableau[10];
$response_code = $tableau[11];
$payment_certificate = $tableau[12];
$authorisation_id = $tableau[13];
$currency_code = $tableau[14];
$card_number = $tableau[15];
$cvv_flag = $tableau[16];
$cvv_response_code = $tableau[17];
$bank_response_code = $tableau[18];
$complementary_code = $tableau[19];
$complementary_info= $tableau[20];
$return_context = $tableau[21];
$caddie = $tableau[22];
$receipt_complement = $tableau[23];
$merchant_language = $tableau[24];
$language = $tableau[25];
$customer_id = $tableau[26];
$order_id = $tableau[27];
$customer_email = $tableau[28];
$customer_ip_address = $tableau[29];
$capture_day = $tableau[30];
$capture_mode = $tableau[31];
$data = $tableau[32];
$order_validity = $tableau[33];
$transaction_condition = $tableau[34];
$statement_reference = $tableau[35];
$card_validity = $tableau[36];
$score_value = $tableau[37];
$score_color = $tableau[38];
$score_info = $tableau[39];
$score_threshold = $tableau[40];
$score_profile = $tableau[41];


// Initialisation du chemin du fichier de log (à modifier)
//   ex :
//    -> Windows : $logfile="c:\repertoire\log\logfile.txt";
//    -> Unix    : $logfile="/home/repertoire/log/logfile.txt";

$logfile="/homez.374/monsite/www/payment/logfile.txt";

// Ouverture du fichier de log en append

$fp=fopen($logfile, "a");

// analyse du code retour

if (( $code == "" ) && ( $error == "" ) ) {
    fwrite($fp, "erreur appel response\n");
    print ("executable response non trouve $path_bin\n");
}

// Erreur, sauvegarde le message d'erreur

else if ( $code != 0 ) {
    fwrite($fp, " API call error.\n");
    fwrite($fp, "Error message :  $error\n");
}

else {
    // OK, Sauvegarde des champs de la réponse

    fwrite( $fp, "merchant_id : $merchant_id\n");
    fwrite( $fp, "merchant_country : $merchant_country\n");
    fwrite( $fp, "amount : $amount\n");
    fwrite( $fp, "transaction_id : $transaction_id\n");
    fwrite( $fp, "transmission_date: $transmission_date\n");
    fwrite( $fp, "payment_means: $payment_means\n");
    fwrite( $fp, "payment_time : $payment_time\n");
    fwrite( $fp, "payment_date : $payment_date\n");
    fwrite( $fp, "response_code : $response_code\n");
    fwrite( $fp, "payment_certificate : $payment_certificate\n");
    fwrite( $fp, "authorisation_id : $authorisation_id\n");
    fwrite( $fp, "currency_code : $currency_code\n");
    fwrite( $fp, "card_number : $card_number\n");
    fwrite( $fp, "cvv_flag: $cvv_flag\n");
    fwrite( $fp, "cvv_response_code: $cvv_response_code\n");
    fwrite( $fp, "bank_response_code: $bank_response_code\n");
    fwrite( $fp, "complementary_code: $complementary_code\n");
    fwrite( $fp, "complementary_info: $complementary_info\n");
    fwrite( $fp, "return_context: $return_context\n");
    fwrite( $fp, "caddie : $caddie\n");
    fwrite( $fp, "receipt_complement: $receipt_complement\n");
    fwrite( $fp, "merchant_language: $merchant_language\n");
    fwrite( $fp, "language: $language\n");
    fwrite( $fp, "customer_id: $customer_id\n");
    fwrite( $fp, "order_id: $order_id\n");
    fwrite( $fp, "customer_email: $customer_email\n");
    fwrite( $fp, "customer_ip_address: $customer_ip_address\n");
    fwrite( $fp, "capture_day: $capture_day\n");
    fwrite( $fp, "capture_mode: $capture_mode\n");
    fwrite( $fp, "data: $data\n");
    fwrite( $fp, "order_validity: $order_validity\n");
    fwrite( $fp, "transaction_condition: $transaction_condition\n");
    fwrite( $fp, "statement_reference: $statement_reference\n");
    fwrite( $fp, "card_validity: $card_validity\n");
    fwrite( $fp, "card_validity: $score_value\n");
    fwrite( $fp, "card_validity: $score_color\n");
    fwrite( $fp, "card_validity: $score_info\n");
    fwrite( $fp, "card_validity: $score_threshold\n");
    fwrite( $fp, "card_validity: $score_profile\n");
    fwrite( $fp, "-------------------------------------------n");
}

fclose ($fp);

if (!empty($bank_response_code) && $bank_response_code == 00) {
    // Tout s'est bien passé,
    // on valide donc le paiement et on effectue nos traitements en base de données
}

Tester l’interface

Maintenant que nous avons fini de paramétrer l’interface, il faudrait la tester pour vérifier que tout fonctionne… Simulez donc un achat, cliquez sur une carte bancaire, vous vous trouvez alors sur le serveur de test de la banque. Voici les codes de cartes pour opérer vos tests :

Numéro de Carte Code de réponse
4974934125497800 00 (paiement accepté)
4972187615205 05 (paiement refusé)
Cryptogramme ccv_response_code
600 4D
640 4D
650 50
653 53
645 55

Si/quand tous vos tests sont couronnés de succès, vous pouvez passez à l’ultime étape avant la mise en production, direction la pré-production !

Passer en pré-production et en production

Note : comme le fait remarquer Nico dans les commentaires, à ce stade, pensez à désactiver le mode DEBUG.

Lorsque vous en arrivez là, le plus dur est fait. Pour pouvoir passer en production, il faut que vous ayez réussi au moins une transaction en pré-production. Les cartes utilisées seront cette fois-ci des cartes réelles, mais vous ne serez pas débité.

Pour passer en pré-production, vous devrez remplacer le certificat de test par votre certificat de commerçant délivré par la banque. Il vous faudra remplacer votre merchant_id dans le fichier call_request.php, télécharger le certificat de commerçant que la banque vous a délivrée, et changer le nom du fichier parmcom.014213245611111 par parmcom.xxxxxxxxxxxxxxx où xxxxxxxxxxxxxxx désigne votre merchant_id. Lorsque le test avec la vrai carte bancaire aura été concluant, il vous faudra imprimer le PV de recette et envoyer un Fax à votre banque pour qu’il passe votre API en production à la date et à l’heure que vous leur indiquerez.

Rappel : N’oubliez pas de transmettre vos logos par email au support technique pour qu’il les intègre sur le serveur de paiement. Ceci peut prendre un certain temps (un ou deux jours).

Puisque vous en êtes à installer une solution de paiement, avez-vous pensé à Paypal ? Même en complément d’une solution bancaire, Paypal est devenu incontournable. Comparé à la solution ATOS et quelque soit l’API choisie, Paypal est un jeux d’enfant à mettre en place. Voyez mon article sur l’intégration de Paypal IPN.

Dans un souci d’amélioration, je serai reconnaissant envers quiconque me signalera une erreur ou me fera part de suggestions.

Commentaires

Rejoignez la discussion !

Vous pouvez utiliser Markdown pour les liens [ancre de lien](url), la mise en *italique* et en **gras**. Enfin pour le code, vous pouvez utiliser la syntaxe `inline` et la syntaxe bloc 

```
ceci est un bloc
de code
```