비가시성 워터마크 검출

ORDER_IDEMPOTENCY_KEY=$(uuidgen | tr '[:upper:]' '[:lower:]')
curl -X POST https://api.bizmori.com/api/v3/orders/wtr-extract \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "idempotencyKey": "'$ORDER_IDEMPOTENCY_KEY'",
    "file": {
      "fileName": "suspect.png",
      "originalFile": { "fileName": "campaign.png" }
    }
  }'

import { randomUUID } from 'node:crypto';

const API_BASE = 'https://api.bizmori.com/api/v3';
const headers = { Authorization: 'Bearer YOUR_API_KEY' };

const response = await fetch(`${API_BASE}/orders/wtr-extract`, {
  method: 'POST',
  headers: { ...headers, 'Content-Type': 'application/json' },
  body: JSON.stringify({
    idempotencyKey: randomUUID(),
    file: {
      fileName: 'suspect.png',
      originalFile: { fileName: 'campaign.png' },
    },
  }),
});
const { data: order } = await response.json();

// JSON을 사용하는 모든 호출에 쓰는 헬퍼 함수 하나입니다. API는 실패 시
// `{ code: "ERROR_CODE" }`를 반환하므로, 단순 상태 코드 대신 이 code를 노출합니다.
const API_BASE = 'https://api.bizmori.com/api/v3';
const API_KEY = import.meta.env.VITE_MORI_API_KEY;

async function api(path, { method = 'GET', body, idempotencyKey } = {}) {
  const res = await fetch(`${API_BASE}${path}`, {
    method,
    headers: {
      Authorization: `Bearer ${API_KEY}`,
      ...(body && { 'Content-Type': 'application/json' }),
    },
    body: body && JSON.stringify({ idempotencyKey, ...body }),
  });

  if (!res.ok) {
    const { code } = await res.json().catch(() => ({}));
    throw new Error(code ?? `HTTP_${res.status}`);
  }
  return (await res.json()).data;
}

// `originalFile`과 `checkedFile`은 사용자가 선택한 두 File입니다
const order = await api('/orders/wtr-extract', {
  method: 'POST',
  idempotencyKey: crypto.randomUUID(),
  body: {
    file: {
      fileName: checkedFile.name,
      originalFile: { fileName: originalFile.name },
    },
  },
});

import uuid
import requests

API_BASE = 'https://api.bizmori.com/api/v3'
HEADERS = {'Authorization': 'Bearer YOUR_API_KEY'}

res = requests.post(
    f'{API_BASE}/orders/wtr-extract',
    headers=HEADERS,
    json={
        'idempotencyKey': str(uuid.uuid4()),
        'file': {
            'fileName': 'suspect.png',
            'originalFile': {'fileName': 'campaign.png'},
        },
    },
)
order = res.json()['data']

# files[0]: 원본 파일
curl -X PUT "https://s3.ap-northeast-2.amazonaws.com/...original..." \
  -H "Content-Type: image/png" \
  --data-binary @campaign.png

# files[1]: 검사할 파일
curl -X PUT "https://s3.ap-northeast-2.amazonaws.com/...checked..." \
  -H "Content-Type: image/png" \
  --data-binary @suspect.png

import { readFile } from 'node:fs/promises';

async function putFile(uploadUrl, path, contentType) {
  const res = await fetch(uploadUrl, {
    method: 'PUT',
    headers: { 'Content-Type': contentType },
    body: await readFile(path),
  });
  if (!res.ok) throw new Error(`UPLOAD_FAILED_${res.status}`);
}

await putFile(order.files[0].uploadUrl, 'campaign.png', 'image/png'); // 원본
await putFile(order.files[1].uploadUrl, 'suspect.png', 'image/png'); // 검사할 파일

// 프리사인드 URL은 파일 확장자에 맞는 타입으로 서명되어 있으므로,
// `file.type` 대신 파일 이름에서 Content-Type을 정합니다.
const CONTENT_TYPES = {
  jpg: 'image/jpeg', jpeg: 'image/jpeg', png: 'image/png', webp: 'image/webp',
  bmp: 'image/bmp', tif: 'image/tiff', tiff: 'image/tiff', pdf: 'application/pdf',
};
const contentTypeOf = (name) => CONTENT_TYPES[name.split('.').pop().toLowerCase()];

// fetch()는 업로드 진행률을 알려줄 수 없으므로, PUT에는 XMLHttpRequest를 사용합니다.
function putFile(file, uploadUrl, onProgress) {
  return new Promise((resolve, reject) => {
    const xhr = new XMLHttpRequest();
    xhr.open('PUT', uploadUrl);
    xhr.setRequestHeader('Content-Type', contentTypeOf(file.name));

    xhr.upload.onprogress = (event) => {
      if (event.lengthComputable) onProgress(event.loaded / event.total);
    };
    xhr.onload = () =>
      xhr.status < 300 ? resolve() : reject(new Error(`UPLOAD_FAILED_${xhr.status}`));
    xhr.onerror = () => reject(new Error('UPLOAD_NETWORK_ERROR'));

    xhr.send(file);
  });
}

// files[0]은 원본, files[1]은 검사할 파일입니다.
await Promise.all([
  putFile(originalFile, order.files[0].uploadUrl, () => {}),
  putFile(checkedFile, order.files[1].uploadUrl, (ratio) => setProgress(ratio)),
]);

def put_file(upload_url, path, content_type):
    with open(path, 'rb') as f:
        res = requests.put(upload_url, headers={'Content-Type': content_type}, data=f)
    res.raise_for_status()

put_file(order['files'][0]['uploadUrl'], 'campaign.png', 'image/png')  # 원본
put_file(order['files'][1]['uploadUrl'], 'suspect.png', 'image/png')   # 검사할 파일

curl https://api.bizmori.com/api/v3/orders/1234567891 \
  -H "Authorization: Bearer YOUR_API_KEY"

const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

async function waitForOrder(orderId) {
  for (let delay = 2000; ; delay = Math.min(delay * 1.5, 15000)) {
    const res = await fetch(`${API_BASE}/orders/${orderId}`, { headers });
    const { data } = await res.json();
    if (['complete', 'failed', 'expired'].includes(data.status)) return data;
    await sleep(delay);
  }
}

const finished = await waitForOrder(order.orderId);
console.log(finished.result?.detectionStatus, finished.result?.watermarkText);

const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

// 대기 시간이 길어질수록 폴링 간격도 늘립니다: 빠른 응답은 빠르게 유지하고,
// 오래 걸리는 작업이 API를 계속 두드리지 않도록 합니다. 무한정 폴링하지 않고 10분 후 포기합니다.
// 폴링은 `status`로 판단하고, 검출 결과는 `result`에서 읽습니다.
async function pollOrder(orderId, { onStatus, timeoutMs = 10 * 60 * 1000 } = {}) {
  const deadline = Date.now() + timeoutMs;
  let delay = 2000;

  while (Date.now() < deadline) {
    const order = await api(`/orders/${orderId}`);
    onStatus?.(order.status);
    if (['complete', 'failed', 'expired'].includes(order.status)) return order;

    await sleep(delay);
    delay = Math.min(delay * 1.5, 15000);
  }
  throw new Error('ORDER_POLL_TIMEOUT');
}

import time

def wait_for_order(order_id):
    delay = 2
    while True:
        res = requests.get(f'{API_BASE}/orders/{order_id}', headers=HEADERS)
        data = res.json()['data']
        if data['status'] in ('complete', 'failed', 'expired'):
            return data
        time.sleep(delay)
        delay = min(delay * 1.5, 15)

finished = wait_for_order(order['orderId'])

curl -X POST https://api.bizmori.com/api/v3/orders/1234567891/reports \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "locale": "ko-KR" }'

curl https://api.bizmori.com/api/v3/orders/1234567891/reports/ko-KR \
  -H "Authorization: Bearer YOUR_API_KEY"

async function createReport(orderId, locale) {
  const created = await fetch(`${API_BASE}/orders/${orderId}/reports`, {
    method: 'POST',
    headers: { ...headers, 'Content-Type': 'application/json' },
    body: JSON.stringify({ locale }),
  });
  if (!created.ok) throw new Error((await created.json()).code);

  for (let delay = 2000; ; delay = Math.min(delay * 1.5, 15000)) {
    const res = await fetch(`${API_BASE}/orders/${orderId}/reports/${locale}`, { headers });
    const { data: report } = await res.json();
    if (report.status === 'completed') return report.download.url;
    if (report.status === 'failed') throw new Error(report.failure.code);
    await sleep(delay);
  }
}

const reportUrl = await createReport(order.orderId, 'ko-KR');

// 보고서 URL은 300초 뒤 만료됩니다. 사용자가 다운로드를 누를 때마다
// GET 엔드포인트를 다시 호출해 받은 새 URL로 이동하세요.
async function openReport(orderId, locale) {
  await api(`/orders/${orderId}/reports`, { method: 'POST', body: { locale } });

  for (let delay = 2000; ; delay = Math.min(delay * 1.5, 15000)) {
    const report = await api(`/orders/${orderId}/reports/${locale}`);
    if (report.status === 'completed') return window.location.assign(report.download.url);
    if (report.status === 'failed') throw new Error(report.failure.code);
    await sleep(delay);
  }
}

def create_report(order_id, locale):
    created = requests.post(
        f'{API_BASE}/orders/{order_id}/reports',
        headers=HEADERS,
        json={'locale': locale},
    )
    if not created.ok:
        raise RuntimeError(created.json()['code'])
    delay = 2
    while True:
        res = requests.get(f'{API_BASE}/orders/{order_id}/reports/{locale}', headers=HEADERS)
        report = res.json()['data']
        if report['status'] == 'completed':
            return report['download']['url']
        if report['status'] == 'failed':
            raise RuntimeError(report['failure']['code'])
        time.sleep(delay)
        delay = min(delay * 1.5, 15)

report_url = create_report(order['orderId'], 'ko-KR')