Odoo Integration

"""
Odoo → Certyo integration script.
Polls Odoo for validated delivery orders and ingests them into Certyo.
"""
import xmlrpc.client
import requests
from datetime import datetime, timedelta

# --- Odoo connection ---
ODOO_URL = "https://mycompany.odoo.com"
ODOO_DB = "mycompany-prod"
ODOO_USER = "api-user@mycompany.com"
ODOO_API_KEY = "odoo-api-key-here"  # Settings → Users → API Keys

common = xmlrpc.client.ServerProxy(f"{ODOO_URL}/xmlrpc/2/common")
uid = common.authenticate(ODOO_DB, ODOO_USER, ODOO_API_KEY, {})
models = xmlrpc.client.ServerProxy(f"{ODOO_URL}/xmlrpc/2/object")

# --- Certyo connection ---
CERTYO_URL = "https://www.certyos.com/api/v1"
CERTYO_API_KEY = "your-certyo-api-key"
CERTYO_TENANT = "mycompany"

def get_recent_pickings():
    """Fetch delivery orders validated in the last hour."""
    since = (datetime.utcnow() - timedelta(hours=1)).strftime("%Y-%m-%d %H:%M:%S")
    return models.execute_kw(
        ODOO_DB, uid, ODOO_API_KEY,
        "stock.picking", "search_read",
        [[
            ("state", "=", "done"),
            ("picking_type_code", "=", "outgoing"),
            ("date_done", ">=", since),
            ("x_certyo_record_hash", "=", False),  # not yet ingested
        ]],
        {"fields": [
            "name", "partner_id", "origin", "date_done",
            "move_ids_without_package", "carrier_tracking_ref",
        ]},
    )

def get_move_lines(picking_id):
    """Fetch product details for a delivery order."""
    return models.execute_kw(
        ODOO_DB, uid, ODOO_API_KEY,
        "stock.move", "search_read",
        [[("picking_id", "=", picking_id)]],
        {"fields": [
            "product_id", "product_uom_qty", "quantity",
            "lot_ids", "reference",
        ]},
    )

def ingest_picking(picking):
    """Send a single delivery order to Certyo."""
    moves = get_move_lines(picking["id"])
    products = []
    for move in moves:
        products.append({
            "productId": move["product_id"][0],
            "productName": move["product_id"][1],
            "orderedQty": move["product_uom_qty"],
            "deliveredQty": move["quantity"],
            "lotIds": move.get("lot_ids", []),
        })

    payload = {
        "tenantId": CERTYO_TENANT,
        "database": "odoo",
        "collection": "stock.picking",
        "recordId": picking["name"],            # e.g. "WH/OUT/00042"
        "recordVersion": "1",
        "operationType": "insert",
        "recordPayload": {
            "pickingName": picking["name"],
            "partner": picking["partner_id"][1] if picking["partner_id"] else None,
            "sourceDocument": picking.get("origin"),
            "dateDone": picking["date_done"],
            "trackingRef": picking.get("carrier_tracking_ref"),
            "products": products,
        },
        "sourceTimestamp": picking["date_done"],
        "idempotencyKey": f'{picking["name"]}-v1',
    }

    resp = requests.post(
        f"{CERTYO_URL}/records",
        json=payload,
        headers={
            "X-API-Key": CERTYO_API_KEY,
            "Content-Type": "application/json",
        },
        timeout=10,
    )
    resp.raise_for_status()
    return resp.json()

def update_odoo_status(picking_id, certyo_response):
    """Write Certyo hash back to the Odoo record."""
    models.execute_kw(
        ODOO_DB, uid, ODOO_API_KEY,
        "stock.picking", "write",
        [[picking_id], {
            "x_certyo_record_hash": certyo_response["recordHash"],
            "x_certyo_anchor_status": "pending",
        }],
    )

if __name__ == "__main__":
    pickings = get_recent_pickings()
    print(f"Found {len(pickings)} new delivery orders")
    for picking in pickings:
        result = ingest_picking(picking)
        update_odoo_status(picking["id"], result)
        print(f"  ✓ {picking['name']} → {result['recordHash'][:16]}...")

"""
Alternative: Use Odoo JSON-RPC instead of XML-RPC.
JSON-RPC is faster for large payloads and avoids XML encoding overhead.
"""
import requests

ODOO_URL = "https://mycompany.odoo.com"
ODOO_DB = "mycompany-prod"
ODOO_USER = "api-user@mycompany.com"
ODOO_API_KEY = "odoo-api-key-here"

def jsonrpc(url, method, params):
    """Make a JSON-RPC 2.0 call to Odoo."""
    resp = requests.post(
        url,
        json={"jsonrpc": "2.0", "method": method, "params": params, "id": 1},
        timeout=30,
    )
    result = resp.json()
    if "error" in result:
        raise Exception(result["error"]["data"]["message"])
    return result["result"]

# Authenticate
uid = jsonrpc(
    f"{ODOO_URL}/jsonrpc",
    "call",
    {
        "service": "common",
        "method": "authenticate",
        "args": [ODOO_DB, ODOO_USER, ODOO_API_KEY, {}],
    },
)

# Search for validated pickings
pickings = jsonrpc(
    f"{ODOO_URL}/jsonrpc",
    "call",
    {
        "service": "object",
        "method": "execute_kw",
        "args": [
            ODOO_DB, uid, ODOO_API_KEY,
            "stock.picking", "search_read",
            [[
                ("state", "=", "done"),
                ("picking_type_code", "=", "outgoing"),
                ("x_certyo_record_hash", "=", False),
            ]],
            {"fields": ["name", "partner_id", "origin", "date_done"], "limit": 100},
        ],
    },
)

print(f"Found {len(pickings)} pickings to sync")

/**
 * Node.js integration: Odoo JSON-RPC → Certyo.
 * Uses the odoo-await library for cleaner async/await syntax.
 *
 * npm install odoo-await node-fetch
 */
const Odoo = require("odoo-await");
const fetch = require("node-fetch");

const CERTYO_URL = "https://www.certyos.com/api/v1";
const CERTYO_API_KEY = "your-certyo-api-key";
const CERTYO_TENANT = "mycompany";

async function main() {
  // Connect to Odoo
  const odoo = new Odoo({
    baseUrl: "https://mycompany.odoo.com",
    db: "mycompany-prod",
    username: "api-user@mycompany.com",
    password: "odoo-api-key-here",
  });
  await odoo.connect();

  // Fetch validated outgoing pickings not yet synced
  const pickings = await odoo.searchRead("stock.picking", {
    domain: [
      ["state", "=", "done"],
      ["picking_type_code", "=", "outgoing"],
      ["x_certyo_record_hash", "=", false],
    ],
    fields: ["name", "partner_id", "origin", "date_done"],
    limit: 100,
  });

  console.log(`Found ${pickings.length} delivery orders`);

  for (const picking of pickings) {
    // Ingest into Certyo
    const resp = await fetch(`${CERTYO_URL}/records`, {
      method: "POST",
      headers: {
        "X-API-Key": CERTYO_API_KEY,
        "Content-Type": "application/json",
      },
      body: JSON.stringify({
        tenantId: CERTYO_TENANT,
        database: "odoo",
        collection: "stock.picking",
        recordId: picking.name,
        recordVersion: "1",
        operationType: "insert",
        recordPayload: {
          pickingName: picking.name,
          partner: picking.partner_id?.[1] ?? null,
          sourceDocument: picking.origin,
          dateDone: picking.date_done,
        },
        sourceTimestamp: picking.date_done,
        idempotencyKey: `${picking.name}-v1`,
      }),
    });

    const result = await resp.json();
    console.log(`  ✓ ${picking.name} → ${result.recordHash.slice(0, 16)}...`);

    // Write hash back to Odoo
    await odoo.update("stock.picking", picking.id, {
      x_certyo_record_hash: result.recordHash,
      x_certyo_anchor_status: "pending",
    });
  }
}

main().catch(console.error);