Taksit Bilgisi Paynkolay'a Ait

// === V0 3D FLOW: PaymentInstallments → Payment (.NET 8 minimal API) ===
// Taksit Bilgisi Paynkolay'a Ait — önce taksit sorgulanır, dönen EncodedValue ile ödeme başlatılır.
// Kurulum: dotnet new web -n PaynkolayV0ThreeD → bu dosyayı Program.cs ile değiştirin → dotnet run
// Test: tarayıcıda http://localhost:<port>/odeme (port konsolda yazar)
// Not: Canlı uç localhost'tan gelen istekleri reddeder; canlıda sunucunuzdan çalıştırın.
using System.Globalization;
using System.Net;
using System.Security.Cryptography;
using System.Text;
using System.Text.Json;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddHttpClient();
var app = builder.Build();

// Kimlik bilgileri (size verilen değerler)
const string Sx = "SX_DEGERINIZ";
const string MerchantSecretKey = "SECRET_KEY_DEGERINIZ";

// Test uçları — canlıda alan adı paynkolay.nkolayislem.com.tr olur
const string InstallmentsUrl = "https://paynkolaytest.nkolayislem.com.tr/Vpos/Payment/PaymentInstallments";
const string PaymentUrl = "https://paynkolaytest.nkolayislem.com.tr/Vpos/Payment/Payment";

app.MapGet("/odeme", async (HttpContext ctx, IHttpClientFactory httpFactory) =>
{
    var clientRefCode = "789456|AB76";                      // her işlemde benzersiz olmalı (ör. "ORDER-" + Guid)
    var amount = "6.00";
    var successUrl = "https://siteniz.com/payment/callback"; // 3D sonucu buraya döner
    var failUrl = "https://siteniz.com/payment/callback";
    var hostUrl = "https://siteniz.com";
    var customerKey = "";                                   // kart saklanmıyorsa boş
    var cardNumber = "4546711234567894";

    // rnd: Türkiye saatiyle (UTC+3) dd-MM-yyyy HH:mm:ss
    var rnd = DateTime.UtcNow.AddHours(3).ToString("dd-MM-yyyy HH:mm:ss", CultureInfo.InvariantCulture);

    // Hash: sx|clientRefCode|amount|successUrl|failUrl|rnd|customerKey|secretKey → SHA512 (ham bayt) → Base64
    var hashStr = string.Join("|", Sx, clientRefCode, amount, successUrl, failUrl, rnd, customerKey, MerchantSecretKey);
    var hashDatav2 = Convert.ToBase64String(SHA512.HashData(Encoding.UTF8.GetBytes(hashStr)));

    var http = httpFactory.CreateClient();
    http.Timeout = TimeSpan.FromSeconds(30);

    try
    {
        // --- ADIM 1: Taksit sorgulama ---
        var instBody = await PostFormAsync(http, InstallmentsUrl, new()
        {
            ["sx"] = Sx,
            ["amount"] = amount,
            ["cardNumber"] = cardNumber,
            ["hosturl"] = hostUrl,
            ["iscardvalid"] = "false",   // sadece BIN (ilk 8 hane) ile sorgu
        });

        // PAYMENT_BANK_LIST boşsa Adım 2'ye geçilmez
        var option = FirstInstallmentOption(instBody); // gerçek entegrasyonda kullanıcının seçtiği opsiyon
        if (option is null)
        {
            return PlainText($"Taksit bilgisi alınamadı: {instBody}", 400);
        }
        var (encodedValue, installmentNo) = option.Value;

        // --- ADIM 2: 3D ödeme ---
        var payBody = await PostFormAsync(http, PaymentUrl, new()
        {
            ["EncodedValue"] = encodedValue,   // ← V0'a özgü, Adım 1'den gelir
            ["installmentNo"] = installmentNo,
            ["amount"] = amount,
            ["sx"] = Sx,
            ["clientRefCode"] = clientRefCode,
            ["successUrl"] = successUrl,
            ["failUrl"] = failUrl,
            ["cardHolderName"] = "Tuna Çınar",
            ["month"] = "12",
            ["year"] = "2026",
            ["cvv"] = "001",
            ["cardNumber"] = cardNumber,
            ["use3D"] = "true",                // ← 3D akışı
            ["transactionType"] = "SALES",
            ["hosturl"] = hostUrl,
            ["cardHolderIP"] = GetClientIp(ctx),
            ["rnd"] = rnd,
            ["hashDatav2"] = hashDatav2,
            ["environment"] = "API",
        });

        // === 3D'ye özgü: BANK_REQUEST_MESSAGE'ı tarayıcıya bas (banka ACS'ye auto-submit olur) ===
        var bankForm = ReadString(payBody, "BANK_REQUEST_MESSAGE");
        if (!string.IsNullOrEmpty(bankForm))
        {
            return Results.Content(bankForm, "text/html; charset=utf-8");
        }

        // Sonuç successUrl/failUrl callback'inde — hash doğrulaması orada zorunlu
        return PlainText($"3D formu alınamadı: {payBody}", 400);
    }
    catch (Exception ex) when (ex is HttpRequestException or TaskCanceledException)
    {
        return PlainText($"Bağlantı hatası: {ex.Message}", 502);
    }
});

app.Run();

static IResult PlainText(string message, int statusCode) =>
    Results.Text(message, "text/plain; charset=utf-8", statusCode: statusCode);

// form-data POST (multipart/form-data)
static async Task<string> PostFormAsync(HttpClient http, string url, Dictionary<string, string> fields)
{
    using var form = new MultipartFormDataContent();
    foreach (var (key, value) in fields)
    {
        form.Add(new StringContent(value), key);
    }
    using var response = await http.PostAsync(url, form);
    return await response.Content.ReadAsStringAsync();
}

// PAYMENT_BANK_LIST[0] → (EncodedValue, INSTALLMENT); liste boşsa null
static (string EncodedValue, string Installment)? FirstInstallmentOption(string body)
{
    try
    {
        using var json = JsonDocument.Parse(body);
        var root = json.RootElement;
        if (root.ValueKind != JsonValueKind.Object
            || !root.TryGetProperty("PAYMENT_BANK_LIST", out var list)
            || list.ValueKind != JsonValueKind.Array
            || list.GetArrayLength() == 0)
        {
            return null;
        }

        var first = list[0];
        if (first.ValueKind != JsonValueKind.Object || !first.TryGetProperty("EncodedValue", out var encoded))
        {
            return null;
        }

        var encodedValue = encoded.ToString();
        if (string.IsNullOrEmpty(encodedValue))
        {
            return null;
        }

        var installment = first.TryGetProperty("INSTALLMENT", out var inst) ? inst.ToString() : "1";
        return (encodedValue, installment);
    }
    catch (JsonException)
    {
        return null;
    }
}

// JSON yanıttan tek bir alanı metin olarak okur; yoksa null
static string? ReadString(string body, string property)
{
    try
    {
        using var json = JsonDocument.Parse(body);
        return json.RootElement.ValueKind == JsonValueKind.Object
            && json.RootElement.TryGetProperty(property, out var value)
            ? value.ToString()
            : null;
    }
    catch (JsonException)
    {
        return null;
    }
}

// Müşteri IP'si: önce proxy başlıkları, yoksa bağlantı adresi
static string GetClientIp(HttpContext ctx)
{
    foreach (var header in new[] { "CF-Connecting-IP", "X-Forwarded-For", "X-Real-IP" })
    {
        var value = ctx.Request.Headers[header].ToString();
        if (string.IsNullOrWhiteSpace(value)) continue;

        var ip = value.Split(',')[0].Trim();
        if (IPAddress.TryParse(ip, out _)) return ip;
    }

    var remote = ctx.Connection.RemoteIpAddress;
    if (remote is null) return "127.0.0.1";
    return (remote.IsIPv4MappedToIPv6 ? remote.MapToIPv4() : remote).ToString();
}

# === V0 3D FLOW: PaymentInstallments → Payment (Python + requests) ===
# Taksit Bilgisi Paynkolay'a Ait — önce taksit sorgulanır, dönen EncodedValue ile ödeme başlatılır.
# Kurulum: pip install requests
# Çalıştırma: python3 example.py  →  http://localhost:8000/odeme
# Not: Canlı uç localhost'tan gelen istekleri reddeder; canlıda sunucunuzdan çalıştırın.
import base64
import hashlib
import ipaddress
import json
from datetime import datetime, timedelta, timezone
from http.server import BaseHTTPRequestHandler, HTTPServer

import requests

# Kimlik bilgileri (size verilen değerler)
SX = "SX_DEGERINIZ"
MERCHANT_SECRET_KEY = "SECRET_KEY_DEGERINIZ"

# Test uçları — canlıda alan adı paynkolay.nkolayislem.com.tr olur
INSTALLMENTS_URL = "https://paynkolaytest.nkolayislem.com.tr/Vpos/Payment/PaymentInstallments"
PAYMENT_URL = "https://paynkolaytest.nkolayislem.com.tr/Vpos/Payment/Payment"


def client_ip(handler):
    """Müşteri IP'si: önce proxy başlıkları, yoksa bağlantı adresi."""
    for header in ("CF-Connecting-IP", "X-Forwarded-For", "X-Real-IP"):
        value = handler.headers.get(header)
        if value:
            ip = value.split(",")[0].strip()
            try:
                ipaddress.ip_address(ip)
                return ip
            except ValueError:
                pass
    return handler.client_address[0]


def post_form(url, fields):
    """form-data POST — files=(None, değer) biçimi isteği multipart/form-data gönderir."""
    response = requests.post(url, files={k: (None, v) for k, v in fields.items()}, timeout=30)
    return response.text


def parse_json(text):
    try:
        data = json.loads(text)
        return data if isinstance(data, dict) else None
    except ValueError:
        return None


def pay(card_holder_ip):
    """(HTTP durum, içerik tipi, gövde) döner."""
    client_ref_code = "789456|AB76"  # her işlemde benzersiz olmalı (ör. "ORDER-" + uuid)
    amount = "6.00"
    success_url = "https://siteniz.com/payment/callback"  # 3D sonucu buraya döner
    fail_url = "https://siteniz.com/payment/callback"
    host_url = "https://siteniz.com"
    customer_key = ""  # kart saklanmıyorsa boş
    card_number = "4546711234567894"

    # rnd: Türkiye saatiyle (UTC+3) dd-MM-yyyy HH:mm:ss
    rnd = datetime.now(timezone(timedelta(hours=3))).strftime("%d-%m-%Y %H:%M:%S")

    # Hash: sx|clientRefCode|amount|successUrl|failUrl|rnd|customerKey|secretKey → SHA512 (ham bayt) → Base64
    hash_str = "|".join([SX, client_ref_code, amount, success_url, fail_url, rnd, customer_key, MERCHANT_SECRET_KEY])
    hash_datav2 = base64.b64encode(hashlib.sha512(hash_str.encode("utf-8")).digest()).decode("ascii")

    # --- ADIM 1: Taksit sorgulama ---
    inst_body = post_form(INSTALLMENTS_URL, {
        "sx": SX,
        "amount": amount,
        "cardNumber": card_number,
        "hosturl": host_url,
        "iscardvalid": "false",  # sadece BIN (ilk 8 hane) ile sorgu
    })

    inst_data = parse_json(inst_body) or {}
    bank_list = inst_data.get("PAYMENT_BANK_LIST")
    option = bank_list[0] if isinstance(bank_list, list) and bank_list else None  # gerçek entegrasyonda kullanıcının seçtiği opsiyon

    # PAYMENT_BANK_LIST boşsa Adım 2'ye geçilmez
    if not isinstance(option, dict) or not option.get("EncodedValue"):
        return 400, "text/plain", "Taksit bilgisi alınamadı: " + inst_body

    encoded_value = option["EncodedValue"]
    installment_no = str(option.get("INSTALLMENT", "1"))

    # --- ADIM 2: 3D ödeme ---
    pay_body = post_form(PAYMENT_URL, {
        "EncodedValue": encoded_value,  # ← V0'a özgü, Adım 1'den gelir
        "installmentNo": installment_no,
        "amount": amount,
        "sx": SX,
        "clientRefCode": client_ref_code,
        "successUrl": success_url,
        "failUrl": fail_url,
        "cardHolderName": "Tuna Çınar",
        "month": "12",
        "year": "2026",
        "cvv": "001",
        "cardNumber": card_number,
        "use3D": "true",  # ← 3D akışı
        "transactionType": "SALES",
        "hosturl": host_url,
        "cardHolderIP": card_holder_ip,
        "rnd": rnd,
        "hashDatav2": hash_datav2,
        "environment": "API",
    })

    # === 3D'ye özgü: BANK_REQUEST_MESSAGE'ı tarayıcıya bas (banka ACS'ye auto-submit olur) ===
    bank_form = (parse_json(pay_body) or {}).get("BANK_REQUEST_MESSAGE")
    if bank_form:
        return 200, "text/html", bank_form

    # Sonuç successUrl/failUrl callback'inde — hash doğrulaması orada zorunlu
    return 400, "text/plain", "3D formu alınamadı: " + pay_body


class Handler(BaseHTTPRequestHandler):
    def do_GET(self):
        if self.path != "/odeme":
            return self.reply(404, "text/plain", "Ödeme için /odeme adresini açın.")
        try:
            self.reply(*pay(client_ip(self)))
        except requests.RequestException as exc:
            self.reply(502, "text/plain", "Bağlantı hatası: {}".format(exc))

    def reply(self, status, content_type, text):
        body = text.encode("utf-8")
        self.send_response(status)
        self.send_header("Content-Type", content_type + "; charset=utf-8")
        self.send_header("Content-Length", str(len(body)))
        self.end_headers()
        self.wfile.write(body)


if __name__ == "__main__":
    print("http://localhost:8000/odeme")
    HTTPServer(("0.0.0.0", 8000), Handler).serve_forever()

// === V0 3D FLOW: PaymentInstallments → Payment (Node.js + axios + form-data) ===
// Taksit Bilgisi Paynkolay'a Ait — önce taksit sorgulanır, dönen EncodedValue ile ödeme başlatılır.
// Kurulum: npm install axios form-data
// Çalıştırma: node example.js  →  http://localhost:8000/odeme
// Not: Canlı uç localhost'tan gelen istekleri reddeder; canlıda sunucunuzdan çalıştırın.
const http = require('http');
const net = require('net');
const crypto = require('crypto');
const axios = require('axios');
const FormData = require('form-data');

// Kimlik bilgileri (size verilen değerler)
const SX = 'SX_DEGERINIZ';
const MERCHANT_SECRET_KEY = 'SECRET_KEY_DEGERINIZ';

// Test uçları — canlıda alan adı paynkolay.nkolayislem.com.tr olur
const INSTALLMENTS_URL = 'https://paynkolaytest.nkolayislem.com.tr/Vpos/Payment/PaymentInstallments';
const PAYMENT_URL = 'https://paynkolaytest.nkolayislem.com.tr/Vpos/Payment/Payment';

// Müşteri IP'si: önce proxy başlıkları, yoksa bağlantı adresi
function clientIp(req) {
  for (const header of ['cf-connecting-ip', 'x-forwarded-for', 'x-real-ip']) {
    const value = req.headers[header];
    if (value) {
      const ip = String(value).split(',')[0].trim();
      if (net.isIP(ip)) return ip;
    }
  }
  return (req.socket.remoteAddress || '127.0.0.1').replace(/^::ffff:/, '');
}

// rnd: Türkiye saatiyle (UTC+3) dd-MM-yyyy HH:mm:ss
function turkeyTime() {
  const d = new Date(Date.now() + 3 * 60 * 60 * 1000);
  const p = (n) => String(n).padStart(2, '0');
  return `${p(d.getUTCDate())}-${p(d.getUTCMonth() + 1)}-${d.getUTCFullYear()} ` +
    `${p(d.getUTCHours())}:${p(d.getUTCMinutes())}:${p(d.getUTCSeconds())}`;
}

// form-data POST (multipart/form-data) — gövdeyi metin olarak döner
async function postForm(url, fields) {
  const form = new FormData();
  for (const [key, value] of Object.entries(fields)) form.append(key, value);

  const response = await axios.post(url, form, {
    headers: form.getHeaders(),
    timeout: 30000,
    responseType: 'text',
    validateStatus: () => true, // HTTP durum kodundan bağımsız gövdeyi okuyalım
  });
  return response.data;
}

function parseJson(text) {
  try {
    const data = JSON.parse(text);
    return data && typeof data === 'object' ? data : {};
  } catch {
    return {};
  }
}

// { status, type, body } döner
async function pay(cardHolderIP) {
  const clientRefCode = '789456|AB76';                      // her işlemde benzersiz olmalı (ör. 'ORDER-' + Date.now())
  const amount = '6.00';
  const successUrl = 'https://siteniz.com/payment/callback'; // 3D sonucu buraya döner
  const failUrl = 'https://siteniz.com/payment/callback';
  const hostUrl = 'https://siteniz.com';
  const customerKey = '';                                   // kart saklanmıyorsa boş
  const cardNumber = '4546711234567894';
  const rnd = turkeyTime();

  // Hash: sx|clientRefCode|amount|successUrl|failUrl|rnd|customerKey|secretKey → SHA512 (ham bayt) → Base64
  const hashStr = [SX, clientRefCode, amount, successUrl, failUrl, rnd, customerKey, MERCHANT_SECRET_KEY].join('|');
  const hashDatav2 = crypto.createHash('sha512').update(hashStr, 'utf8').digest('base64');

  // --- ADIM 1: Taksit sorgulama ---
  const instBody = await postForm(INSTALLMENTS_URL, {
    sx: SX,
    amount,
    cardNumber,
    hosturl: hostUrl,
    iscardvalid: 'false', // sadece BIN (ilk 8 hane) ile sorgu
  });

  const bankList = parseJson(instBody).PAYMENT_BANK_LIST;
  const option = Array.isArray(bankList) ? bankList[0] : undefined; // gerçek entegrasyonda kullanıcının seçtiği opsiyon

  // PAYMENT_BANK_LIST boşsa Adım 2'ye geçilmez
  if (!option || !option.EncodedValue) {
    return { status: 400, type: 'text/plain', body: `Taksit bilgisi alınamadı: ${instBody}` };
  }

  const encodedValue = option.EncodedValue;
  const installmentNo = String(option.INSTALLMENT ?? '1');

  // --- ADIM 2: 3D ödeme ---
  const payBody = await postForm(PAYMENT_URL, {
    EncodedValue: encodedValue,   // ← V0'a özgü, Adım 1'den gelir
    installmentNo,
    amount,
    sx: SX,
    clientRefCode,
    successUrl,
    failUrl,
    cardHolderName: 'Tuna Çınar',
    month: '12',
    year: '2026',
    cvv: '001',
    cardNumber,
    use3D: 'true',                // ← 3D akışı
    transactionType: 'SALES',
    hosturl: hostUrl,
    cardHolderIP,
    rnd,
    hashDatav2,
    environment: 'API',
  });

  // === 3D'ye özgü: BANK_REQUEST_MESSAGE'ı tarayıcıya bas (banka ACS'ye auto-submit olur) ===
  const bankForm = parseJson(payBody).BANK_REQUEST_MESSAGE;
  if (bankForm) {
    return { status: 200, type: 'text/html', body: bankForm };
  }

  // Sonuç successUrl/failUrl callback'inde — hash doğrulaması orada zorunlu
  return { status: 400, type: 'text/plain', body: `3D formu alınamadı: ${payBody}` };
}

http.createServer(async (req, res) => {
  const reply = (status, type, text) => {
    res.writeHead(status, { 'Content-Type': `${type}; charset=utf-8` });
    res.end(text);
  };

  if (req.url !== '/odeme') return reply(404, 'text/plain', 'Ödeme için /odeme adresini açın.');

  try {
    const { status, type, body } = await pay(clientIp(req));
    reply(status, type, body);
  } catch (err) {
    reply(502, 'text/plain', `Bağlantı hatası: ${err.message}`);
  }
}).listen(8000, () => console.log('http://localhost:8000/odeme'));