import requests

BASE = "https://importer.synder.com/api/v1"
headers = {"Authorization": "Bearer YOUR_API_TOKEN"}

resp = requests.get(f"{BASE}/account", headers=headers)
print(resp.json())

const BASE = "https://importer.synder.com/api/v1";
const headers = { "Authorization": "Bearer YOUR_API_TOKEN" };

const resp = await fetch(`${BASE}/account`, { headers });
const data = await resp.json();
console.log(data);

companies = requests.get(f"{BASE}/companies", headers=headers).json()
company_id = companies[0]["id"]

const companies = await fetch(`${BASE}/companies`, { headers }).then(r => r.json());
const companyId = companies[0].id;

fields = requests.get(
    f"{BASE}/companies/{company_id}/entities/Invoice/fields",
    headers=headers
).json()

required = [f for f in fields if f["isRequired"]]
print(f"Required fields: {[f['title'] for f in required]}")

const fields = await fetch(
  `${BASE}/companies/${companyId}/entities/Invoice/fields`,
  { headers }
).then(r => r.json());

const required = fields.filter(f => f.isRequired);
console.log("Required:", required.map(f => f.title));

mapping = requests.post(
    f"{BASE}/companies/{company_id}/mappings",
    headers={**headers, "Content-Type": "application/json"},
    json={
        "title": "My Invoice Mapping",
        "entityName": "Invoice",
        "fields": [
            {"sourceFieldTitle": "Invoice #",  "targetFieldId": "231"},
            {"sourceFieldTitle": "Customer",   "targetFieldId": "176"},
            {"sourceFieldTitle": "Date",       "targetFieldId": "179"},
            {"sourceFieldTitle": "Item",       "targetFieldId": "232"},
            {"sourceFieldTitle": "Amount",     "targetFieldId": "237"},
            {"sourceFieldTitle": None, "targetFieldId": "234",
             "fixedValue": "Imported via API"}
        ]
    }
).json()

mapping_id = mapping["id"]

const mapping = await fetch(`${BASE}/companies/${companyId}/mappings`, {
  method: "POST",
  headers: { ...headers, "Content-Type": "application/json" },
  body: JSON.stringify({
    title: "My Invoice Mapping",
    entityName: "Invoice",
    fields: [
      { sourceFieldTitle: "Invoice #",  targetFieldId: "231" },
      { sourceFieldTitle: "Customer",   targetFieldId: "176" },
      { sourceFieldTitle: "Date",       targetFieldId: "179" },
      { sourceFieldTitle: "Item",       targetFieldId: "232" },
      { sourceFieldTitle: "Amount",     targetFieldId: "237" },
      { sourceFieldTitle: null, targetFieldId: "234",
        fixedValue: "Imported via API" }
    ]
  })
}).then(r => r.json());

const mappingId = mapping.id;

import uuid

resp = requests.post(
    f"{BASE}/companies/{company_id}/imports",
    headers={**headers, "Idempotency-Key": str(uuid.uuid4())},
    files={"file": open("invoices.csv", "rb")},
    data={"mappingId": mapping_id}
).json()

import_id = resp["id"]
print(f"Import {import_id} — Status: {resp['status']}")

const form = new FormData();
form.append("file", fs.createReadStream("invoices.csv"));
form.append("mappingId", mappingId);

const imp = await fetch(`${BASE}/companies/${companyId}/imports`, {
  method: "POST",
  headers: { ...headers, "Idempotency-Key": crypto.randomUUID() },
  body: form
}).then(r => r.json());

const importId = imp.id;
console.log(`Import ${importId} — Status: ${imp.status}`);

import time

terminal = {"FINISHED", "FINISHED_WITH_WARNINGS", "FAILED", "CANCELED"}
delay = 2

while True:
    status = requests.get(
        f"{BASE}/companies/{company_id}/imports/{import_id}",
        headers=headers
    ).json()
    print(f"Status: {status['status']} — {status.get('summary', {})}")

    if status["status"] in terminal:
        break

    time.sleep(delay)
    delay = min(delay * 1.5, 30)  # Exponential backoff, cap 30s

const terminal = new Set(["FINISHED","FINISHED_WITH_WARNINGS","FAILED","CANCELED"]);
let delay = 2000;
let status;

do {
  await new Promise(r => setTimeout(r, delay));
  status = await fetch(
    `${BASE}/companies/${companyId}/imports/${importId}`,
    { headers }
  ).then(r => r.json());

  console.log(`Status: ${status.status}`, status.summary);
  delay = Math.min(delay * 1.5, 30000);
} while (!terminal.has(status.status));

results = requests.get(
    f"{BASE}/companies/{company_id}/imports/{import_id}/results",
    headers=headers,
    params={"type": "ERROR"}
).json()

for row in results["data"]:
    print(f"Row {row['orderNumber']}: {row['text']}")

const results = await fetch(
  `${BASE}/companies/${companyId}/imports/${importId}/results?type=ERROR`,
  { headers }
).then(r => r.json());

results.data.forEach(r =>
  console.log(`Row ${r.orderNumber}: ${r.text}`)
);

auto = requests.post(
    f"{BASE}/companies/{company_id}/imports/auto",
    headers=headers,
    files={"file": open("invoices.csv", "rb")},
    data={"entityName": "Invoice", "dryRun": "true"}
).json()

print(f"Matched {auto['totalFieldsMapped']}/{auto['totalEntityFields']} fields")
for f in auto["proposedFields"]:
    print(f"  {f['sourceFieldTitle']} → {f['targetFieldName']}")

/**
 * Import invoices into QuickBooks via Synder Importer API.
 * Run: node import.mjs (Node 18+)
 */
import fs from "fs";
import crypto from "crypto";

const BASE = "https://importer.synder.com/api/v1";
const TOKEN = "YOUR_API_TOKEN";
const headers = { Authorization: `Bearer ${TOKEN}` };

async function api(path, opts = {}) {
  const res = await fetch(`${BASE}${path}`, { headers, ...opts });
  if (!res.ok) {
    const err = await res.json();
    throw new Error(`${res.status}: ${err.error?.message || JSON.stringify(err)}`);
  }
  return res.json();
}

// 1. Get your company
const companies = await api("/companies");
const company = companies.find(c => c.status === "ACTIVE");
const cid = company.id;
console.log(`Using company: ${company.companyName} (${company.provider})`);

// 2. List required fields for Invoice
const fields = await api(`/companies/${cid}/entities/Invoice/fields`);
const required = fields.filter(f => f.isRequired);
console.log("Required fields:", required.map(f => f.title));

// 3. Create a mapping
const mapping = await api(`/companies/${cid}/mappings`, {
  method: "POST",
  headers: { ...headers, "Content-Type": "application/json" },
  body: JSON.stringify({
    title: "Invoice Import",
    entityName: "Invoice",
    fields: [
      { sourceFieldTitle: "Invoice #",  targetFieldId: "231" },
      { sourceFieldTitle: "Customer",   targetFieldId: "176" },
      { sourceFieldTitle: "Date",       targetFieldId: "179" },
      { sourceFieldTitle: "Item",       targetFieldId: "232" },
      { sourceFieldTitle: "Amount",     targetFieldId: "237" },
    ]
  })
});
console.log(`Mapping created: ${mapping.id}`);

// 4. Upload file & start import
const form = new FormData();
form.append("file", new Blob([fs.readFileSync("invoices.csv")]));
form.append("mappingId", mapping.id);

const imp = await fetch(`${BASE}/companies/${cid}/imports`, {
  method: "POST",
  headers: { ...headers, "Idempotency-Key": crypto.randomUUID() },
  body: form
}).then(r => r.json());
console.log(`Import ${imp.id} started — status: ${imp.status}`);

// 5. Poll until done
const terminal = new Set(["FINISHED","FINISHED_WITH_WARNINGS","FAILED","CANCELED"]);
let delay = 2000;
let status;
do {
  await new Promise(r => setTimeout(r, delay));
  status = await api(`/companies/${cid}/imports/${imp.id}`);
  console.log(`  Status: ${status.status}`);
  delay = Math.min(delay * 1.5, 30000);
} while (!terminal.has(status.status));

// 6. Show results
const results = await api(`/companies/${cid}/imports/${imp.id}/results`);
for (const r of results.data) {
  const icon = r.type === "INFO" ? "✅" : r.type === "WARNING" ? "⚠️" : "❌";
  console.log(`  ${icon} Row ${r.orderNumber}: ${r.text}`);
}

const s = status.summary;
console.log(`\nDone: ${s.succeeded} ok, ${s.failed} failed, ${s.warnings} warnings`);

async function apiRequest(path, opts = {}) {
  const resp = await fetch(`${BASE}${path}`, { headers, ...opts });

  if (resp.status === 429) {
    const retryAfter = parseInt(resp.headers.get("Retry-After") || "60");
    console.log(`Rate limited — waiting ${retryAfter}s`);
    await new Promise(r => setTimeout(r, retryAfter * 1000));
    return apiRequest(path, opts); // Retry once
  }

  if (!resp.ok) {
    const { error } = await resp.json();
    throw new Error(`[${error?.code}] ${error?.message}`);
  }

  return resp.json();
}