Payment Request

Code samples to generate Signature hash while initiating payment, Use the generate signature in Init-Payment API

Golang

import (

"crypto/hmac"

"crypto/sha256"

"encoding/base64"

)

type RequestObj struct {

ClientKey string

Currency string

Amount string

MerchantOrderId string

SuccessUrl string

FailureUrl string

}

func GenerateSignature(requestObj RequestObj, secretKey string) string {

params := make(url.Values)

params.Add("client_key", requestObj.ClientKey)

params.Add("currency", requestObj.Currency)

params.Add("amount", requestObj.Amount)

params.Add("merchant_order_id", requestObj.MerchantOrderId)

params.Add("success_url", requestObj.SuccessUrl)

params.Add("failure_url", requestObj.FailureUrl)

data := params.Encode()

secret := []byte(secretKey)

message := []byte(data)

hash := hmac.New(sha256.New, secret)

hash.Write(message)

// to base64

hash_value := base64.StdEncoding.EncodeToString(hash.Sum(nil))

return hash_value

}

PHP

<?php

function GenerateSignature($requestObj, $secretKey) {

$data = array(

'amount' => $requestObj.Amount,

'currency' => $requestObj.Currency,

'failure_url' => $requestObj.FailureUrl,

'merchant_order_id' => $requestObj.MerchantOrderId,

'client_key' => $requestObj.ClientKey,

'success_url' => $requestObj.SuccessUrl

);

ksort($data);

$data = http_build_query($data);

$message = $data;

return base64_encode(hash_hmac('sha256', $message, $secretKey, true));

}

?>

NodeJS

var url = require('url');

var crypto = require('crypto');

function GenerateSignature(requestObj, secretKey) {

const params = new URLSearchParams();

params.append('amount', requestObj.Amount)

params.append('currency', requestObj.Currency)

params.append('failure_url', requestObj.FailureUrl)

params.append('merchant_order_id', requestObj.MerchantOrderId)

params.append('client_key', requestObj.ClientKey)

params.append('success_url', requestObj.SuccessUrl)

params.sort();

var message = params.toString()

var hash_value = crypto.createHmac('sha256', secretKey).update(message).hash.digest('base64');

return hash_value

}

C#

using System;

using System.Security.Cryptography;

using System.Collections.Specialized;

class PaymentRequest {

string Amount,

string Currency,

string FailureUrl,

string MerchantOrderId,

string ClientKey,

string SuccessUrl,

}

namespace Signature {

public class Signature {

private bool GenerateSignature(PaymentRequest paymentRequest, string secret) {

NameValueCollection myCollection = System.Web.HttpUtility.ParseQueryString(string.Empty);

myCollection.Add("amount", paymentResponse.Amount);

myCollection.Add("currency", paymentResponse.Currency);

myCollection.Add("failure_url", paymentResponse.FailureUrl);

myCollection.Add("merchant_order_id", paymentResponse.MerchantOrderId);

myCollection.Add("client_key", paymentResponse.ClientKey);

myCollection.Add("success_url", paymentResponse.SuccessUrl);

string message = myCollection.ToString();

var encoding = new System.Text.ASCIIEncoding();

byte[] keyByte = encoding.GetBytes(secret);

byte[] messageBytes = encoding.GetBytes(message);

var hmacsha256 = new HMACSHA256(keyByte);

byte[] hashmessage = hmacsha256.ComputeHash(messageBytes);

string hash_value = Convert.ToBase64String(hashmessage);

return hash_value

}

}

}

Java

import javax.crypto.Mac;

import javax.crypto.spec.SecretKeySpec;

import org.apache.commons.codec.binary.Base64;

class PaymentRequest {

string Amount,

string Currency,

string FailureUrl,

string MerchantOrderId,

string ClientKey,

string SuccessUrl,

}

public class ApiSecurityExample {

public static String GenerateSignature(PaymentRequest paymentRequest, String secret) {

StringBuilder stringBuilder = new StringBuilder();

Map < String, String > map;

map["amount"] = paymentRequest.Amount;

map["currency"] = paymentRequest.Currency;

map["failure_url"] = paymentRequest.FailureUrl;

map["merchant_order_id"] = paymentRequest.MerchantOrderId;

map["client_key"] = paymentRequest.ClientKey;

map["success_url"] = paymentRequest.SuccessUrl;

for (String key: map.keySet()) {

if (stringBuilder.length() > 0) {

stringBuilder.append("&");

}

String value = map.get(key);

try {

stringBuilder.append((key != null ? URLEncoder.encode(key, "UTF-8") : ""));

stringBuilder.append("=");

stringBuilder.append(value != null ? URLEncoder.encode(value, "UTF-8") : "");

} catch (UnsupportedEncodingException e) {

throw new RuntimeException("This method requires UTF-8 encoding support", e);

}

}

String message = stringBuilder.toString();

Mac sha256_HMAC = Mac.getInstance("HmacSHA256");

SecretKeySpec secret_key = new SecretKeySpec(secret.getBytes(), "HmacSHA256");

sha256_HMAC.init(secret_key);

String hash_value = Base64.encodeBase64String(sha256_HMAC.doFinal(message.getBytes()));

return hash_value;

}

}

Python

#!/usr/bin/python

# -*- coding: utf-8 -*-

import urllib

import hashlib

import hmac

import base64

class requestObj:

def __init__(self, Amount, Currency, FailureUrl, MerchantOrderId, ClientKey, SuccessUrl):

# Instance Variable

self.Amount = Amount

self.Currency = Currency

self.FailureUrl = FailureUrl

self.MerchantOrderId = MerchantOrderId

self.ClientKey = ClientKey

self.SuccessUrl = SuccessUrl

def GenerateSignature(requestObj, secretKey):

f = {

'amount': requestObj.Amount,

'currency': requestObj.Currency,

'failure_url': requestObj.FailureUrl,

'merchant_order_id': requestObj.MerchantOrderId,

'client_key': requestObj.ClientKey,

'success_url': requestObj.SuccessUrl,

}

message1 = urllib.urlencode(f)

message = bytes(message1).encode('utf-8')

secret = bytes(secretKey).encode('utf-8')

signature = base64.b64encode(hmac.new(secret, message, digestmod=hashlib.sha256).digest())

return signature