Intégration de la passerelle de paiement Authorize.Net à l'aide de PHP

la passerelle de paiement Authorize.Net est l'un des systèmes de paiement les plus utilisés dans les applications de commerce électronique. Il prend en charge les cartes Visa, MasterCard, Discover, Google Pay, PayPal, Apple Pay et tous les services similaires populaires. La passerelle de paiement Autoriser. Net fournit une solution simple et efficace pour intégrer un système de paiement en ligne avec une expérience de paiement fluide.

La passerelle de paiement est la partie la plus importante de l'application de paiement en ligne. Il existe différentes passerelles de paiement disponibles pour intégrer le système de paiement par carte de crédit sur le site Web. Comme la passerelle de paiement Stripe, la passerelle de paiement 2Checkout , le système de paiement Paypal . Dans cet article, nous verrons comment effectuer des transactions de paiement pour débiter une carte de crédit en utilisant la passerelle de paiement Authorize.Net en PHP .

Table des matières

Étapes pour intégrer la passerelle de paiement Authorize.Net

Étape 1 : Créez un compte sandbox Authorize.Net pour obtenir la clé d'identification de l'API de connexion à partir d' ici . Après la création du compte, Sandbox est utilisé pour tester l'intégration de la passerelle de paiement. La capture d'écran suivante montre l'identifiant et la clé de connexion à l'API générés.

Copiez et collez l' ID de connexion API et la clé de transaction sur le bloc-notes pour les utiliser ultérieurement dans le script.

Étape 2 : Créer une table de base de données

Pour stocker les détails de la transaction, une table doit être créée dans la base de données. Donc, copiez la requête MySQL ci-dessous et exécutez cette requête dans la base de données MySQL.

2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
/// Copy and paste this query to create transaction_details
 
CREATE TABLE `transaction_details` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 `name` varchar(50) COLLATE utf8_unicode_ci NOT NULL,
 `email` varchar(50) COLLATE utf8_unicode_ci NOT NULL,
 `item_name` varchar(255) COLLATE utf8_unicode_ci NOT NULL,
 `item_number` varchar(50) COLLATE utf8_unicode_ci NOT NULL,
 `item_price` float(10,2) NOT NULL,
 `item_price_currency` varchar(10) COLLATE utf8_unicode_ci NOT NULL,
 `card_number` bigint(20) NOT NULL,
 `card_exp_month` varchar(2) COLLATE utf8_unicode_ci NOT NULL,
 `card_exp_year` varchar(5) COLLATE utf8_unicode_ci NOT NULL,
 `paid_amount` varchar(10) COLLATE utf8_unicode_ci NOT NULL,
 `txn_id` varchar(50) COLLATE utf8_unicode_ci NOT NULL,
 `payment_status` varchar(25) COLLATE utf8_unicode_ci NOT NULL COMMENT 'Ok | Error',
 `payment_response` enum('1','2','3','4') COLLATE utf8_unicode_ci NOT NULL COMMENT '1=Approved | 2=Declined | 3=Error | 4=Held for Review',
 `created` datetime NOT NULL,
 `modified` datetime NOT NULL,
 PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;
 

Étape 3 : Créer l'API Authorize.Net et la configuration de la base de données (authConfig.php)

2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
<?php 
// Product Details 
$itemName = "Tutorials Authorized Script";  
$itemNumber = "TAUTS001";  
$itemPrice = 10;  
$currency = "USD";  
 
// Authorize.Net API configuration  
define('ANET_API_LOGIN_ID', 'YOUR_API_LOGIN_ID');  
define('ANET_TRANSACTION_KEY', 'YOUR_TRANSACTION_KEY');  
define('ANET_ENV', 'SANDBOX');   // or PRODUCTION 
 
// Database configuration  
define('DB_HOST', 'MySQL_Database_Host');  
define('DB_USERNAME', 'MySQL_Database_Username');  
define('DB_PASSWORD', 'MySQL_Database_Password');  
define('DB_NAME', 'MySQL_Database_Name');
 
?>
 

Remarque : L'identifiant de connexion et la clé de transaction de l'API Authorize.Net se trouvent dans la section API Credentials & Keys de votre compte marchand Authorize.Net.

Étape 4 : Créer une connexion à la base de données (dbconfig.php)

2
3
4
5
6
7
8
9
10
11
12
 
<?php  
// Connect with the database  
$db = new mysqli(DB_HOST, DB_USERNAME, DB_PASSWORD, DB_NAME);  
  
// Display error if failed to connect  
if ($db->connect_errno) {  
    printf("Connect failed: %s\n", $db->connect_error);  
    exit();  
}
 

Étape 5 : Formulaire de paiement (index.php)

Avant tout code HTML, y compris le fichier de configuration. Créez un formulaire HTML pour collecter des informations auprès du client sur l'utilisateur (telles que l'e-mail et le nom) et les détails de la carte (numéro de carte, expiration et numéro CVC). Après la soumission du formulaire, les données sont soumises au script (payment.php) pour le traitement du paiement par carte de crédit.

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
 
<?php 
// Include configuration file  
require_once 'authConfig.php'; 
?>        
 <div class="panel">
    <div class="panel-heading">
        <h3 class="panel-title">Charge <?php echo '$'.$itemPrice; ?> with Authorize.Net</h3>
		
        <!-- Product Info -->
        <p><b>Item Name:</b> <?php echo $itemName; ?></p>
        <p><b>Price:</b> <?php echo '$'.$itemPrice.' '.$currency; ?></p>
    </div>
    <div class="panel-body">
		
        <!-- Payment form -->
        <form action="payment.php" method="POST">
            <div class="form-group">
                <label>NAME</label>
                <input type="text" name="name" placeholder="Enter name" required="" autofocus="">
            </div>
            <div class="form-group">
                <label>EMAIL</label>
                <input type="email" name="email" placeholder="Enter email" required="">
            </div>
            <div class="form-group">
                <label>CARD NUMBER</label>
                <input type="text" name="card_number" placeholder="1234 1234 1234 1234" autocomplete="off" required="" maxlength="16">
            </div>
            <div class="row">
                <div class="left">
                    <div class="form-group">
                        <label>EXPIRY DATE</label>
                        <div class="col-1">
                            <input type="text" name="card_exp_month" placeholder="MM" required="" maxlength="2">
                        </div>
                        <div class="col-2">
                            <input type="text" name="card_exp_year" placeholder="YYYY" required="" maxlength="4">
                        </div>
                    </div>
                </div>
                <div class="right">
                    <div class="form-group">
                        <label>CVC CODE</label>
                        <input type="text" name="card_cvc" placeholder="CVC" autocomplete="off" required="" maxlength="3">
                    </div>
                </div>
                <input type='hidden' name='item_name' value='<?php echo $itemName; ?>'> 
                <input type='hidden' name='amount' value='<?php echo $itemPrice; ?>'> 
                <input type='hidden' name='currency' value='<?php echo $currency; ?>'> 
            </div>
            <button type="submit" class="btn btn-success">Submit Payment</button>
        </form>
    </div>
</div>
 

Étape 6 : Importez le SDK PHP pour accéder à l'API Authorize.Net

Pour le traitement des paiements, nous avons besoin du SDK PHP pour accéder à l'API Autorize.Net. Le compositeur doit importer ce SDK. Assurez-vous d'installer le compositeur sur votre ordinateur et créez un fichier composer.json et ajoutez le script ci-dessous.

2
3
4
5
6
7
8
9
10
 
{
  "require": {
    "php": ">=5.6",
    "ext-curl": "*",
    "authorizenet/authorizenet": ">=1.9.3"
  }
}
 

Ensuite, exécutez la commande suivante.

2
3
4
 
composer update
 

Après cela, vous obtiendrez le dossier du fournisseur . Nous utiliserons ce dossier à l'étape suivante du processus de paiement Authorize.Net.

Étape 7 : Créer un fichier (AuthorizeNetPayment.php) pour ajouter le code de processus de demande de paiement

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
 
<?php
// Include the autoloader of the Authorize.Net PHP SDK.
require 'vendor/autoload.php';
use net\authorize\api\contract\v1 as AnetAPI;
use net\authorize\api\controller as AnetController;
 
class AuthorizeNetPayment
{
 
    private $APILoginId;
    private $APIKey;
    private $APIENV;
    private $refId;
    private $merchantAuthentication;
    public $responseText;
 
 
    public function __construct()
    {
        // Include configuration file        
        require_once "authConfig.php";
        // getting APIkey details from configuration file
        $this->APILoginId = ANET_API_LOGIN_ID;
        $this->APIKey = ANET_TRANSACTION_KEY;
        $this->APIENV = ANET_ENV;
         // Set the transaction's reference ID 
        $this->refId = 'ref' . time();
        $this->merchantAuthentication = $this->setMerchantAuthentication();
        $this->responseText = array("1"=>"Approved", "2"=>"Declined", "3"=>"Error", "4"=>"Held for Review");
    }
 
    public function setMerchantAuthentication()
    {
        // Create a merchantAuthenticationType object with authentication details 
        $merchantAuthentication = new AnetAPI\MerchantAuthenticationType();
        $merchantAuthentication->setName($this->APILoginId);
        $merchantAuthentication->setTransactionKey($this->APIKey);  
        
        return $merchantAuthentication;
    }
     
    public function setCreditCard($cardDetails)
    {    // Create the payment data for a credit card
        $creditCard = new AnetAPI\CreditCardType();
        $creditCard->setCardNumber(preg_replace('/\s+/', '', $cardDetails["card_number"]));
        $creditCard->setExpirationDate( $cardDetails["card_exp_year"] . "-" . $cardDetails["card_exp_month"]);
        $creditCard->setCardCode($cardDetails["card_cvc"]); 
        $paymentType = new AnetAPI\PaymentType();
        $paymentType->setCreditCard($creditCard);
        
        return $paymentType;
    }
    
    public function setOrder($itemName)
    {
        // Create order information 
    $order = new AnetAPI\OrderType(); 
    $order->setDescription($itemName); 
        
        return $order;
    }
    
     public function setCustomer($email)
    {
      // Set the customer's identifying information 
    $customerData = new AnetAPI\CustomerDataType(); 
    $customerData->setType("individual"); 
    $customerData->setEmail($email);  
        
        return $customerData;
    }
    
    public function setTransactionRequestType($paymentType, $amount,$order,$customerData)
    {    // Add the payment data to a paymentType object 
        $transactionRequestType = new AnetAPI\TransactionRequestType();
        $transactionRequestType->setTransactionType("authCaptureTransaction");
        $transactionRequestType->setAmount($amount);
        $transactionRequestType->setOrder($order);
        $transactionRequestType->setPayment($paymentType);
        $transactionRequestType->setCustomer($customerData);
        
        return $transactionRequestType;
    }
 
    public function chargeCreditCard($cardDetails)
    {
      
        $paymentType = $this->setCreditCard($cardDetails);
         $order = $this->setOrder($cardDetails['item_name']);
            $customerdata = $this->setCustomer($cardDetails['email']);
        $transactionRequestType = $this->setTransactionRequestType($paymentType, $_POST["amount"],$order,$customerdata);
 
        // Create a transaction 
        $request = new AnetAPI\CreateTransactionRequest();
        $request->setMerchantAuthentication($this->merchantAuthentication);
        $request->setRefId( $this->refId);
        $request->setTransactionRequest($transactionRequestType);
        $controller = new AnetController\CreateTransactionController($request);
        $response = $controller->executeWithApiResponse(constant("\\net\authorize\api\constants\ANetEnvironment::$this->APIENV"));
        
        return $response;
    }
}
 

Étape 8 : Créer (payment.php) pour débiter la carte de crédit et obtenir la réponse de paiement Authorize.net et mettre à jour la base de données

L'instance de classe AuthorizeNetPayment est créée dans le code PHP ci-dessous et la demande de carte de crédit est créée. En conséquence, la fonction renvoie la réponse de paiement au format JSON.

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
 
<?php
 
require_once "authConfig.php";
 
$type = "";
$statusMsg = "";
if(!empty($_POST['card_number']) && !empty($_POST['card_exp_month']) && !empty($_POST['card_exp_year']) && !empty($_POST['card_cvc'])){ 
    
     // Retrieve card and user info from the submitted form data 
    $name = $_POST['name']; 
    $email = $_POST['email']; 
    $card_number = preg_replace('/\s+/', '', $_POST['card_number']); 
    $card_exp_month = $_POST['card_exp_month']; 
    $card_exp_year = $_POST['card_exp_year']; 
    $card_exp_year_month = $card_exp_year.'-'.$card_exp_month; 
    $card_cvc = $_POST['card_cvc']; 
    
    require_once 'AuthorizeNetPayment.php';
    $authorizeNetPayment = new AuthorizeNetPayment();
    
    $response = $authorizeNetPayment->chargeCreditCard($_POST);
    
    if ($response != null)
    {
        $tresponse = $response->getTransactionResponse();
        
        if (($tresponse != null) && ($tresponse->getResponseCode()=="1"))
        {
            // Transaction info 
                $transaction_id = $tresponse->getTransId(); 
                $payment_status = $response->getMessages()->getResultCode(); 
                $payment_response = $tresponse->getResponseCode(); 
                $auth_code = $tresponse->getAuthCode(); 
                $message_code = $tresponse->getMessages()[0]->getCode(); 
                $message_desc = $tresponse->getMessages()[0]->getDescription(); 
                
                        require_once "dbconfig.php";
         // Insert tansaction data into the database 
                $sql = "INSERT INTO transaction_details (name,email, item_name, item_number, item_price, item_price_currency, card_number, card_exp_month, card_exp_year, paid_amount, txn_id, payment_status, payment_response, created,modified) VALUES ('".$name."', '".$email."', '".$itemName."', '".$itemNumber."', '".$itemPrice."','". $currency."', '".$card_number."', '".$card_exp_month."', '".$card_exp_year."', '".$itemPrice."', '".$transaction_id."', '".$payment_status."', '".$payment_response."', NOW(), NOW())"; 
                $insert = $db->query($sql); 
                $paymentID = $db->insert_id; 
                $ordStatus = 'success'; 
                $statusMsg = 'Your Payment has been Successful!'; 
            
        }else
        {
            $authCode = "";
            $paymentResponse = $tresponse->getErrors()[0]->getErrorText();
            $reponseType = "error";
            $statusMsg  = "Charge Credit Card ERROR :  Invalid response\n";
        }
    }
    else
    {
        $reponseType = "error";
        $statusMsg = "Charge Credit Card Null response returned";
    }
}
?>
 <div class="panel">
    <div class="panel-body">
     <div class="status">
	<?php if(!empty($paymentID)){ ?>
		<h1 class="<?php echo $ordStatus; ?>"><?php echo $statusMsg; ?></h1>
		
		<h4>Payment Information</h4>
		<p><b>Reference Number:</b> <?php echo $paymentID; ?></p>
		<p><b>Transaction ID:</b> <?php echo $transaction_id; ?></p