Shophin Partner API

Authorization: Bearer shp_live_7f3a2b1c9d4e_a91c...

{
  "error": {
    "code": "unauthorized",
    "message": "Geçersiz veya süresi dolmuş API anahtarı",
    "field": null
  }
}

{
  "error": {
    "code": "insufficient_scope",
    "message": "Bu uç için gereken izin anahtarınızda yok: orders:write",
    "field": null
  }
}

cursor=""
while :; do
  res=$(curl -s -H "Authorization: Bearer $SHOPHIN_KEY" \
    "https://api.shophin.com/api/partner/v1/orders?status=PAID&limit=100${cursor:+&cursor=$cursor}")

  echo "$res" | jq -c '.data[]'

  cursor=$(echo "$res" | jq -r '.nextCursor // empty')
  [ -z "$cursor" ] && break
done

{
  "error": {
    "code": "invalid_status_transition",
    "message": "Yalnızca ödemesi alınmış (PAID) sipariş onaylanabilir; bu sipariş PREPARING durumunda.",
    "field": "status"
  }
}

curl -X POST -H "Authorization: Bearer $SHOPHIN_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "title": "El Yapımı Zeytinyağlı Sabun",
    "description": "Soğuk pres zeytinyağı, 100 gr.",
    "productType": "PHYSICAL",
    "hasVariants": false,
    "price": 120.00,
    "stock": 25,
    "sku": "SBN-001",
    "vatRate": 20
  }' \
  https://api.shophin.com/api/partner/v1/products

{
  "id": "cmsn3c6840001s06mm00k9lag",
  "slug": "el-yapimi-zeytinyagli-sabun",
  "title": "El Yapımı Zeytinyağlı Sabun",
  "status": "DRAFT",
  "productType": "PHYSICAL",
  "hasVariants": false,
  "sku": "SBN-001",
  "price": 120,
  "vatRate": 20,
  "imageCount": 0,
  "variants": [],
  "createdAt": "2026-08-10T09:41:22.104Z"
}

{
  "title": "Pamuklu Tişört",
  "productType": "PHYSICAL",
  "hasVariants": true,
  "vatRate": 20,
  "options": [
    { "name": "Beden", "values": ["S", "M", "L"] }
  ],
  "variants": [
    { "optionValues": { "Beden": "S" }, "price": 250, "stock": 5, "sku": "TS-S" },
    { "optionValues": { "Beden": "M" }, "price": 250, "stock": 8, "sku": "TS-M" }
  ]
}

curl -X POST -H "Authorization: Bearer $SHOPHIN_KEY" \
  -H "Content-Type: application/json" \
  -d '{"fileName":"sabun.jpg","contentType":"image/jpeg","size":184320}' \
  https://api.shophin.com/api/partner/v1/products/cmsn3c6840001s06mm00k9lag/images/presign

# → {"key":"stores/.../sabun.jpg","uploadUrl":"https://..."}

curl -X PUT -H "Content-Type: image/jpeg" \
  --data-binary @sabun.jpg \
  "$UPLOAD_URL"

curl -X POST -H "Authorization: Bearer $SHOPHIN_KEY" \
  -H "Content-Type: application/json" \
  -d '{"key":"stores/.../sabun.jpg","alt":"El yapımı sabun"}' \
  https://api.shophin.com/api/partner/v1/products/cmsn3c6840001s06mm00k9lag/images

# → {"id":"cms...","url":"https://.../sabun.webp","position":0}

curl -X POST -H "Authorization: Bearer $SHOPHIN_KEY" \
  https://api.shophin.com/api/partner/v1/products/cmsn3c6840001s06mm00k9lag/publish

{
  "id": "cmsn3c6840001s06mm00k9lag",
  "slug": "el-yapimi-zeytinyagli-sabun",
  "status": "ACTIVE",
  "imageCount": 1,
  "variants": []
}

curl -X POST -H "Content-Type: application/json" \
  -d '{
    "storeSlug": "ayse-butik",
    "productSlug": "el-yapimi-zeytinyagli-sabun",
    "quantity": 2
  }' \
  https://api.shophin.com/api/cart/items

# Varyantlı üründe variantId de gerekir:
#   "variantId": "<oluşturma yanıtındaki variants[].id>"

curl -X PATCH -H "Authorization: Bearer $SHOPHIN_KEY" \
  -H "Content-Type: application/json" \
  -d '{"price": 149.90, "stock": 12}' \
  https://api.shophin.com/api/partner/v1/products/cmsn3c6840001s06mm00k9lag

# Satıştan kaldır
curl -X PATCH -H "Authorization: Bearer $SHOPHIN_KEY" \
  -H "Content-Type: application/json" \
  -d '{"status":"INACTIVE"}' \
  https://api.shophin.com/api/partner/v1/products/cmsn3c6840001s06mm00k9lag

curl -X PATCH -H "Authorization: Bearer $SHOPHIN_KEY" \
  -H "Content-Type: application/json" \
  -d '{"stock": 42, "price": 279.90}' \
  https://api.shophin.com/api/partner/v1/products/cmsn3c6840001s06mm00k9lag/variants/cms7v1a2b0001x0yz

{
  "id": "cmsn3c6840001s06mm00k9lag",
  "slug": "pamuklu-tisort",
  "status": "ACTIVE",
  "hasVariants": true,
  "variants": [
    {
      "id": "cms7v1a2b0001x0yz",
      "sku": "TS-S",
      "optionValues": { "Beden": "S" },
      "price": 279.90,
      "compareAtPrice": null,
      "stock": 42
    },
    {
      "id": "cms7v1a2b0002x0yz",
      "sku": "TS-M",
      "optionValues": { "Beden": "M" },
      "price": 250,
      "compareAtPrice": null,
      "stock": 8
    }
  ]
}

curl -H "Authorization: Bearer $SHOPHIN_KEY" \
  "https://api.shophin.com/api/partner/v1/orders?status=PAID&limit=50"

{
  "data": [ /* sipariş nesneleri — bkz. Sipariş detayı */ ],
  "nextCursor": "Y21yejd6Njd4MDAwaHMwYmp2ZzB1OTZ5Yg"
}

curl -H "Authorization: Bearer $SHOPHIN_KEY" \
  https://api.shophin.com/api/partner/v1/orders/SPH-MRZ7Z67W-8ECB

{
  "orderNumber": "SPH-MRZ7Z67W-8ECB",
  "status": "PREPARING",
  "createdAt": "2026-07-28T09:14:22.031Z",
  "updatedAt": "2026-07-28T09:16:05.884Z",
  "currency": "TRY",
  "itemsTotal": 49.90,
  "itemsDiscount": 0,
  "shippingTotal": 30.00,
  "shippingDiscount": 0,
  "grandTotal": 79.90,
  "taxTotal": 13.32,
  "taxSummary": [
    { "rate": 20, "taxBase": 66.58, "taxTotal": 13.32 }
  ],
  "shippingTax": {
    "rate": 20,
    "gross": 30.00,
    "taxBase": 25.00,
    "taxTotal": 5.00
  },
  "invoices": [],
  "invoiceInfo": {
    "title": "Akme Yazılım A.Ş.",
    "taxId": "1234567808",
    "taxIdKind": "VKN",
    "taxOffice": "Beşiktaş",
    "city": "Ankara",
    "district": "Çankaya",
    "addressLine": "Fatura Cad. No:5",
    "zip": "34710"
  },
  "trackingNumber": "SPH-KRG-DDA535EC",
  "carrier": null,
  "hasDigitalItems": false,
  "digitalDeliveryComplete": true,
  "customer": {
    "name": "Selin Kaya",
    "maskedEmail": "s*****1@e*****e.com",
    "phone": "05551112233",
    "isGuest": false
  },
  "shipping": {
    "fullName": "Selin Kaya",
    "phone": "05551112233",
    "city": "İstanbul",
    "district": "Kadıköy",
    "addressLine": "Örnek Mah. Test Sok. No:1",
    "zip": "34710"
  },
  "items": [
    {
      "id": "cmrxlhy0v000dh37gtsibedq6",
      "title": "El Yapımı Sabun",
      "sku": "SBN-LVN-01",
      "variant": "Koku: Lavanta",
      "productType": "PHYSICAL",
      "unitPrice": 49.90,
      "quantity": 1,
      "lineTotal": 49.90,
      "discountShare": 0,
      "vatRate": 20,
      "taxBase": 41.58,
      "taxTotal": 8.32,
      "deliveries": [],
      "awaitingDelivery": false
    }
  ]
}

curl -X POST -H "Authorization: Bearer $SHOPHIN_KEY" \
  https://api.shophin.com/api/partner/v1/orders/SPH-MRZ7Z67W-8ECB/approve

{
  "orderNumber": "SPH-MRZ7Z67W-8ECB",
  "status": "PREPARING",
  "trackingNumber": "SPH-KRG-DDA535EC",
  "...": "diğer alanlar sipariş detayıyla aynı"
}

curl -X POST -H "Authorization: Bearer $SHOPHIN_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "type": "CODE",
    "content": "LISANS-ABC-123",
    "note": "Kurulum sırasında bu kodu girin"
  }' \
  https://api.shophin.com/api/partner/v1/orders/SPH-MRXLHY0V-C528/items/cmrxlhy0v000dh37gtsibedq6/deliveries

{
  "orderNumber": "SPH-MRXLHY0V-C528",
  "status": "DELIVERED",
  "digitalDeliveryComplete": true,
  "items": [
    {
      "id": "cmrxlhy0v000dh37gtsibedq6",
      "productType": "DIGITAL",
      "awaitingDelivery": false,
      "deliveries": [
        {
          "id": "cms1a2b3c0001x0yz",
          "type": "CODE",
          "content": "LISANS-ABC-123",
          "fileName": null,
          "note": "Kurulum sırasında bu kodu girin",
          "deliveredAt": "2026-07-30T21:04:11.902Z"
        }
      ]
    }
  ]
}

curl -X POST -H "Authorization: Bearer $SHOPHIN_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "number": "GT2026000000123",
    "issuedAt": "2026-07-31T09:00:00Z",
    "pdfUrl": "https://entegrator.example.com/f/gt123.pdf"
  }' \
  https://api.shophin.com/api/partner/v1/orders/SPH-MRZ7WMVI-FE3E/invoice

{
  "id": "cms7vnlg00001s0gk4thxezao",
  "orderNumber": "SPH-MRZ7WMVI-FE3E",
  "number": "GT2026000000123",
  "issuedAt": "2026-07-31T09:00:00.000Z",
  "pdfUrl": "https://entegrator.example.com/f/gt123.pdf",
  "createdAt": "2026-07-31T09:00:04.512Z"
}

{
  "id": "evt_9f2c1a7b4d6e8f0a1b2c3d4e5f60718",
  "type": "order.paid",
  "createdAt": "2026-08-07T09:14:25.114Z",
  "data": {
    "orderNumber": "SPH-MRZ7Z67W-8ECB",
    "status": "PAID",
    "createdAt": "2026-08-07T09:14:22.031Z",
    "updatedAt": "2026-08-07T09:14:25.102Z",
    "currency": "TRY",
    "itemsTotal": 149.70,
    "itemsDiscount": 10.00,
    "shippingTotal": 30.00,
    "shippingDiscount": 5.00,
    "grandTotal": 164.70,
    "hasDigitalItems": false,
    "items": [
      {
        "id": "cmrxlhy0v000dh37gtsibedq6",
        "title": "El Yapımı Sabun",
        "sku": "SBN-LVN-01",
        "variant": "Koku: Lavanta",
        "productType": "PHYSICAL",
        "unitPrice": 49.90,
        "quantity": 2,
        "lineTotal": 99.80,
        "discountShare": 10.00
      }
    ]
  }
}

import express from "express";
import crypto from "node:crypto";

const SECRET = process.env.SHOPHIN_WEBHOOK_SECRET;
const app = express();

// Ham gövde şart: express.json() gövdeyi yeniden yazdırırsa imza tutmaz
app.post("/shophin/webhook", express.raw({ type: "application/json" }), (req, res) => {
  const ts = req.get("X-Shophin-Timestamp");
  const body = req.body.toString("utf8");

  // 1) Tazelik: 5 dakikadan eski istek reddedilir (replay koruması)
  if (Math.abs(Math.floor(Date.now() / 1000) - Number(ts)) > 300) {
    return res.sendStatus(400);
  }

  // 2) İmza
  const expected = crypto
    .createHmac("sha256", SECRET)
    .update(`${ts}.${body}`)
    .digest("hex");
  const provided = (req.get("X-Shophin-Signature") ?? "")
    .split(",").map((p) => p.trim())
    .find((p) => p.startsWith("v1="))?.slice(3) ?? "";

  const a = Buffer.from(expected, "hex");
  const b = Buffer.from(provided, "hex");
  if (a.length !== b.length || !crypto.timingSafeEqual(a, b)) {
    return res.sendStatus(401);
  }

  // 3) Önce 200 dön, işi sonra yap — 10 sn'yi aşan yanıt zaman aşımına düşer
  res.sendStatus(200);

  const event = JSON.parse(body);
  if (islendiMi(event.id)) return;      // aynı olay tekrar gelebilir
  kuyrugaEkle(event);                    // ayrıntı: GET /orders/{orderNumber}
});

app.listen(3000);

import hashlib, hmac, os, time
from flask import Flask, request

SECRET = os.environ["SHOPHIN_WEBHOOK_SECRET"].encode()
app = Flask(__name__)

@app.post("/shophin/webhook")
def webhook():
    body = request.get_data()                      # ham gövde
    ts = request.headers.get("X-Shophin-Timestamp", "")
    sig = request.headers.get("X-Shophin-Signature", "")

    # 1) Tazelik
    if abs(int(time.time()) - int(ts or 0)) > 300:
        return "", 400

    # 2) İmza
    expected = hmac.new(
        SECRET, f"{ts}.".encode() + body, hashlib.sha256
    ).hexdigest()
    provided = next(
        (p.strip()[3:] for p in sig.split(",") if p.strip().startswith("v1=")),
        "",
    )
    if not hmac.compare_digest(expected, provided):
        return "", 401

    # 3) Ağır işi burada yapmayın; kuyruğa bırakıp hemen dönün
    event = request.get_json()
    if not islendi_mi(event["id"]):
        kuyruga_ekle(event)                        # GET /orders/{orderNumber}
    return "", 200

using System.Security.Cryptography;
using System.Text;

app.MapPost("/shophin/webhook", async (HttpRequest req) =>
{
    var secret = Environment.GetEnvironmentVariable("SHOPHIN_WEBHOOK_SECRET")!;
    using var reader = new StreamReader(req.Body);
    var body = await reader.ReadToEndAsync();          // ham gövde

    var ts = req.Headers["X-Shophin-Timestamp"].ToString();
    var sig = req.Headers["X-Shophin-Signature"].ToString();

    // 1) Tazelik
    var now = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
    if (!long.TryParse(ts, out var sent) || Math.Abs(now - sent) > 300)
        return Results.BadRequest();

    // 2) İmza
    using var hmac = new HMACSHA256(Encoding.UTF8.GetBytes(secret));
    var expected = Convert.ToHexString(
        hmac.ComputeHash(Encoding.UTF8.GetBytes($"{ts}.{body}"))).ToLowerInvariant();

    var provided = sig.Split(',')
        .Select(p => p.Trim())
        .FirstOrDefault(p => p.StartsWith("v1="))?[3..] ?? "";

    if (!CryptographicOperations.FixedTimeEquals(
            Encoding.UTF8.GetBytes(expected), Encoding.UTF8.GetBytes(provided)))
        return Results.Unauthorized();

    // 3) Önce yanıt, işi arkada yap
    _ = Task.Run(() => Isle(body));                    // GET /orders/{orderNumber}
    return Results.Ok();
});

<?php
$secret = getenv('SHOPHIN_WEBHOOK_SECRET');
$body   = file_get_contents('php://input');            // ham gövde
$ts     = $_SERVER['HTTP_X_SHOPHIN_TIMESTAMP'] ?? '';
$sig    = $_SERVER['HTTP_X_SHOPHIN_SIGNATURE'] ?? '';

// 1) Tazelik
if (abs(time() - (int)$ts) > 300) {
    http_response_code(400);
    exit;
}

// 2) İmza
$expected = hash_hmac('sha256', $ts . '.' . $body, $secret);

$provided = '';
foreach (explode(',', $sig) as $part) {
    $part = trim($part);
    if (str_starts_with($part, 'v1=')) {
        $provided = substr($part, 3);
    }
}

if (!hash_equals($expected, $provided)) {
    http_response_code(401);
    exit;
}

// 3) Önce yanıt
http_response_code(200);
$event = json_decode($body, true);
if (!islendiMi($event['id'])) {
    kuyrugaEkle($event);                               // GET /orders/{orderNumber}
}

package main

import (
	"crypto/hmac"
	"crypto/sha256"
	"crypto/subtle"
	"encoding/hex"
	"encoding/json"
	"io"
	"math"
	"net/http"
	"os"
	"strconv"
	"strings"
	"time"
)

var secret = []byte(os.Getenv("SHOPHIN_WEBHOOK_SECRET"))

func webhook(w http.ResponseWriter, r *http.Request) {
	body, _ := io.ReadAll(r.Body) // ham gövde

	ts := r.Header.Get("X-Shophin-Timestamp")
	sent, err := strconv.ParseInt(ts, 10, 64)

	// 1) Tazelik
	if err != nil || math.Abs(float64(time.Now().Unix()-sent)) > 300 {
		w.WriteHeader(http.StatusBadRequest)
		return
	}

	// 2) İmza
	mac := hmac.New(sha256.New, secret)
	mac.Write([]byte(ts + "."))
	mac.Write(body)
	expected := hex.EncodeToString(mac.Sum(nil))

	provided := ""
	for _, part := range strings.Split(r.Header.Get("X-Shophin-Signature"), ",") {
		if part = strings.TrimSpace(part); strings.HasPrefix(part, "v1=") {
			provided = part[3:]
		}
	}

	if subtle.ConstantTimeCompare([]byte(expected), []byte(provided)) != 1 {
		w.WriteHeader(http.StatusUnauthorized)
		return
	}

	// 3) Önce yanıt, işi arkada yap
	w.WriteHeader(http.StatusOK)

	var event struct {
		ID   string `json:"id"`
		Type string `json:"type"`
	}
	json.Unmarshal(body, &event)
	if !islendiMi(event.ID) {
		go kuyrugaEkle(event) // ayrıntı: GET /orders/{orderNumber}
	}
}

func main() {
	http.HandleFunc("/shophin/webhook", webhook)
	http.ListenAndServe(":3000", nil)
}

matrah = (lineTotal - discountShare) / (1 + vatRate / 100)
kdv    = (lineTotal - discountShare) - matrah

# Örnek: 49,90 TL, %20
# matrah = 49.90 / 1.20 = 41.5833… → 41.58
# kdv    = 49.90 - 41.58            =  8.32

"taxSummary": [
  { "rate": 10, "taxBase": 100.00, "taxTotal": 10.00 },
  { "rate": 20, "taxBase": 66.58,  "taxTotal": 13.32 }
],
"taxTotal": 23.32,
"shippingTax": { "rate": 20, "gross": 30.00, "taxBase": 25.00, "taxTotal": 5.00 }

const BASE = "https://api.shophin.com/api/partner/v1";
const KEY = process.env.SHOPHIN_KEY;

async function call(method, path, body) {
  const res = await fetch(BASE + path, {
    method,
    headers: {
      Authorization: `Bearer ${KEY}`,
      "Content-Type": "application/json",
    },
    body: body ? JSON.stringify(body) : undefined,
  });
  const data = await res.json();
  if (!res.ok) throw Object.assign(new Error(data.error.message), data.error);
  return data;
}

const { data: orders } = await call("GET", "/orders?status=PAID&limit=100");

for (const order of orders) {
  // 1) Onayla — zaten onaylıysa hata sayma
  try {
    await call("POST", `/orders/${order.orderNumber}/approve`);
  } catch (e) {
    if (e.code !== "invalid_status_transition") throw e;
  }

  // 2) Bekleyen dijital kalemlere teslimat işle
  for (const item of order.items) {
    if (!item.awaitingDelivery) continue;
    for (let i = 0; i < item.quantity; i++) {
      await call("POST", `/orders/${order.orderNumber}/items/${item.id}/deliveries`, {
        type: "CODE",
        content: await lisansUret(item.title),
      });
    }
  }

  // 3) Faturayı kes ve siparişe işle
  const fatura = await faturaKes(order);
  await call("POST", `/orders/${order.orderNumber}/invoice`, {
    number: fatura.number,
    issuedAt: fatura.issuedAt,
    pdfUrl: fatura.pdfUrl,
  });
}

import os
import requests

BASE = "https://api.shophin.com/api/partner/v1"

session = requests.Session()
session.headers.update({
    "Authorization": f"Bearer {os.environ['SHOPHIN_KEY']}",
    "Content-Type": "application/json",
})


class ShophinError(Exception):
    def __init__(self, code: str, message: str):
        super().__init__(message)
        self.code = code


def call(method: str, path: str, body: dict | None = None) -> dict:
    res = session.request(method, BASE + path, json=body)
    data = res.json()
    if not res.ok:
        raise ShophinError(data["error"]["code"], data["error"]["message"])
    return data


orders = call("GET", "/orders?status=PAID&limit=100")["data"]

for order in orders:
    no = order["orderNumber"]

    # 1) Onayla — zaten onaylıysa hata sayma
    try:
        call("POST", f"/orders/{no}/approve")
    except ShophinError as e:
        if e.code != "invalid_status_transition":
            raise

    # 2) Bekleyen dijital kalemlere teslimat işle
    for item in order["items"]:
        if not item["awaitingDelivery"]:
            continue
        for _ in range(item["quantity"]):
            call("POST", f"/orders/{no}/items/{item['id']}/deliveries", {
                "type": "CODE",
                "content": lisans_uret(item["title"]),
            })

    # 3) Faturayı kes ve siparişe işle
    fatura = fatura_kes(order)
    call("POST", f"/orders/{no}/invoice", {
        "number": fatura["number"],
        "issuedAt": fatura["issuedAt"],
        "pdfUrl": fatura["pdfUrl"],
    })

using System.Net.Http.Headers;
using System.Net.Http.Json;

const string Base = "https://api.shophin.com/api/partner/v1";

var http = new HttpClient();
http.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(
    "Bearer", Environment.GetEnvironmentVariable("SHOPHIN_KEY"));

// System.Net.Http.Json web varsayılanlarını kullanır: orderNumber ↔ OrderNumber
async Task<T?> Call<T>(HttpMethod method, string path, object? body = null)
{
    using var req = new HttpRequestMessage(method, Base + path);
    if (body is not null) req.Content = JsonContent.Create(body);

    using var res = await http.SendAsync(req);
    if (!res.IsSuccessStatusCode)
    {
        var wrapper = await res.Content.ReadFromJsonAsync<ErrorWrapper>();
        throw new ShophinException(wrapper!.Error.Code, wrapper.Error.Message);
    }
    return await res.Content.ReadFromJsonAsync<T>();
}

var page = await Call<Page>(HttpMethod.Get, "/orders?status=PAID&limit=100");

foreach (var order in page!.Data)
{
    // 1) Onayla — zaten onaylıysa hata sayma
    try
    {
        await Call<object>(HttpMethod.Post, $"/orders/{order.OrderNumber}/approve");
    }
    catch (ShophinException e) when (e.Code == "invalid_status_transition") { }

    // 2) Bekleyen dijital kalemlere teslimat işle
    foreach (var item in order.Items)
    {
        if (!item.AwaitingDelivery) continue;
        for (var i = 0; i < item.Quantity; i++)
        {
            await Call<object>(
                HttpMethod.Post,
                $"/orders/{order.OrderNumber}/items/{item.Id}/deliveries",
                new { type = "CODE", content = LisansUret(item.Title) });
        }
    }

    // 3) Faturayı kes ve siparişe işle
    var fatura = FaturaKes(order);
    await Call<object>(HttpMethod.Post, $"/orders/{order.OrderNumber}/invoice", new
    {
        number = fatura.Number,
        issuedAt = fatura.IssuedAt,
        pdfUrl = fatura.PdfUrl,
    });
}

record ErrorWrapper(ApiError Error);
record ApiError(string Code, string Message, string? Field);
record Page(List<Order> Data);
record Order(string OrderNumber, List<Item> Items);
record Item(string Id, string Title, int Quantity, bool AwaitingDelivery);

class ShophinException(string code, string message) : Exception(message)
{
    public string Code { get; } = code;
}

<?php
const BASE = "https://api.shophin.com/api/partner/v1";

class ShophinError extends RuntimeException {
    public function __construct(public readonly string $code, string $message) {
        parent::__construct($message);
    }
}

function call(string $method, string $path, ?array $body = null): array {
    $ch = curl_init(BASE . $path);
    curl_setopt_array($ch, [
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_CUSTOMREQUEST  => $method,
        CURLOPT_HTTPHEADER     => [
            "Authorization: Bearer " . getenv("SHOPHIN_KEY"),
            "Content-Type: application/json",
        ],
    ]);
    if ($body !== null) {
        curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($body));
    }
    $raw    = curl_exec($ch);
    $status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);

    $data = json_decode($raw, true);
    if ($status >= 400) {
        throw new ShophinError($data["error"]["code"], $data["error"]["message"]);
    }
    return $data;
}

$orders = call("GET", "/orders?status=PAID&limit=100")["data"];

foreach ($orders as $order) {
    $no = $order["orderNumber"];

    // 1) Onayla — zaten onaylıysa hata sayma
    try {
        call("POST", "/orders/$no/approve");
    } catch (ShophinError $e) {
        if ($e->code !== "invalid_status_transition") throw $e;
    }

    // 2) Bekleyen dijital kalemlere teslimat işle
    foreach ($order["items"] as $item) {
        if (!$item["awaitingDelivery"]) continue;
        for ($i = 0; $i < $item["quantity"]; $i++) {
            call("POST", "/orders/$no/items/{$item['id']}/deliveries", [
                "type"    => "CODE",
                "content" => lisansUret($item["title"]),
            ]);
        }
    }

    // 3) Faturayı kes ve siparişe işle
    $fatura = faturaKes($order);
    call("POST", "/orders/$no/invoice", [
        "number"   => $fatura["number"],
        "issuedAt" => $fatura["issuedAt"],
        "pdfUrl"   => $fatura["pdfUrl"],
    ]);
}

package main

import (
	"bytes"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"net/http"
	"os"
)

const base = "https://api.shophin.com/api/partner/v1"

type APIError struct {
	Code    string `json:"code"`
	Message string `json:"message"`
	Field   string `json:"field"`
}

func (e APIError) Error() string { return e.Message }

func call(method, path string, body, out any) error {
	var payload io.Reader
	if body != nil {
		b, err := json.Marshal(body)
		if err != nil {
			return err
		}
		payload = bytes.NewReader(b)
	}

	req, err := http.NewRequest(method, base+path, payload)
	if err != nil {
		return err
	}
	req.Header.Set("Authorization", "Bearer "+os.Getenv("SHOPHIN_KEY"))
	req.Header.Set("Content-Type", "application/json")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		return err
	}
	defer res.Body.Close()

	if res.StatusCode >= 400 {
		var wrapper struct {
			Error APIError `json:"error"`
		}
		json.NewDecoder(res.Body).Decode(&wrapper)
		return wrapper.Error
	}
	if out != nil {
		return json.NewDecoder(res.Body).Decode(out)
	}
	return nil
}

type Item struct {
	ID               string `json:"id"`
	Title            string `json:"title"`
	Quantity         int    `json:"quantity"`
	AwaitingDelivery bool   `json:"awaitingDelivery"`
}

type Order struct {
	OrderNumber string `json:"orderNumber"`
	Items       []Item `json:"items"`
}

func main() {
	var page struct {
		Data []Order `json:"data"`
	}
	if err := call("GET", "/orders?status=PAID&limit=100", nil, &page); err != nil {
		panic(err)
	}

	for _, order := range page.Data {
		// 1) Onayla — zaten onaylıysa hata sayma
		if err := call("POST", "/orders/"+order.OrderNumber+"/approve", nil, nil); err != nil {
			var apiErr APIError
			if !errors.As(err, &apiErr) || apiErr.Code != "invalid_status_transition" {
				panic(err)
			}
		}

		// 2) Bekleyen dijital kalemlere teslimat işle
		for _, item := range order.Items {
			if !item.AwaitingDelivery {
				continue
			}
			for i := 0; i < item.Quantity; i++ {
				path := fmt.Sprintf("/orders/%s/items/%s/deliveries", order.OrderNumber, item.ID)
				body := map[string]string{"type": "CODE", "content": lisansUret(item.Title)}
				if err := call("POST", path, body, nil); err != nil {
					panic(err)
				}
			}
		}

		// 3) Faturayı kes ve siparişe işle
		fatura := faturaKes(order)
		if err := call("POST", "/orders/"+order.OrderNumber+"/invoice", fatura, nil); err != nil {
			panic(err)
		}
	}
}