Mastering Laravel PayU Integration with GuzzleHTTP: A Comprehensive Guide

In the world of e-commerce, integrating secure and reliable payment gateways is crucial for businesses. Laravel, one of the most popular PHP frameworks, offers a seamless way to integrate payment gateways like PayU. This guide will walk you through the process of Laravel PayU integration using GuzzleHTTP. We’ll provide code examples for each type of PayU payment method, answer some frequently asked questions, and conclude with key takeaways.

NowPayments with Laravel: A Perfect Pair for Modern Payment Solutions

Laravel PayU integration using GuzzleHTTP

To Laravel PayU integration, we’ll utilize GuzzleHTTP, a powerful HTTP client for sending HTTP requests. Here’s a step-by-step guide on how to do this:

Step 1: Install GuzzleHTTP

You can install GuzzleHTTP using Composer, the dependency manager for PHP:

Step 2: Configure PayU

First, obtain your PayU API credentials and configure them in your Laravel application, typically in the .env file:

PAYU_MERCHANT_KEY=your_merchant_key
PAYU_SALT=your_salt
PAYU_BASE_URL=https://secure.payu.in

Step 3: Create Routes

Define the routes in routes/web.php for handling payment requests, responses, and notifications:

Route::get('/payment', 'PaymentController@createPayment')->name('payment');
Route::post('/payment/response', 'PaymentController@paymentResponse')->name('payment.response');
Route::post('/payment/notify', 'PaymentController@paymentNotify')->name('payment.notify');

Step 4: Create Controller

Generate a new controller for handling payment requests:

public function createPayment()
{
    $client = new \GuzzleHttp\Client();
    
    $txnid = uniqid(); // Generate a unique transaction ID
    $amount = 100; // Amount in INR (adjust as needed)
    
    $hash = hash(
        'sha512',
        env('PAYU_MERCHANT_KEY') . '|' . $txnid . '|' . $amount . '|Sample Product|John|john@example.com|1234567890|INR|||' . env('PAYU_SALT')
    );
    
    $data = [
        'key' => env('PAYU_MERCHANT_KEY'),
        'txnid' => $txnid,
        'amount' => $amount,
        'productinfo' => 'Sample Product',
        'firstname' => 'John',
        'email' => 'john@example.com',
        'phone' => '1234567890',
        'surl' => route('payment.response'),
        'furl' => route('payment.response'),
        'hash' => $hash,
    ];
    
    try {
        $response = $client->post(env('PAYU_BASE_URL') . '/_payment', [
            'form_params' => $data,
        ]);

        $paymentResponse = $response->getBody();
        
        // You can return the paymentResponse or perform further actions as needed
        return $paymentResponse;
    } catch (\Exception $e) {
        // Handle any exceptions, log errors, or return an error response
        return response()->json(['error' => $e->getMessage()], 500);
    }
}

public function paymentResponse(Request $request)
{
    $status = $request->input('status');
    $txnid = $request->input('txnid');
    $amount = $request->input('amount');
    $hash = $request->input('hash');

    // Verify the response by recalculating the hash
    $expectedHash = hash('sha512', env('PAYU_MERCHANT_KEY') . '|' . $txnid . '|' . $amount . '|INR|' . $status . '|' . env('PAYU_SALT'));

    if ($hash === $expectedHash) {
        // Payment response is valid, handle success
        if ($status === 'success') {
            // Payment was successful, update your database, send confirmation emails, etc.
            return view('payment.success'); // Show a success view
        } elseif ($status === 'failure') {
            // Payment failed, handle accordingly
            return view('payment.failure'); // Show a failure view
        }
    } else {
        // Invalid payment response, handle accordingly
        return view('payment.invalid'); // Show an invalid payment view
    }
}

here’s a sample implementation of the paymentNotify method within the PaymentController. This method handles payment notifications from PayU, which are typically used for asynchronous processing of payment statuses:

public function paymentNotify(Request $request)
{
    // Retrieve and log the notification data
    $notificationData = $request->all();
    \Log::info('PayU Notification Data: ' . json_encode($notificationData));

    // Extract key information from the notification
    $status = $request->input('status');
    $txnid = $request->input('txnid');
    $amount = $request->input('amount');
    $hash = $request->input('hash');

    // Verify the notification by recalculating the hash
    $expectedHash = hash('sha512', env('PAYU_MERCHANT_KEY') . '|' . $txnid . '|' . $amount . '|INR|' . $status . '|' . env('PAYU_SALT'));

    if ($hash === $expectedHash) {
        // Notification is valid, handle payment status
        if ($status === 'success') {
            // Payment was successful, update your database, send confirmation emails, etc.
            // Return a response to acknowledge receipt of the notification
            return response('Payment Success', 200);
        } elseif ($status === 'failure') {
            // Payment failed, handle accordingly
            // Return a response to acknowledge receipt of the notification
            return response('Payment Failure', 200);
        }
    } else {
        // Invalid notification, handle accordingly
        // Return an error response to acknowledge receipt of the notification
        return response('Invalid Notification', 400);
    }
}

In this paymentNotify method, we:

1. Retrieve the notification data sent by PayU and log it for reference.
2. Extract key information from the notification, such as the payment status, transaction ID, amount, and hash.
3. Verify the notification by recalculating the hash based on the received data and comparing it with the hash from PayU. This step ensures the integrity of the notification.
4. Depending on the status of the payment (success or failure), you can perform appropriate actions, such as updating your database, sending confirmation emails, and returning a response to acknowledge receipt of the notification.
5. If the notification is invalid (e.g., hash mismatch), you can handle it by returning an error response to acknowledge receipt of the notification.

Customize this method according to your specific requirements and integrate it with your Laravel application’s logic for processing payment notifications. Additionally, ensure that you configure your PayU account to send notifications to the correct URL where this method is accessible.

Database and Views

To Laravel PayU integration, you can create a model, views, and database migration to manage payment details. Here’s a step-by-step guide:

Step 1: Create a Model First, create a model to manage payments. Run the following command to generate the model:

This will create a Payment model in the app directory. You can define the fields you want to store in the database in the model. Here’s an example of what the model could look like in app/Payment.php:

<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

class Payment extends Model
{
    protected $fillable = [
        'user_id',
        'amount',
        'transaction_id',
        'status',
    ];

    public function user()
    {
        return $this->belongsTo(User::class);
    }
}

Step 2: Create a Migration Generate a migration for the payments table. This migration will create the table in your database with the fields defined in the model. Run the following command:

Then, open the generated migration file (found in the database/migrations directory) and define the schema for the payments table. Here’s an example:

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

class CreatePaymentsTable extends Migration
{
    public function up()
    {
        Schema::create('payments', function (Blueprint $table) {
            $table->id();
            $table->unsignedBigInteger('user_id');
            $table->decimal('amount', 10, 2);
            $table->string('transaction_id');
            $table->string('status');
            $table->timestamps();
        });
    }

    public function down()
    {
        Schema::dropIfExists('payments');
    }
}

Run the migration to create the payments table:

Step 3: Create Views Create views for your payment process. You can create views for payment initiation, success, and failure. Place these views in the resources/views directory.

1. Payment Initiation View: This view is where users initiate the payment process. It should include a form to submit payment information, and it will be used in the createPayment method mentioned earlier.
2. Payment Success View: Displayed after a successful payment.
3. Payment Failure View: Displayed after a failed payment.

Here’s a basic example of what the views might look like:

• resources/views/payment/initiate.blade.php:

<!DOCTYPE html>
<html>
<head>
    <title>Initiate Payment</title>
</head>
<body>
    <form action="{{ route('payment') }}" method="POST">
        @csrf
        <!-- Payment form fields here -->
        <button type="submit">Make Payment</button>
    </form>
</body>
</html>

• resources/views/payment/success.blade.php:

<!DOCTYPE html>
<html>
<head>
    <title>Payment Successful</title>
</head>
<body>
    <h1>Payment Successful</h1>
    <!-- Display payment success message and details -->
</body>
</html>

• resources/views/payment/failure.blade.php:

<!DOCTYPE html>
<html>
<head>
    <title>Payment Failed</title>
</head>
<body>
    <h1>Payment Failed</h1>
    <!-- Display payment failure message and details -->
</body>
</html>

Remember to customize these views according to your design and requirements.

Once you have created the model, migration, and views, you can use them to manage payments in your Laravel PayU integration. Make sure to update your controller methods to interact with the Payment model and store payment data in the database as needed.

Conclusion

Laravel PayU integration using GuzzleHTTP is a powerful and flexible way to handle payments. By following the steps and code examples in this guide, you can create a robust payment gateway for your Laravel-based e-commerce application.

Frequently Asked Questions (FAQ) – Laravel PayU integration

Q1. Can I use Laravel PayU integration for international payments?

PayU primarily supports payments in India, but they also offer services in a few other countries. Ensure you check their availability for your specific region.

Q2. What should I do if the payment is successful or failed?

In the provided code examples, the success and failure routes (surl and furl) handle successful and failed payments. You can define your actions in these routes as per your business logic.

Q3. How can I handle recurring payments with Laravel PayU integration?

To handle recurring payments, you may need to implement a subscription system with Laravel’s built-in tools or integrate with a dedicated subscription service like Stripe or PayPal.

Q4. Is it safe to store PayU credentials in the .env file?

Storing your credentials in the .env file is a common practice. Just make sure the file is protected and not accessible through the web. You can also encrypt sensitive data for an added layer of security.

Key Takeaways

• Laravel PayU integration using GuzzleHTTP is a secure and efficient way to handle payments.
• Different payment methods, such as credit card, net banking, and wallets, can be easily implemented.
• Always follow best security practices when handling sensitive payment information.

With this guide, you’re well-equipped to Laravel PayU integration and create a seamless payment experience for your users. Happy coding!