Masterpass Integration

using System;
using System.Net.Http;
using System.Security.Cryptography;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;
using System.Collections.Generic;

public class MasterpassPayment
{
    private readonly string apiSecretKey;
    private readonly string merchantSecretKey;
    private readonly string mpCode;
    private readonly string baseURL;

    public MasterpassPayment(string apiSecretKey, string merchantSecretKey, string mpCode, string baseURL)
    {
        this.apiSecretKey = apiSecretKey;
        this.merchantSecretKey = merchantSecretKey;
        this.mpCode = mpCode;
        this.baseURL = baseURL;
    }

    private string CalculateApiKey()
    {
        string hashString = $"{apiSecretKey}|{merchantSecretKey}";
        using (var sha512 = SHA512.Create())
        {
            byte[] bytes = sha512.ComputeHash(Encoding.UTF8.GetBytes(hashString));
            return Convert.ToBase64String(bytes);
        }
    }

    public async Task<JsonDocument> CreateMasterpassPayment(PaymentData paymentData)
    {
        string apiKey = CalculateApiKey();

        var data = new
        {
            apiKey,
            apiSecretKey,
            gsm = paymentData.Gsm,
            trxCurrency = "TRY",
            trxAmount = paymentData.Amount,
            trxCode = paymentData.OrderId,
            trxType = "SALES",
            callbackUrl = paymentData.CallbackUrl,
            sellerList = paymentData.Sellers,
            shippingCost = paymentData.ShippingCost,
            otherAmount = paymentData.OtherAmount,
            marketplaceCode = mpCode
        };

        using var client = new HttpClient();
        var jsonContent = new StringContent(
            JsonSerializer.Serialize(data),
            Encoding.UTF8,
            "application/json"
        );

        var response = await client.PostAsync($"{baseURL}/payment/create/MASTERPASS", jsonContent);
        var jsonString = await response.Content.ReadAsStringAsync();
        return JsonDocument.Parse(jsonString);
    }
}

public class PaymentData
{
    public string Gsm { get; set; }
    public decimal Amount { get; set; }
    public string OrderId { get; set; }
    public string CallbackUrl { get; set; }
    public List<Seller> Sellers { get; set; }
    public decimal ShippingCost { get; set; }
    public decimal OtherAmount { get; set; }
}

public class Seller
{
    public string sellerExternalId { get; set; }
    public decimal trxAmount { get; set; }
    public decimal withholdingTax { get; set; }
}

// Usage
var masterpass = new MasterpassPayment(
    Environment.GetEnvironmentVariable("API_SECRET_KEY"),
    Environment.GetEnvironmentVariable("MERCHANT_SECRET_KEY"),
    "MP12345",
    "https://apitest.paynkolay.com.tr/marketplace/v1"
);

// Create payment
var payment = await masterpass.CreateMasterpassPayment(new PaymentData
{
    Gsm = "5321234567",
    Amount = 250.00m,
    OrderId = "ORDER_789",
    CallbackUrl = "https://yoursite.com/payment-callback",
    Sellers = new List<Seller>
    {
        new Seller
        {
            sellerExternalId = "SELLER_001",
            trxAmount = 250.00m,
            withholdingTax = 2.00m
        }
    },
    ShippingCost = 0,
    OtherAmount = 0
});

// Decode and display form
if (payment.RootElement.GetProperty("success").GetBoolean() &&
    payment.RootElement.GetProperty("data").TryGetProperty("form", out var formElement))
{
    byte[] formBytes = Convert.FromBase64String(formElement.GetString());
    string htmlForm = Encoding.UTF8.GetString(formBytes);
    // Display HTML to user
}

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

class MasterpassPayment {
  constructor(apiSecretKey, merchantSecretKey, mpCode, baseURL) {
    this.apiSecretKey = apiSecretKey;
    this.merchantSecretKey = merchantSecretKey;
    this.mpCode = mpCode;
    this.baseURL = baseURL;
  }

  calculateApiKey() {
    const hashString = this.apiSecretKey + '|' + this.merchantSecretKey;
    const hash = crypto.createHash('sha512').update(hashString, 'utf8').digest();
    return hash.toString('base64');
  }

  async createMasterpassPayment(paymentData) {
    const apiKey = this.calculateApiKey();

    const response = await axios.post(
      `${this.baseURL}/payment/create/MASTERPASS`,
      {
        apiKey,
        apiSecretKey: this.apiSecretKey,
        gsm: paymentData.gsm,
        trxCurrency: 'TRY',
        trxAmount: paymentData.amount,
        trxCode: paymentData.orderId,
        trxType: 'SALES',
        callbackUrl: paymentData.callbackUrl,
        sellerList: paymentData.sellers,
        shippingCost: paymentData.shippingCost || 0,
        otherAmount: paymentData.otherAmount || 0,
        marketplaceCode: this.mpCode
      }
    );

    return response.data;
  }
}

// Usage
const masterpass = new MasterpassPayment(
  process.env.API_SECRET_KEY,
  process.env.MERCHANT_SECRET_KEY,
  'MP12345',
  'https://apitest.paynkolay.com.tr/marketplace/v1'
);

// Create payment
const payment = await masterpass.createMasterpassPayment({
  gsm: '5321234567',
  amount: 250.00,
  orderId: 'ORDER_789',
  callbackUrl: 'https://yoursite.com/payment-callback',
  sellers: [
    {
      sellerExternalId: 'SELLER_001',
      trxAmount: 250.00,
      withholdingTax: 2.00
    }
  ],
  shippingCost: 0,
  otherAmount: 0
});

// Decode and display form
if (payment.success && payment.data.form) {
  const htmlForm = Buffer.from(payment.data.form, 'base64').toString('utf-8');
  // Display HTML to user
}

import requests
import hashlib
import base64
import os
import json

class MasterpassPayment:
    def __init__(self, api_secret_key, merchant_secret_key, mp_code, base_url):
        self.api_secret_key = api_secret_key
        self.merchant_secret_key = merchant_secret_key
        self.mp_code = mp_code
        self.base_url = base_url

    def calculate_api_key(self):
        hash_string = f"{self.api_secret_key}|{self.merchant_secret_key}"
        hash_bytes = hashlib.sha512(hash_string.encode('utf-8')).digest()
        return base64.b64encode(hash_bytes).decode('utf-8')

    def create_masterpass_payment(self, payment_data):
        api_key = self.calculate_api_key()

        data = {
            'apiKey': api_key,
            'apiSecretKey': self.api_secret_key,
            'gsm': payment_data['gsm'],
            'trxCurrency': 'TRY',
            'trxAmount': payment_data['amount'],
            'trxCode': payment_data['orderId'],
            'trxType': 'SALES',
            'callbackUrl': payment_data['callbackUrl'],
            'sellerList': payment_data['sellers'],
            'shippingCost': payment_data.get('shippingCost', 0),
            'otherAmount': payment_data.get('otherAmount', 0),
            'marketplaceCode': self.mp_code
        }

        response = requests.post(
            f"{self.base_url}/payment/create/MASTERPASS",
            json=data
        )

        return response.json()

# Usage
masterpass = MasterpassPayment(
    os.getenv('API_SECRET_KEY'),
    os.getenv('MERCHANT_SECRET_KEY'),
    'MP12345',
    'https://apitest.paynkolay.com.tr/marketplace/v1'
)

# Create payment
payment = masterpass.create_masterpass_payment({
    'gsm': '5321234567',
    'amount': 250.00,
    'orderId': 'ORDER_789',
    'callbackUrl': 'https://yoursite.com/payment-callback',
    'sellers': [
        {
            'sellerExternalId': 'SELLER_001',
            'trxAmount': 250.00,
            'withholdingTax': 2.00
        }
    ],
    'shippingCost': 0,
    'otherAmount': 0
})

# Decode and display form
if payment.get('success') and payment.get('data', {}).get('form'):
    html_form = base64.b64decode(payment['data']['form']).decode('utf-8')
    # Display HTML to user