Partner and Supply Chain File Exchange

import os
import requests

BASE_URL = os.getenv("INNORIX_BASE_URL", "https://app.innorix.com").rstrip("/")
TOKEN = os.environ["INNORIX_ACCESS_TOKEN"]
WORKSPACE_ID = os.getenv("INNORIX_WORKSPACE_ID")   # optional; falls back to the current workspace

STATUS_COMPLETE = 2
TERMINAL = {2, 4, 5, 9, 99}          # complete / error / cancelled / partial / failed
NOT_SUCCEEDED = {4, 5, 9, 99}


def api(method, path, body=None, params=None):
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {TOKEN}",
    }

    if WORKSPACE_ID:
        headers["x-workspace-id"] = WORKSPACE_ID

    response = requests.request(
        method, BASE_URL + path,
        headers=headers, json=body, params=params, timeout=30,
    )

    payload = response.json() if response.content else {}

    if not response.ok:
        raise RuntimeError(payload.get("message") or f"HTTP {response.status_code}")

    return payload.get("data")


def is_terminal(detail):
    return detail.get("isTerminal", detail.get("status") in TERMINAL)

import base64
import time


def encode_path(device_id, raw_path):
    normalized = str(raw_path or "").replace("\\", "/")
    token = base64.b64encode(normalized.encode("utf-8")).decode("ascii")
    return f"{device_id}_ino_{token}"


def now_iso():
    return time.strftime("%Y-%m-%dT%H:%M:%S.000Z", time.gmtime())

PARTNERS = {
    "partner-a": {
        "device": "device-partner-a",
        "send":    {"local": "/send/orders", "remote": "/receive/orders"},
        "receive": {"remote": "/send/results", "local": "/receive/results"},
    },
    "partner-b": {
        "device": "device-partner-b",
        "send":    {"local": "/send/design", "remote": "/receive/design"},
        "receive": {"remote": "/send/review", "local": "/receive/review"},
    },
}

INTERNAL = "device-hq-01"

import os


def send_to_partner(partner_id, files):
    partner = PARTNERS[partner_id]

    transfer = api("POST", "/api/transfers/manual", {
        "sourceDevice": INTERNAL,
        "targetDevice": partner["device"],
        "targetPath": partner["send"]["remote"],
        "sourceItem": [{"path": p, "isDir": False} for p in files],
        "sendAllFolder": False,
        "transferOptions": {"target-action": "numbering"},
    })

    return transfer["monitorId"]


monitor_id = send_to_partner("partner-a", ["/send/orders/PO-2026-0901.xlsx"])

def create_receive_watch(partner_id, webhook=None):
    partner = PARTNERS[partner_id]
    remote = partner["receive"]["remote"]
    local = f"{partner['receive']['local']}/{partner_id}"
    name = f"receive {partner_id}"

    body = {
        "name": name,
        "flowName": name,
        "transferType": "sync",
        "timezone": "Asia/Seoul",
        "step": 1,
        "isUpcoming": False,
        "details": [
            {
                "senderId": partner["device"],
                "receiverId": INTERNAL,
                "sourceItem": [
                    {
                        "hash": encode_path(partner["device"], remote),
                        "filePath": remote,
                        "isDir": True,
                    }
                ],
                "targetPath": encode_path(INTERNAL, local),
                "step": 1,
                "transferOptions": {
                    "noSchedule": True,
                    "target-action": "numbering",
                    "send-fileoption": {},
                    "syncType": 1,
                    "watchFolderType": 1,      # 1 = on create, 2 = on modify
                },
            }
        ],
        "schedules": [
            {"type": "none", "startDateType": "now",
             "startDate": now_iso(), "timezone": "Asia/Seoul"}
        ],
    }

    if webhook:
        body["processors"] = [{
            "category": "run",
            "type": "http",
            "config": {"url": webhook, "method": "POST"},
        }]

    return api("POST", "/api/automations", body)["automationId"]


receivers = {p: create_receive_watch(p, RECEIVE_HOOK) for p in PARTNERS}

def on_receive_hook(payload):
    monitor_id = payload.get("monitorId")

    if monitor_id:
        detail = api("GET", f"/api/transfers/{monitor_id}")

        if detail["status"] != STATUS_COMPLETE:
            return notify_partner_failure(payload)

    register_received_files(payload)

from datetime import datetime, timedelta, timezone


def paginate(path, params=None, limit=200, max_pages=50):
    query = dict(params or {})
    query["limit"] = limit
    cursor = None

    for _ in range(max_pages):
        if cursor:
            query["cursor"] = cursor

        result = api("GET", path, params=query) or {}

        for record in result.get("data") or []:
            yield record

        pagination = result.get("pagination") or {}

        if not pagination.get("hasMore"):
            return

        cursor = pagination.get("nextCursor")

        if not cursor:
            return


def partner_summary(partner_id, days=7):
    partner = PARTNERS[partner_id]
    end = datetime.now(timezone.utc)
    fmt = "%Y-%m-%dT%H:%M:%SZ"

    rows = list(paginate(
        f"/api/devices/{partner['device']}/transfer-history", params={
            "startDate": (end - timedelta(days=days)).strftime(fmt),
            "endDate": end.strftime(fmt),
        }))

    return {
        "sent": len([r for r in rows if r.get("sourceDeviceName") == INTERNAL]),
        "received": len([r for r in rows if r.get("targetDeviceName") == INTERNAL]),
        "failed": len([r for r in rows if r.get("status") in NOT_SUCCEEDED]),
        "rows": rows,
    }


for partner_id in PARTNERS:
    summary = partner_summary(partner_id)
    print(f"{partner_id:14} sent {summary['sent']:>3}"
          f" received {summary['received']:>3} failed {summary['failed']:>3}")

def wait(monitor_id, timeout=3600, interval=3):
    deadline = time.time() + timeout

    while time.time() < deadline:
        detail = api("GET", f"/api/transfers/{monitor_id}")

        if is_terminal(detail):
            return detail

        time.sleep(interval)

    raise TimeoutError(monitor_id)


def failed_files(monitor_id):
    result = api("GET", f"/api/transfers/{monitor_id}/files", params={
        "state": "any", "size": 500,
    }) or {}

    return [r for r in (result.get("children") or [])
            if r.get("status") in NOT_SUCCEEDED]


def retry_failed(monitor_id):
    rows = failed_files(monitor_id)

    if not rows:
        return 0

    api("POST", f"/api/transfers/{monitor_id}/retry", {
        "filesRetry": [
            {"filePath": r["sourceFilePath"], "isDir": bool(r.get("isFolder"))}
            for r in rows
        ]
    })

    return len(rows)

def check_partner(partner_id, days=1):
    partner = PARTNERS[partner_id]
    summary = partner_summary(partner_id, days=days)

    state = api("GET", f"/api/devices/{partner['device']}/connectivity") or {}

    if not state.get("isConnected"):
        return f"connection lost ({state.get('stateLabel')}) - recollect after recovery"

    if summary["failed"]:
        count = 0

        for row in summary["rows"]:
            if row.get("status") in NOT_SUCCEEDED and row.get("monitorId"):
                count += retry_failed(row["monitorId"])

        return f"transfer failed - retried {count} files"

    if summary["received"] == 0:
        return "nothing received - ask the partner"

    return "ok"