同步提交图片翻译任务

# -*- coding: utf-8 -*-
import requests
import hmac
import hashlib
import base64
import datetime
import json
import os
import mimetypes

# 配置
API_ENDPOINT = "https://******/submit_task_sync"
ACCOUNT_ID = "pic_YOUR_ID"      # 替换为你的 AccountId
SECRET_KEY = "YOUR_SECRET_KEY"  # 替换为你的 SecretKey

def generate_signature(params, secret_key):
    """生成 API 请求签名"""
    sorted_params = sorted(params.items())
    param_string = "&".join(f"{k}={v}" for k, v in sorted_params if v is not None and v != '')
    sign_string = f"{param_string}&SecretKey={secret_key}"
    signature = hmac.new(secret_key.encode('utf-8'), sign_string.encode('utf-8'), hashlib.sha256).digest()
    return base64.b64encode(signature).decode('utf-8')

def read_image_as_base64(file_path):
    """读取图片并转为 Base64"""
    if not os.path.exists(file_path): return None
    mime_type, _ = mimetypes.guess_type(file_path)
    if not mime_type: mime_type = 'application/octet-stream'

    with open(file_path, "rb") as f:
        base64_data = base64.b64encode(f.read()).decode('utf-8')
    return f"data:{mime_type};base64,{base64_data}"

def translate_single_image(image_path):
    img_base64 = read_image_as_base64(image_path)
    if not img_base64: return

    # 准备参数 (注意使用 CST/UTC+8 时间戳)
    cst = datetime.timezone(datetime.timedelta(hours=8))
    timestamp = str(int(datetime.datetime.now(cst).timestamp()))

    params = {
        "AccountId": ACCOUNT_ID,
        "SourceLanguage": "zh",
        "TargetLanguage": "pt",
        "Timestamp": timestamp,
        "ImageBase64": img_base64,
        "OutputFormat": "png",
    }

    params["Signature"] = generate_signature(params, SECRET_KEY)

    try:
        resp = requests.post(API_ENDPOINT, json=params, timeout=60)
        print(json.dumps(resp.json(), indent=2, ensure_ascii=False))
    except Exception as e:
        print(f"Error: {e}")

if __name__ == "__main__":
    translate_single_image("test.jpg")

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.time.Instant;
import java.time.ZoneId;
import java.util.*;
import java.util.stream.Collectors;

public class PicTechSyncDemo {
    private static final String API_URL = "https://******/submit_task_sync";
    private static final String ACCOUNT_ID = "pic_YOUR_ID";
    private static final String SECRET_KEY = "YOUR_SECRET_KEY";

    public static void main(String[] args) throws Exception {
        String imagePath = "test.jpg";

        // 1. 准备参数
        Map<String, String> params = new TreeMap<>(); // TreeMap 自动按 Key 排序
        params.put("AccountId", ACCOUNT_ID);
        params.put("SourceLanguage", "zh");
        params.put("TargetLanguage", "pt");
        // 获取 CST (UTC+8) 时间戳
        long cstTimestamp = Instant.now().atZone(ZoneId.of("Asia/Shanghai")).toEpochSecond();
        params.put("Timestamp", String.valueOf(cstTimestamp));
        params.put("ImageBase64", readFileAsBase64(imagePath));
        params.put("OutputFormat", "png");

        // 2. 生成签名
        String signature = generateSignature(params, SECRET_KEY);
        params.put("Signature", signature);

        // 3. 发送请求 (构建 JSON)
        String jsonBody = buildJson(params);
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(API_URL))
                .header("Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(jsonBody))
                .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println("Result: " + response.body());
    }

    private static String generateSignature(Map<String, String> params, String secret) throws Exception {
        String strToSign = params.entrySet().stream()
                .filter(e -> e.getValue() != null && !e.getValue().isEmpty())
                .map(e -> e.getKey() + "=" + e.getValue())
                .collect(Collectors.joining("&")) + "&SecretKey=" + secret;

        Mac hmacSha256 = Mac.getInstance("HmacSHA256");
        hmacSha256.init(new SecretKeySpec(secret.getBytes(StandardCharsets.UTF_8), "HmacSHA256"));
        return Base64.getEncoder().encodeToString(hmacSha256.doFinal(strToSign.getBytes(StandardCharsets.UTF_8)));
    }

    private static String readFileAsBase64(String path) throws IOException {
        byte[] bytes = Files.readAllBytes(Path.of(path));
        String mime = path.toLowerCase().endsWith(".png") ? "image/png" : "image/jpeg";
        return "data:" + mime + ";base64," + Base64.getEncoder().encodeToString(bytes);
    }

    private static String buildJson(Map<String, String> params) {
        // 简单 JSON 构建，生产环境建议使用 Jackson 或 Gson
        StringBuilder sb = new StringBuilder("{");
        for (Map.Entry<String, String> entry : params.entrySet()) {
            sb.append(""").append(entry.getKey()).append("":"")
              .append(entry.getValue().replace(""", "\"")).append("",");
        }
        if (sb.length() > 1) sb.deleteCharAt(sb.length() - 1);
        sb.append("}");
        return sb.toString();
    }
}

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

public class Program
{
    static readonly string ApiUrl = "https://******/submit_task_sync";
    static readonly string AccountId = "pic_YOUR_ID";
    static readonly string SecretKey = "YOUR_SECRET_KEY";

    public static async Task Main()
    {
        var paramsDict = new SortedDictionary<string, string>(StringComparer.Ordinal)
        {
            { "AccountId", AccountId },
            { "SourceLanguage", "zh" },
            { "TargetLanguage", "pt" },
            // 获取 UTC+8 时间戳
            { "Timestamp", DateTimeOffset.UtcNow.ToOffset(TimeSpan.FromHours(8)).ToUnixTimeSeconds().ToString() },
            { "ImageBase64", GetImageBase64("test.jpg") },
            { "OutputFormat", "png" }
        };

        // 计算签名
        string paramString = string.Join("&", paramsDict.Where(p => !string.IsNullOrEmpty(p.Value)).Select(p => $"{p.Key}={p.Value}"));
        string signString = $"{paramString}&SecretKey={SecretKey}";
        using var hmac = new HMACSHA256(Encoding.UTF8.GetBytes(SecretKey));
        paramsDict.Add("Signature", Convert.ToBase64String(hmac.ComputeHash(Encoding.UTF8.GetBytes(signString))));

        // 发送请求
        using var client = new HttpClient();
        var content = new StringContent(JsonSerializer.Serialize(paramsDict), Encoding.UTF8, "application/json");
        var response = await client.PostAsync(ApiUrl, content);
        Console.WriteLine(await response.Content.ReadAsStringAsync());
    }

    static string GetImageBase64(string path)
    {
        if (!File.Exists(path)) return "";
        byte[] bytes = File.ReadAllBytes(path);
        string mime = Path.GetExtension(path).ToLower() == ".png" ? "image/png" : "image/jpeg";
        return $"data:{mime};base64,{Convert.ToBase64String(bytes)}";
    }
}

const axios = require('axios'); // npm install axios
const crypto = require('crypto');
const fs = require('fs');
const path = require('path');

const CONFIG = {
    url: 'https://******/submit_task_sync',
    accountId: 'pic_YOUR_ID',
    secretKey: 'YOUR_SECRET_KEY'
};

async function submitSyncTask() {
    const filePath = './test.jpg';

    // 1. 读取 Base64
    const bitmap = fs.readFileSync(filePath);
    const mime = path.extname(filePath) === '.png' ? 'image/png' : 'image/jpeg';
    const base64 = `data:${mime};base64,${Buffer.from(bitmap).toString('base64')}`;

    // 2. 准备参数
    // 获取当前秒级时间戳 (近似处理，严格建议使用 moment-timezone 转 Asia/Shanghai)
    const timestamp = Math.floor(Date.now() / 1000).toString();

    const params = {
        AccountId: CONFIG.accountId,
        SourceLanguage: 'zh',
        TargetLanguage: 'pt',
        Timestamp: timestamp,
        ImageBase64: base64,
        OutputFormat: 'png'
    };

    // 3. 计算签名
    const keys = Object.keys(params).sort();
    const signStr = keys.map(k => `${k}=${params[k]}`).join('&') + `&SecretKey=${CONFIG.secretKey}`;
    params.Signature = crypto.createHmac('sha256', CONFIG.secretKey).update(signStr).digest('base64');

    // 4. 发送请求
    try {
        const res = await axios.post(CONFIG.url, params);
        console.log('API Response:', JSON.stringify(res.data, null, 2));
    } catch (err) {
        console.error('Error:', err.message);
    }
}

submitSyncTask();