API 文档

import com.fasterxml.jackson.databind.ObjectMapper;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.io.*;
import java.net.*;
import java.nio.charset.StandardCharsets;
import java.util.*;

public class MyPromotionClient {
    private final String baseUrl;
    private final String accessKey;
    private final String accessSecret;
    private final ObjectMapper mapper = new ObjectMapper();

    public MyPromotionClient(String accessKey, String accessSecret, String baseUrl) {
        this.accessKey = accessKey;
        this.accessSecret = accessSecret;
        this.baseUrl = baseUrl.replaceAll("/+$", "");
    }

    public MyPromotionClient(String accessKey, String accessSecret) {
        this(accessKey, accessSecret, "https://api.example.com");
    }

    /* ===== 核心请求辅助 ===== */
    private Map<String, Object> request(String method, String path,
                                         Map<String, String> query,
                                         Map<String, Object> body) throws Exception {
        String url = baseUrl + path;
        if (query != null && !query.isEmpty()) {
            StringBuilder qs = new StringBuilder("?");
            for (Map.Entry<String, String> e : query.entrySet())
                qs.append(e.getKey()).append("=").append(URLEncoder.encode(e.getValue(), "UTF-8")).append("&");
            url += qs.toString();
        }
        HttpURLConnection conn = (HttpURLConnection) new URL(url).openConnection();
        conn.setRequestMethod(method);
        conn.setRequestProperty("Content-Type", "application/json");
        conn.setRequestProperty("X-Access-Key", accessKey);
        conn.setRequestProperty("X-Access-Secret", accessSecret);
        if (body != null) {
            conn.setDoOutput(true);
            OutputStream os = conn.getOutputStream();
            os.write(mapper.writeValueAsString(body).getBytes(StandardCharsets.UTF_8));
            os.flush(); os.close();
        }
        int code = conn.getResponseCode();
        InputStream stream = (code >= 200 && code < 300) ? conn.getInputStream() : conn.getErrorStream();
        BufferedReader in = new BufferedReader(new InputStreamReader(stream, StandardCharsets.UTF_8));
        StringBuilder sb = new StringBuilder();
        String line;
        while ((line = in.readLine()) != null) sb.append(line);
        in.close();
        if (code < 200 || code >= 300) { throw new RuntimeException("HTTP " + code + ": " + sb); }
        return mapper.readValue(sb.toString(), Map.class);
    }

    /* ===== 查询类 ===== */
    public Map<String, Object> healthCheck() throws Exception {
        return request("GET", "/api/v1/health/", null, null);
    }

    public Map<String, Object> listPromotions(int page, int pageSize) throws Exception {
        Map<String, String> q = new HashMap<>(); q.put("page", String.valueOf(page)); q.put("page_size", String.valueOf(pageSize));
        return request("GET", "/api/v1/promotions/", q, null);
    }

    public Map<String, Object> getPromotionMetadata(String promotionCode) throws Exception {
        return request("GET", "/api/v1/promotions/" + promotionCode + "/metadata/", null, null);
    }

    public Map<String, Object> getPromotionDetail(String promotionCode) throws Exception {
        return request("GET", "/api/v1/promotions/" + promotionCode + "/detail/", null, null);
    }

    public Map<String, Object> listTags() throws Exception {
        return request("GET", "/api/v1/promotions/tags/", null, null);
    }

    public Map<String, Object> getTag(String tagCode) throws Exception {
        return request("GET", "/api/v1/promotions/tags/" + tagCode + "/", null, null);
    }

    public Map<String, Object> getTrace(String traceId) throws Exception {
        return request("GET", "/api/v1/traces/" + traceId + "/", null, null);
    }

    /* ===== 计算类 ===== */
    public Map<String, Object> promoCalculate(String userId, List<Map<String, Object>> cartItems,
                                               List<String> promotionCodes, String orderId,
                                               boolean preview) throws Exception {
        Map<String, Object> body = new HashMap<>();
        body.put("user_id", userId); body.put("cart_items", cartItems);
        body.put("promotion_codes", promotionCodes);
        body.put("preview", preview); body.put("order_id", orderId);
        return request("POST", "/api/v1/promotions/calculate/", null, body);
    }

    public Map<String, Object> tagCalculate(String tagCode, String userId,
                                             List<Map<String, Object>> cartItems, String orderId,
                                             boolean preview) throws Exception {
        Map<String, Object> body = new HashMap<>();
        body.put("user_id", userId); body.put("cart_items", cartItems);
        body.put("preview", preview); body.put("order_id", orderId);
        return request("POST", "/api/v1/promotions/tags/" + tagCode + "/calculate/", null, body);
    }

    public Map<String, Object> smartCalculate(String userId, List<Map<String, Object>> cartItems,
                                               String orderId, boolean preview) throws Exception {
        Map<String, Object> body = new HashMap<>();
        body.put("user_id", userId); body.put("cart_items", cartItems);
        body.put("preview", preview); body.put("order_id", orderId);
        return request("POST", "/api/v1/promotions/calculate/smart/", null, body);
    }

    /* ===== 交易类 ===== */
    public Map<String, Object> recordUsage(String traceId, String orderId,
                                           String totalPaid, String status) throws Exception {
        Map<String, Object> body = new HashMap<>();
        body.put("trace_id", traceId); body.put("order_id", orderId);
        body.put("total_paid", totalPaid); body.put("status", status);
        return request("POST", "/api/v1/promotions/usage/", null, body);
    }

    public Map<String, Object> refundCalculate(String traceId,
                                                List<Map<String, Object>> refundItems,
                                                String refundNo) throws Exception {
        Map<String, Object> body = new HashMap<>();
        body.put("trace_id", traceId); body.put("refund_items", refundItems);
        body.put("refund_no", refundNo);
        return request("POST", "/api/v1/refund/calculate/", null, body);
    }

    public Map<String, Object> refundExecute(String traceId,
                                              List<Map<String, Object>> refundItems,
                                              String refundAmount, String refundNo) throws Exception {
        Map<String, Object> body = new HashMap<>();
        body.put("trace_id", traceId); body.put("refund_items", refundItems);
        body.put("refund_amount", refundAmount); body.put("refund_no", refundNo);
        return request("POST", "/api/v1/refund/execute/", null, body);
    }

}

package main

import (
    "bytes"
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "strconv"
    "strings"
    "time"
)

type MyPromotionClient struct {
    BaseURL      string
    AccessKey    string
    AccessSecret string
    client       *http.Client
}

func NewMyPromotionClient(key, secret string) *MyPromotionClient {
    return &MyPromotionClient{
        BaseURL:      "https://api.example.com",
        AccessKey:    key,
        AccessSecret: secret,
        client:       &http.Client{Timeout: 10 * time.Second},
    }
}

func (c *MyPromotionClient) request(method, path string, query map[string]string, body map[string]interface{}) (map[string]interface{}, error) {
    url := c.BaseURL + path
    if len(query) > 0 {
        qs := "?"
        for k, v := range query { qs += k + "=" + v + "&" }
        url += qs
    }
    var bodyReader *bytes.Reader
    if body != nil {
        b, _ := json.Marshal(body)
        bodyReader = bytes.NewReader(b)
    } else {
        bodyReader = bytes.NewReader([]byte{})
    }
    req, _ := http.NewRequest(method, url, bodyReader)
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("X-Access-Key", c.AccessKey)
    req.Header.Set("X-Access-Secret", c.AccessSecret)
    resp, err := c.client.Do(req)
    if err != nil { return nil, err }
    defer resp.Body.Close()
    if resp.StatusCode < 200 || resp.StatusCode >= 300 {
        b, _ := io.ReadAll(resp.Body)
        return nil, fmt.Errorf("HTTP %d: %s", resp.StatusCode, string(b))
    }
    var result map[string]interface{}
    if err := json.NewDecoder(resp.Body).Decode(&result); err != nil { return nil, err }
    return result, nil
}

// ===== 查询类 =====
func (c *MyPromotionClient) HealthCheck() (map[string]interface{}, error) {
    return c.request("GET", "/api/v1/health/", nil, nil)
}

func (c *MyPromotionClient) ListPromotions(page, pageSize int) (map[string]interface{}, error) {
    return c.request("GET", "/api/v1/promotions/", map[string]string{"page": strconv.Itoa(page), "page_size": strconv.Itoa(pageSize)}, nil)
}

func (c *MyPromotionClient) GetPromotionMetadata(promotionCode string) (map[string]interface{}, error) {
    return c.request("GET", "/api/v1/promotions/"+promotionCode+"/metadata/", nil, nil)
}

func (c *MyPromotionClient) GetPromotionDetail(promotionCode string) (map[string]interface{}, error) {
    return c.request("GET", "/api/v1/promotions/"+promotionCode+"/detail/", nil, nil)
}

func (c *MyPromotionClient) ListTags() (map[string]interface{}, error) {
    return c.request("GET", "/api/v1/promotions/tags/", nil, nil)
}

func (c *MyPromotionClient) GetTag(tagCode string) (map[string]interface{}, error) {
    return c.request("GET", "/api/v1/promotions/tags/"+tagCode+"/", nil, nil)
}

func (c *MyPromotionClient) GetTrace(traceID string) (map[string]interface{}, error) {
    return c.request("GET", "/api/v1/traces/"+traceID+"/", nil, nil)
}

// ===== 计算类 =====
func (c *MyPromotionClient) PromoCalculate(userID string, cartItems []map[string]interface{},
    promotionCodes []string, orderID string, preview bool) (map[string]interface{}, error) {
    return c.request("POST", "/api/v1/promotions/calculate/", nil, map[string]interface{}{
        "user_id": userID, "cart_items": cartItems,
        "promotion_codes": promotionCodes,
        "preview": preview, "order_id": orderID,
    })
}

func (c *MyPromotionClient) TagCalculate(tagCode, userID string, cartItems []map[string]interface{},
    orderID string, preview bool) (map[string]interface{}, error) {
    return c.request("POST", "/api/v1/promotions/tags/"+tagCode+"/calculate/", nil, map[string]interface{}{
        "user_id": userID, "cart_items": cartItems,
        "preview": preview, "order_id": orderID,
    })
}

func (c *MyPromotionClient) SmartCalculate(userID string, cartItems []map[string]interface{},
    orderID string, preview bool) (map[string]interface{}, error) {
    return c.request("POST", "/api/v1/promotions/calculate/smart/", nil, map[string]interface{}{
        "user_id": userID, "cart_items": cartItems,
        "preview": preview, "order_id": orderID,
    })
}

// ===== 交易类 =====
func (c *MyPromotionClient) RecordUsage(traceID, orderID, totalPaid, status string) (map[string]interface{}, error) {
    return c.request("POST", "/api/v1/promotions/usage/", nil, map[string]interface{}{
        "trace_id": traceID, "order_id": orderID,
        "total_paid": totalPaid, "status": status,
    })
}

func (c *MyPromotionClient) RefundCalculate(traceID string, refundItems []map[string]interface{},
    refundNo string) (map[string]interface{}, error) {
    return c.request("POST", "/api/v1/refund/calculate/", nil, map[string]interface{}{
        "trace_id": traceID, "refund_items": refundItems, "refund_no": refundNo,
    })
}

func (c *MyPromotionClient) RefundExecute(traceID string, refundItems []map[string]interface{},
    refundAmount, refundNo string) (map[string]interface{}, error) {
    return c.request("POST", "/api/v1/refund/execute/", nil, map[string]interface{}{
        "trace_id": traceID, "refund_items": refundItems,
        "refund_amount": refundAmount, "refund_no": refundNo,
    })
}

}

<?php
class MyPromotionClient {
    private string $baseUrl;
    private string $accessKey;
    private string $accessSecret;

    public function __construct(string $key, string $secret, string $baseUrl = "https://api.example.com") {
        $this->accessKey = $key;
        $this->accessSecret = $secret;
        $this->baseUrl = rtrim($baseUrl, "/");
    }

    private function request(string $method, string $path, array $query = [], array $body = null): array {
        $url = $this->baseUrl . $path;
        if (!empty($query)) $url .= "?" . http_build_query($query);
        $ch = curl_init($url);
        curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
        if ($body !== null) {
            curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($body));
        }
        curl_setopt($ch, CURLOPT_HTTPHEADER, [
            "Content-Type: application/json",
            "X-Access-Key: " . $this->accessKey,
            "X-Access-Secret: " . $this->accessSecret,
        ]);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_TIMEOUT, 10);
        $resp = curl_exec($ch);
        curl_close($ch);
        return json_decode($resp, true);
    }

    /* ===== 查询类 ===== */
    public function healthCheck(): array { return $this->request("GET", "/api/v1/health/"); }

    public function listPromotions(int $page = 1, int $pageSize = 20): array {
        return $this->request("GET", "/api/v1/promotions/", ["page" => $page, "page_size" => $pageSize]);
    }

    public function getPromotionMetadata(string $promotionCode): array {
        return $this->request("GET", "/api/v1/promotions/{$promotionCode}/metadata/");
    }

    public function getPromotionDetail(string $promotionCode): array {
        return $this->request("GET", "/api/v1/promotions/{$promotionCode}/detail/");
    }

    public function listTags(): array { return $this->request("GET", "/api/v1/promotions/tags/"); }

    public function getTag(string $tagCode): array {
        return $this->request("GET", "/api/v1/promotions/tags/{$tagCode}/");
    }

    public function getTrace(string $traceId): array {
        return $this->request("GET", "/api/v1/traces/{$traceId}/");
    }

    /* ===== 计算类 ===== */
    public function promoCalculate(string $userId, array $cartItems, array $promotionCodes,
                                    string $orderId, bool $preview = false): array {
        return $this->request("POST", "/api/v1/promotions/calculate/", [], [
            "user_id" => $userId, "cart_items" => $cartItems,
            "promotion_codes" => $promotionCodes,
            "preview" => $preview, "order_id" => $orderId,
        ]);
    }

    public function tagCalculate(string $tagCode, string $userId, array $cartItems,
                                 string $orderId, bool $preview = false): array {
        return $this->request("POST", "/api/v1/promotions/tags/{$tagCode}/calculate/", [], [
            "user_id" => $userId, "cart_items" => $cartItems,
            "preview" => $preview, "order_id" => $orderId,
        ]);
    }

    public function smartCalculate(string $userId, array $cartItems,
                                   string $orderId, bool $preview = false): array {
        return $this->request("POST", "/api/v1/promotions/calculate/smart/", [], [
            "user_id" => $userId, "cart_items" => $cartItems,
            "preview" => $preview, "order_id" => $orderId,
        ]);
    }

    /* ===== 交易类 ===== */
    public function recordUsage(string $traceId, string $orderId,
                               string $totalPaid, string $status = "completed"): array {
        return $this->request("POST", "/api/v1/promotions/usage/", [], [
            "trace_id" => $traceId, "order_id" => $orderId,
            "total_paid" => $totalPaid, "status" => $status,
        ]);
    }

    public function refundCalculate(string $traceId, array $refundItems, string $refundNo): array {
        return $this->request("POST", "/api/v1/refund/calculate/", [], [
            "trace_id" => $traceId, "refund_items" => $refundItems, "refund_no" => $refundNo,
        ]);
    }

    public function refundExecute(string $traceId, array $refundItems,
                                   string $refundAmount, string $refundNo): array {
        return $this->request("POST", "/api/v1/refund/execute/", [], [
            "trace_id" => $traceId, "refund_items" => $refundItems,
            "refund_amount" => $refundAmount, "refund_no" => $refundNo,
        ]);
    }

}

$client = new MyPromotionClient("your_access_key", "your_access_secret");
$result = $client->promoCalculate(
    "USER001",
    [["sku" => "SKU001", "quantity" => 2, "price" => "100.00"]],
    ["PROMO001"],
    "ORDER_20260504_001"
);
echo $result["meta"]["trace_id"] ?? "no trace";

const axios = require('axios');

class MyPromotionClient {
    constructor(accessKey, accessSecret, baseUrl = 'https://api.example.com') {
        this.baseUrl = baseUrl.replace(/\/$/, '');
        this.headers = {
            'Content-Type': 'application/json',
            'X-Access-Key': accessKey,
            'X-Access-Secret': accessSecret,
        };
    }

    async _request(method, path, params = null, body = null) {
        const url = this.baseUrl + path + (params ? '?' + new URLSearchParams(params).toString() : '');
        const resp = await axios({ method, url, headers: this.headers, data: body, timeout: 10000 });
        return resp.data;
    }

    // ===== 查询类 =====
    async healthCheck() { return this._request('GET', '/api/v1/health/'); }

    async listPromotions(page = 1, pageSize = 20) {
        return this._request('GET', '/api/v1/promotions/', { page, page_size: pageSize });
    }

    async getPromotionMetadata(promotionCode) {
        return this._request('GET', `/api/v1/promotions/${promotionCode}/metadata/`);
    }

    async getPromotionDetail(promotionCode) {
        return this._request('GET', `/api/v1/promotions/${promotionCode}/detail/`);
    }

    async listTags() { return this._request('GET', '/api/v1/promotions/tags/'); }

    async getTag(tagCode) {
        return this._request('GET', `/api/v1/promotions/tags/${tagCode}/`);
    }

    async getTrace(traceId) {
        return this._request('GET', `/api/v1/traces/${traceId}/`);
    }

    // ===== 计算类 =====
    async promoCalculate(userId, cartItems, promotionCodes, orderId, preview = false) {
        return this._request('POST', '/api/v1/promotions/calculate/', null, {
            user_id: userId, cart_items: cartItems,
            promotion_codes: promotionCodes, preview, order_id: orderId,
        });
    }

    async tagCalculate(tagCode, userId, cartItems, orderId, preview = false) {
        return this._request('POST', `/api/v1/promotions/tags/${tagCode}/calculate/`, null, {
            user_id: userId, cart_items: cartItems, preview, order_id: orderId,
        });
    }

    async smartCalculate(userId, cartItems, orderId, preview = false) {
        return this._request('POST', '/api/v1/promotions/calculate/smart/', null, {
            user_id: userId, cart_items: cartItems, preview, order_id: orderId,
        });
    }

    // ===== 交易类 =====
    async recordUsage(traceId, orderId, totalPaid, status = 'completed') {
        return this._request('POST', '/api/v1/promotions/usage/', null, {
            trace_id: traceId, order_id: orderId, total_paid: totalPaid, status,
        });
    }

    async refundCalculate(traceId, refundItems, refundNo) {
        return this._request('POST', '/api/v1/refund/calculate/', null, {
            trace_id: traceId, refund_items: refundItems, refund_no: refundNo,
        });
    }

    async refundExecute(traceId, refundItems, refundAmount, refundNo) {
        return this._request('POST', '/api/v1/refund/execute/', null, {
            trace_id: traceId, refund_items: refundItems,
            refund_amount: refundAmount, refund_no: refundNo,
        });
    }
}

(async () => {
    const client = new MyPromotionClient('your_access_key', 'your_access_secret');
    const result = await client.promoCalculate(
        'USER001',
        [{ sku: 'SKU001', quantity: 2, price: '100.00' }],
        ['PROMO001'],
        'ORDER_20260504_001',
    );
    console.log(result);
})();

curl -X GET "https://api.example.com/api/v1/health/" \
  -H "X-Access-Key: your_access_key" \
  -H "X-Access-Secret: your_access_secret"

curl -X GET "https://api.example.com/api/v1/promotions/?page=1&page_size=20" \
  -H "X-Access-Key: your_access_key" \
  -H "X-Access-Secret: your_access_secret"

curl -X GET "https://api.example.com/api/v1/promotions/PROMO001/metadata/" \
  -H "X-Access-Key: your_access_key" \
  -H "X-Access-Secret: your_access_secret"

curl -X GET "https://api.example.com/api/v1/promotions/PROMO001/detail/" \
  -H "X-Access-Key: your_access_key" \
  -H "X-Access-Secret: your_access_secret"

curl -X GET "https://api.example.com/api/v1/promotions/tags/" \
  -H "X-Access-Key: your_access_key" \
  -H "X-Access-Secret: your_access_secret"

curl -X GET "https://api.example.com/api/v1/promotions/tags/TAG001/" \
  -H "X-Access-Key: your_access_key" \
  -H "X-Access-Secret: your_access_secret"

curl -X POST "https://api.example.com/api/v1/promotions/calculate/" \
  -H "Content-Type: application/json" \
  -H "X-Access-Key: your_access_key" \
  -H "X-Access-Secret: your_access_secret" \
  -d '{
    "user_id": "USER001",
    "cart_items": [
      {"sku": "SKU001", "quantity": 2, "price": "100.00"}
    ],
    "promotion_codes": ["PROMO001"],
    "preview": false,
    "order_id": "ORDER_20260504_001"
  }'

curl -X POST "https://api.example.com/api/v1/promotions/tags/TAG001/calculate/" \
  -H "Content-Type: application/json" \
  -H "X-Access-Key: your_access_key" \
  -H "X-Access-Secret: your_access_secret" \
  -d '{
    "user_id": "USER001",
    "cart_items": [
      {"sku": "SKU001", "quantity": 2, "price": "100.00"}
    ],
    "preview": false,
    "order_id": "ORDER_20260504_001"
  }'

curl -X POST "https://api.example.com/api/v1/promotions/calculate/smart/" \
  -H "Content-Type: application/json" \
  -H "X-Access-Key: your_access_key" \
  -H "X-Access-Secret: your_access_secret" \
  -d '{
    "user_id": "USER001",
    "cart_items": [
      {"sku": "SKU001", "quantity": 2, "price": "100.00"}
    ],
    "preview": false,
    "order_id": "ORDER_20260504_001"
  }'

curl -X POST "https://api.example.com/api/v1/promotions/usage/" \
  -H "Content-Type: application/json" \
  -H "X-Access-Key: your_access_key" \
  -H "X-Access-Secret: your_access_secret" \
  -d '{
    "trace_id": "trace-xxx",
    "order_id": "ORDER_20260504_001",
    "total_paid": "170.00",
    "status": "completed"
  }'

curl -X GET "https://api.example.com/api/v1/traces/trace-xxx/" \
  -H "X-Access-Key: your_access_key" \
  -H "X-Access-Secret: your_access_secret"

curl -X POST "https://api.example.com/api/v1/refund/calculate/" \
  -H "Content-Type: application/json" \
  -H "X-Access-Key: your_access_key" \
  -H "X-Access-Secret: your_access_secret" \
  -d '{
    "trace_id": "trace-xxx",
    "refund_items": [
      {"sku": "SKU001", "quantity": 1}
    ],
    "refund_no": "REF_20260504_001"
  }'

curl -X POST "https://api.example.com/api/v1/refund/execute/" \
  -H "Content-Type: application/json" \
  -H "X-Access-Key: your_access_key" \
  -H "X-Access-Secret: your_access_secret" \
  -d '{
    "trace_id": "trace-xxx",
    "refund_items": [
      {"sku": "SKU001", "quantity": 1}
    ],
    "refund_amount": "30.00",
    "refund_no": "REF_20260504_001"
  }'

import com.fasterxml.jackson.databind.ObjectMapper;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.io.*;
import java.net.*;
import java.nio.charset.StandardCharsets;

public class MyPromotionClient {
    private final String baseUrl;
    private final String accessSecret;
    private final ObjectMapper mapper = new ObjectMapper();

    public MyPromotionClient(String accessSecret, String baseUrl) {
        this.accessSecret = accessSecret;
        this.baseUrl = baseUrl.replaceAll("/+$", "");
    }

    public MyPromotionClient(String accessSecret) {
        this(accessSecret, "https://api.example.com");
    }

    private String sign(String payload, String ts) throws Exception {
        Mac mac = Mac.getInstance("HmacSHA256");
        mac.init(new SecretKeySpec(accessSecret.getBytes(StandardCharsets.UTF_8), "HmacSHA256"));
        byte[] b = mac.doFinal((ts + "." + payload).getBytes(StandardCharsets.UTF_8));
        StringBuilder sb = new StringBuilder();
        for (byte c : b) sb.append(String.format("%02x", c));
        return sb.toString();
    }

    public String sendWebhook(String dataType, String configKey, Object payloadDict) throws Exception {
        String url = baseUrl + "/webhook/v1/" + dataType + "/" + configKey + "/";
        String payload = mapper.writeValueAsString(payloadDict);
        String ts = String.valueOf(System.currentTimeMillis() / 1000);
        String sig = sign(payload, ts);
        HttpURLConnection conn = (HttpURLConnection) new URL(url).openConnection();
        conn.setRequestMethod("POST");
        conn.setRequestProperty("Content-Type", "application/json");
        conn.setRequestProperty("X-Webhook-Signature", sig);
        conn.setRequestProperty("X-Webhook-Timestamp", ts);
        conn.setDoOutput(true);
        try (OutputStream os = conn.getOutputStream()) {
            os.write(payload.getBytes(StandardCharsets.UTF_8));
        }
        int code = conn.getResponseCode();
        InputStream stream = (code >= 200 && code < 300) ? conn.getInputStream() : conn.getErrorStream();
        BufferedReader in = new BufferedReader(new InputStreamReader(stream, StandardCharsets.UTF_8));
        StringBuilder sb = new StringBuilder();
        String line;
        while ((line = in.readLine()) != null) sb.append(line);
        in.close();
        if (code < 200 || code >= 300) { throw new RuntimeException("HTTP " + code + ": " + sb); }
        return sb.toString();
    }

    public static void main(String[] args) throws Exception {
        MyPromotionClient client = new MyPromotionClient("your_webhook_secret_key");
        String result = client.sendWebhook(
            "product", "your_config_key",
            java.util.Collections.singletonMap("action", "modify")
        );
        System.out.println(result);
    }
}

package main

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "strings"
    "time"
)

type MyPromotionClient struct {
    BaseURL      string
    AccessSecret string
    client       *http.Client
}

func NewMyPromotionClient(secret string) *MyPromotionClient {
    return &MyPromotionClient{
        BaseURL:      "https://api.example.com",
        AccessSecret: secret,
        client:       http.DefaultClient,
    }
}

func (c *MyPromotionClient) sign(payload, ts string) string {
    mac := hmac.New(sha256.New, []byte(c.AccessSecret))
    mac.Write([]byte(ts + "." + payload))
    return hex.EncodeToString(mac.Sum(nil))
}

func (c *MyPromotionClient) SendWebhook(dataType, configKey string, payloadDict map[string]interface{}) (map[string]interface{}, error) {
    url := fmt.Sprintf("%s/webhook/v1/%s/%s/", c.BaseURL, dataType, configKey)
    payloadBytes, _ := json.Marshal(payloadDict)
    payload := string(payloadBytes)
    ts := fmt.Sprintf("%d", time.Now().Unix())
    sig := c.sign(payload, ts)
    req, _ := http.NewRequest("POST", url, strings.NewReader(payload))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("X-Webhook-Signature", sig)
    req.Header.Set("X-Webhook-Timestamp", ts)
    resp, err := c.client.Do(req)
    if err != nil { return nil, err }
    defer resp.Body.Close()
    if resp.StatusCode < 200 || resp.StatusCode >= 300 {
        b, _ := io.ReadAll(resp.Body)
        return nil, fmt.Errorf("HTTP %d: %s", resp.StatusCode, string(b))
    }
    var result map[string]interface{}
    if err := json.NewDecoder(resp.Body).Decode(&result); err != nil { return nil, err }
    return result, nil
}

func main() {
    client := NewMyPromotionClient("your_webhook_secret_key")
    result, err := client.SendWebhook("product", "your_key", map[string]interface{}{
        "action": "modify",
        "items": []map[string]interface{}{{"outer_id": "SKU001"}},
    })
    if err != nil { panic(err) }
    fmt.Println(result)
}

<?php
class MyPromotionClient {
    private string $baseUrl = "https://api.example.com";
    private string $accessSecret;

    public function __construct(string $secret) {
        $this->accessSecret = $secret;
    }

    private function sign(string $payload, string $ts): string {
        return hash_hmac('sha256', $ts . "." . $payload, $this->accessSecret);
    }

    public function sendWebhook(string $dataType, string $configKey, array $payloadDict): string {
        $url = $this->baseUrl . "/webhook/v1/{$dataType}/{$configKey}/";
        $payload = json_encode($payloadDict);
        $ts = (string)time();
        $sig = $this->sign($payload, $ts);

        $ch = curl_init($url);
        curl_setopt($ch, CURLOPT_POST, true);
        curl_setopt($ch, CURLOPT_POSTFIELDS, $payload);
        curl_setopt($ch, CURLOPT_HTTPHEADER, [
            "Content-Type: application/json",
            "X-Webhook-Signature: " . $sig,
            "X-Webhook-Timestamp: " . $ts,
        ]);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        $result = curl_exec($ch);
        curl_close($ch);
        return $result;
    }
}

$client = new MyPromotionClient("your_webhook_secret_key");
$result = $client->sendWebhook(
    "product",
    "your_key",
    ["action" => "modify", "items" => [["outer_id" => "SKU001"]]]
);
echo $result;

const crypto = require('crypto');

class MyPromotionClient {
    constructor(accessSecret, baseUrl = 'https://api.example.com') {
        this.baseUrl = baseUrl;
        this.accessSecret = accessSecret;
    }

    sign(payload, ts) {
        return crypto.createHmac('sha256', this.accessSecret)
            .update(`${ts}.${payload}`)
            .digest('hex');
    }

    async sendWebhook(dataType, configKey, payloadDict) {
        const payload = JSON.stringify(payloadDict);
        const ts = Math.floor(Date.now() / 1000).toString();
        const signature = this.sign(payload, ts);

        const resp = await fetch(`${this.baseUrl}/webhook/v1/${dataType}/${configKey}/`, {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'X-Webhook-Signature': signature,
                'X-Webhook-Timestamp': ts,
            },
            body: payload,
        });
        return resp.json();
    }
}

const client = new MyPromotionClient('your_webhook_secret_key');
client.sendWebhook('product', 'your_config_key', {
    action: 'modify',
    items: [{ outer_id: 'SKU001', name: '商品1' }],
}).then(console.log);

# 签名字符串：{timestamp}.{json_payload}
# 算法：HMAC-SHA256，密钥：your_webhook_secret_key
# 输出：hex 编码的签名值

curl -X POST "https://api.example.com/webhook/v1/{data_type}/{config_key}/" \
  -H "Content-Type: application/json" \
  -H "X-Webhook-Signature: a1b2c3d4e5f6..." \
  -H "X-Webhook-Timestamp: 1710423456" \
  -d '{"action":"modify","items":[{"outer_id":"SKU001","name":"商品1"}]}'