TOKENIZATION API
_{MobiToken by MobiCard}

#!/bin/bash

# Configuration
MOBICARD_VERSION="2.0"
MOBICARD_MODE="LIVE"
MOBICARD_MERCHANT_ID="4"
MOBICARD_API_KEY="YmJkOGY0OTZhMTU2ZjVjYTIyYzFhZGQyOWRiMmZjMmE2ZWU3NGIxZWM3ZTBiZSJ9"
MOBICARD_SECRET_KEY="NjIwYzEyMDRjNjNjMTdkZTZkMjZhOWNiYjIxNzI2NDQwYzVmNWNiMzRhMzBjYSJ9"
MOBICARD_TOKEN_ID=$(shuf -i 1000000-1000000000 -n 1)
MOBICARD_TXN_REFERENCE=$(shuf -i 1000000-1000000000 -n 1)
MOBICARD_SERVICE_ID="20000"
MOBICARD_SERVICE_TYPE="TOKENIZATION"
MOBICARD_SINGLE_USE_TOKEN_FLAG="0"
MOBICARD_CARD_NUMBER="4242424242424242"
MOBICARD_CARD_EXPIRY_MONTH="02"
MOBICARD_CARD_EXPIRY_YEAR="28"
MOBICARD_CUSTOM_ONE="mobicard_custom_one"
MOBICARD_CUSTOM_TWO="mobicard_custom_two"
MOBICARD_CUSTOM_THREE="mobicard_custom_three"
MOBICARD_EXTRA_DATA="your_custom_data_here_will_be_returned_as_is"

# Create JWT Header
JWT_HEADER=$(echo -n '{"typ":"JWT","alg":"HS256"}' | base64 | tr '+/' '-_' | tr -d '=')

# Create JWT Payload
PAYLOAD_JSON=$(cat << EOF
{
  "mobicard_version": "$MOBICARD_VERSION",
  "mobicard_mode": "$MOBICARD_MODE",
  "mobicard_merchant_id": "$MOBICARD_MERCHANT_ID",
  "mobicard_api_key": "$MOBICARD_API_KEY",
  "mobicard_service_id": "$MOBICARD_SERVICE_ID",
  "mobicard_service_type": "$MOBICARD_SERVICE_TYPE",
  "mobicard_token_id": "$MOBICARD_TOKEN_ID",
  "mobicard_txn_reference": "$MOBICARD_TXN_REFERENCE",
  "mobicard_single_use_token_flag": "$MOBICARD_SINGLE_USE_TOKEN_FLAG",
  "mobicard_card_number": "$MOBICARD_CARD_NUMBER",
  "mobicard_card_expiry_month": "$MOBICARD_CARD_EXPIRY_MONTH",
  "mobicard_card_expiry_year": "$MOBICARD_CARD_EXPIRY_YEAR",
  "mobicard_custom_one": "$MOBICARD_CUSTOM_ONE",
  "mobicard_custom_two": "$MOBICARD_CUSTOM_TWO",
  "mobicard_custom_three": "$MOBICARD_CUSTOM_THREE",
  "mobicard_extra_data": "$MOBICARD_EXTRA_DATA"
}
EOF
)

JWT_PAYLOAD=$(echo -n "$PAYLOAD_JSON" | base64 | tr '+/' '-_' | tr -d '=')

# Generate Signature
HEADER_PAYLOAD="$JWT_HEADER.$JWT_PAYLOAD"
JWT_SIGNATURE=$(echo -n "$HEADER_PAYLOAD" | openssl dgst -sha256 -hmac "$MOBICARD_SECRET_KEY" -binary | base64 | tr '+/' '-_' | tr -d '=')

# Create Final JWT
MOBICARD_AUTH_JWT="$JWT_HEADER.$JWT_PAYLOAD.$JWT_SIGNATURE"

# Make API Call
API_URL="https://mobicardsystems.com/api/v1/card_tokenization"

RESPONSE=$(curl -X POST "$API_URL" \
  -H "Content-Type: application/json" \
  -d "{\"mobicard_auth_jwt\":\"$MOBICARD_AUTH_JWT\"}" \
  --silent)

echo "$RESPONSE" | python -m json.tool

import json
import base64
import hmac
import hashlib
import random
import requests

class MobicardTokenization:
    def __init__(self, merchant_id, api_key, secret_key):
        self.mobicard_version = "2.0"
        self.mobicard_mode = "LIVE"
        self.mobicard_merchant_id = merchant_id
        self.mobicard_api_key = api_key
        self.mobicard_secret_key = secret_key
        self.mobicard_service_id = "20000"
        self.mobicard_service_type = "TOKENIZATION"
        
        self.mobicard_token_id = str(random.randint(1000000, 1000000000))
        self.mobicard_txn_reference = str(random.randint(1000000, 1000000000))
    
    def tokenize_card(self, card_number, expiry_month, expiry_year, 
                     single_use_token=False, custom_data=None):
        """Tokenize card details"""
        
        mobicard_single_use_token_flag = "1" if single_use_token else "0"
        
        # Default custom data
        if custom_data is None:
            custom_data = {
                "mobicard_custom_one": "mobicard_custom_one",
                "mobicard_custom_two": "mobicard_custom_two",
                "mobicard_custom_three": "mobicard_custom_three",
                "mobicard_extra_data": "your_custom_data_here_will_be_returned_as_is"
            }
        
        # Create JWT Header
        jwt_header = {"typ": "JWT", "alg": "HS256"}
        encoded_header = base64.urlsafe_b64encode(
            json.dumps(jwt_header).encode()
        ).decode().rstrip('=')
        
        # Create JWT Payload
        jwt_payload = {
            "mobicard_version": self.mobicard_version,
            "mobicard_mode": self.mobicard_mode,
            "mobicard_merchant_id": self.mobicard_merchant_id,
            "mobicard_api_key": self.mobicard_api_key,
            "mobicard_service_id": self.mobicard_service_id,
            "mobicard_service_type": self.mobicard_service_type,
            "mobicard_token_id": self.mobicard_token_id,
            "mobicard_txn_reference": self.mobicard_txn_reference,
            "mobicard_single_use_token_flag": mobicard_single_use_token_flag,
            "mobicard_card_number": card_number,
            "mobicard_card_expiry_month": expiry_month,
            "mobicard_card_expiry_year": expiry_year,
            "mobicard_custom_one": custom_data.get("mobicard_custom_one", ""),
            "mobicard_custom_two": custom_data.get("mobicard_custom_two", ""),
            "mobicard_custom_three": custom_data.get("mobicard_custom_three", ""),
            "mobicard_extra_data": custom_data.get("mobicard_extra_data", "")
        }
        
        encoded_payload = base64.urlsafe_b64encode(
            json.dumps(jwt_payload).encode()
        ).decode().rstrip('=')
        
        # Generate Signature
        header_payload = f"{encoded_header}.{encoded_payload}"
        signature = hmac.new(
            self.mobicard_secret_key.encode(),
            header_payload.encode(),
            hashlib.sha256
        ).digest()
        encoded_signature = base64.urlsafe_b64encode(signature).decode().rstrip('=')
        
        jwt_token = f"{encoded_header}.{encoded_payload}.{encoded_signature}"
        
        # Make API Call
        url = "https://mobicardsystems.com/api/v1/card_tokenization"
        payload = {"mobicard_auth_jwt": jwt_token}
        
        try:
            response = requests.post(url, json=payload, verify=False, timeout=30)
            response_data = response.json()
            
            if response_data.get('status') == 'SUCCESS':
                return {
                    'status': 'SUCCESS',
                    'card_token': response_data['card_information']['card_token'],
                    'card_number_masked': response_data['card_information']['card_number_masked'],
                    'raw_response': response_data
                }
            else:
                return {
                    'status': 'ERROR',
                    'status_code': response_data.get('status_code'),
                    'status_message': response_data.get('status_message')
                }
                
        except Exception as e:
            return {'status': 'ERROR', 'error_message': str(e)}

# Usage
tokenizer = MobicardTokenization(
    merchant_id="4",
    api_key="YmJkOGY0OTZhMTU2ZjVjYTIyYzFhZGQyOWRiMmZjMmE2ZWU3NGIxZWM3ZTBiZSJ9",
    secret_key="NjIwYzEyMDRjNjNjMTdkZTZkMjZhOWNiYjIxNzI2NDQwYzVmNWNiMzRhMzBjYSJ9"
)

result = tokenizer.tokenize_card(
    card_number="4242424242424242",
    expiry_month="02",
    expiry_year="28",
    single_use_token=False
)

if result['status'] == 'SUCCESS':
    print(f"Token: {result['card_token']}")
    print(f"Masked Card: {result['card_number_masked']}")
    print("Store token and masked card in your database.")
else:
    print(f"Error: {result.get('status_message')}")

const crypto = require('crypto');
const axios = require('axios');

class MobicardTokenization {
    constructor(merchantId, apiKey, secretKey) {
        this.mobicardVersion = "2.0";
        this.mobicardMode = "LIVE";
        this.mobicardMerchantId = merchantId;
        this.mobicardApiKey = apiKey;
        this.mobicardSecretKey = secretKey;
        this.mobicardServiceId = "20000";
        this.mobicardServiceType = "TOKENIZATION";
        
        this.mobicardTokenId = Math.floor(Math.random() * (1000000000 - 1000000 + 1)) + 1000000;
        this.mobicardTxnReference = Math.floor(Math.random() * (1000000000 - 1000000 + 1)) + 1000000;
    }

    generateJWT(cardData) {
        const jwtHeader = { typ: "JWT", alg: "HS256" };
        const encodedHeader = Buffer.from(JSON.stringify(jwtHeader)).toString('base64url');

        const jwtPayload = {
            mobicard_version: this.mobicardVersion,
            mobicard_mode: this.mobicardMode,
            mobicard_merchant_id: this.mobicardMerchantId,
            mobicard_api_key: this.mobicardApiKey,
            mobicard_service_id: this.mobicardServiceId,
            mobicard_service_type: this.mobicardServiceType,
            mobicard_token_id: this.mobicardTokenId.toString(),
            mobicard_txn_reference: this.mobicardTxnReference.toString(),
            mobicard_single_use_token_flag: cardData.singleUseToken ? "1" : "0",
            mobicard_card_number: cardData.cardNumber,
            mobicard_card_expiry_month: cardData.expiryMonth,
            mobicard_card_expiry_year: cardData.expiryYear,
            mobicard_custom_one: cardData.customOne || "mobicard_custom_one",
            mobicard_custom_two: cardData.customTwo || "mobicard_custom_two",
            mobicard_custom_three: cardData.customThree || "mobicard_custom_three",
            mobicard_extra_data: cardData.extraData || "your_custom_data_here_will_be_returned_as_is"
        };

        const encodedPayload = Buffer.from(JSON.stringify(jwtPayload)).toString('base64url');

        const headerPayload = `${encodedHeader}.${encodedPayload}`;
        const signature = crypto.createHmac('sha256', this.mobicardSecretKey)
            .update(headerPayload)
            .digest('base64url');

        return `${encodedHeader}.${encodedPayload}.${signature}`;
    }

    async tokenizeCard(cardData) {
        try {
            const jwtToken = this.generateJWT(cardData);
            
            const url = "https://mobicardsystems.com/api/v1/card_tokenization";
            const payload = { mobicard_auth_jwt: jwtToken };

            const response = await axios.post(url, payload, {
                httpsAgent: new (require('https').Agent)({ rejectUnauthorized: false })
            });

            const responseData = response.data;

            if (responseData.status === 'SUCCESS') {
                return {
                    status: 'SUCCESS',
                    cardToken: responseData.card_information.card_token,
                    cardNumberMasked: responseData.card_information.card_number_masked,
                    rawResponse: responseData
                };
            } else {
                return {
                    status: 'ERROR',
                    statusCode: responseData.status_code,
                    statusMessage: responseData.status_message
                };
            }
        } catch (error) {
            return {
                status: 'ERROR',
                errorMessage: error.message
            };
        }
    }
}

// Usage
async function main() {
    const tokenizer = new MobicardTokenization(
        "4",
        "YmJkOGY0OTZhMTU2ZjVjYTIyYzFhZGQyOWRiMmZjMmE2ZWU3NGIxZWM3ZTBiZSJ9",
        "NjIwYzEyMDRjNjNjMTdkZTZkMjZhOWNiYjIxNzI2NDQwYzVmNWNiMzRhMzBjYSJ9"
    );

    const result = await tokenizer.tokenizeCard({
        cardNumber: "4242424242424242",
        expiryMonth: "02",
        expiryYear: "28",
        singleUseToken: false
    });

    if (result.status === 'SUCCESS') {
        console.log("Tokenization Successful!");
        console.log(`Card Token: ${result.cardToken}`);
        console.log(`Masked Card: ${result.cardNumberMasked}`);
    } else {
        console.log(`Error: ${result.statusMessage}`);
    }
}

main();

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.Base64;
import java.util.Random;
import java.util.HashMap;
import java.util.Map;

import com.google.gson.Gson;
import com.google.gson.JsonObject;

public class MobicardTokenization {
    
    private final String mobicardVersion = "2.0";
    private final String mobicardMode = "LIVE";
    private final String mobicardMerchantId;
    private final String mobicardApiKey;
    private final String mobicardSecretKey;
    private final String mobicardServiceId = "20000";
    private final String mobicardServiceType = "TOKENIZATION";
    
    private final String mobicardTokenId;
    private final String mobicardTxnReference;
    
    private final Gson gson = new Gson();
    
    public MobicardTokenization(String merchantId, String apiKey, String secretKey) {
        this.mobicardMerchantId = merchantId;
        this.mobicardApiKey = apiKey;
        this.mobicardSecretKey = secretKey;
        
        Random random = new Random();
        this.mobicardTokenId = String.valueOf(random.nextInt(900000000) + 1000000);
        this.mobicardTxnReference = String.valueOf(random.nextInt(900000000) + 1000000);
    }
    
    public String generateJWT(String cardNumber, String expiryMonth, String expiryYear, 
                             boolean singleUseToken, Map customData) throws Exception {
        
        Map jwtHeader = new HashMap<>();
        jwtHeader.put("typ", "JWT");
        jwtHeader.put("alg", "HS256");
        String encodedHeader = base64UrlEncode(gson.toJson(jwtHeader));
        
        Map jwtPayload = new HashMap<>();
        jwtPayload.put("mobicard_version", mobicardVersion);
        jwtPayload.put("mobicard_mode", mobicardMode);
        jwtPayload.put("mobicard_merchant_id", mobicardMerchantId);
        jwtPayload.put("mobicard_api_key", mobicardApiKey);
        jwtPayload.put("mobicard_service_id", mobicardServiceId);
        jwtPayload.put("mobicard_service_type", mobicardServiceType);
        jwtPayload.put("mobicard_token_id", mobicardTokenId);
        jwtPayload.put("mobicard_txn_reference", mobicardTxnReference);
        jwtPayload.put("mobicard_single_use_token_flag", singleUseToken ? "1" : "0");
        jwtPayload.put("mobicard_card_number", cardNumber);
        jwtPayload.put("mobicard_card_expiry_month", expiryMonth);
        jwtPayload.put("mobicard_card_expiry_year", expiryYear);
        jwtPayload.put("mobicard_custom_one", customData.getOrDefault("customOne", "mobicard_custom_one"));
        jwtPayload.put("mobicard_custom_two", customData.getOrDefault("customTwo", "mobicard_custom_two"));
        jwtPayload.put("mobicard_custom_three", customData.getOrDefault("customThree", "mobicard_custom_three"));
        jwtPayload.put("mobicard_extra_data", customData.getOrDefault("extraData", "your_custom_data_here_will_be_returned_as_is"));
        
        String encodedPayload = base64UrlEncode(gson.toJson(jwtPayload));
        
        String headerPayload = encodedHeader + "." + encodedPayload;
        String signature = generateHMAC(headerPayload, mobicardSecretKey);
        
        return encodedHeader + "." + encodedPayload + "." + signature;
    }
    
    public JsonObject tokenizeCard(String cardNumber, String expiryMonth, String expiryYear, 
                                  boolean singleUseToken) throws Exception {
        
        Map customData = new HashMap<>();
        customData.put("customOne", "mobicard_custom_one");
        customData.put("customTwo", "mobicard_custom_two");
        customData.put("customThree", "mobicard_custom_three");
        customData.put("extraData", "your_custom_data_here_will_be_returned_as_is");
        
        String jwtToken = generateJWT(cardNumber, expiryMonth, expiryYear, singleUseToken, customData);
        
        HttpClient client = HttpClient.newHttpClient();
        
        Map requestBody = new HashMap<>();
        requestBody.put("mobicard_auth_jwt", jwtToken);
        
        String jsonBody = gson.toJson(requestBody);
        
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://mobicardsystems.com/api/v1/card_tokenization"))
                .header("Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(jsonBody))
                .build();
        
        HttpResponse response = client.send(request, HttpResponse.BodyHandlers.ofString());
        
        return gson.fromJson(response.body(), JsonObject.class);
    }
    
    private String base64UrlEncode(String data) {
        return Base64.getUrlEncoder().withoutPadding().encodeToString(data.getBytes());
    }
    
    private String generateHMAC(String data, String key) throws Exception {
        Mac sha256Hmac = Mac.getInstance("HmacSHA256");
        SecretKeySpec secretKey = new SecretKeySpec(key.getBytes(), "HmacSHA256");
        sha256Hmac.init(secretKey);
        byte[] hmacBytes = sha256Hmac.doFinal(data.getBytes());
        return base64UrlEncode(new String(hmacBytes));
    }
    
    public static void main(String[] args) {
        try {
            MobicardTokenization tokenizer = new MobicardTokenization(
                "4",
                "YmJkOGY0OTZhMTU2ZjVjYTIyYzFhZGQyOWRiMmZjMmE2ZWU3NGIxZWM3ZTBiZSJ9",
                "NjIwYzEyMDRjNjNjMTdkZTZkMjZhOWNiYjIxNzI2NDQwYzVmNWNiMzRhMzBjYSJ9"
            );
            
            JsonObject result = tokenizer.tokenizeCard(
                "4242424242424242",
                "02",
                "28",
                false
            );
            
            if (result.has("status")) {
                String status = result.get("status").getAsString();
                
                if ("SUCCESS".equals(status)) {
                    System.out.println("Tokenization Successful!");
                    
                    if (result.has("card_information")) {
                        JsonObject cardInfo = result.getAsJsonObject("card_information");
                        
                        System.out.println("Card Token: " + 
                            cardInfo.get("card_token").getAsString());
                        System.out.println("Masked Card: " + 
                            cardInfo.get("card_number_masked").getAsString());
                        System.out.println("\nStore these values in your database.");
                    }
                } else {
                    System.out.println("Tokenization Failed!");
                    if (result.has("status_message")) {
                        System.out.println("Error: " + result.get("status_message").getAsString());
                    }
                }
            }
            
        } catch (Exception e) {
            System.err.println("Error: " + e.getMessage());
            e.printStackTrace();
        }
    }
}