Odoo Shopify Integration: Automate Product, Order & Inventory Sync

{
  "name": "Shopify Order → Odoo",
  "nodes": [
    {
      "name": "Shopify Webhook",
      "type": "n8n-nodes-base.webhook",
      "parameters": {
        "httpMethod": "POST",
        "path": "shopify-order",
        "responseMode": "onReceived"
      }
    },
    {
      "name": "Find or Create Customer",
      "type": "n8n-nodes-base.odoo",
      "parameters": {
        "resource": "contact",
        "operation": "getAll",
        "filters": {
          "filter": [
            {
              "fieldName": "email",
              "operator": "=",
              "value": "={{ $json.customer.email }}"
            }
          ]
        }
      }
    },
    {
      "name": "Create Customer If New",
      "type": "n8n-nodes-base.odoo",
      "parameters": {
        "resource": "contact",
        "operation": "create",
        "fieldsToCreateOrUpdate": {
          "fieldValues": [
            { "fieldName": "name", "fieldValue": "={{ $json.customer.first_name }} {{ $json.customer.last_name }}" },
            { "fieldName": "email", "fieldValue": "={{ $json.customer.email }}" },
            { "fieldName": "phone", "fieldValue": "={{ $json.customer.phone }}" },
            { "fieldName": "street", "fieldValue": "={{ $json.shipping_address.address1 }}" },
            { "fieldName": "city", "fieldValue": "={{ $json.shipping_address.city }}" },
            { "fieldName": "zip", "fieldValue": "={{ $json.shipping_address.zip }}" }
          ]
        }
      }
    },
    {
      "name": "Create Sale Order",
      "type": "n8n-nodes-base.odoo",
      "parameters": {
        "resource": "sale.order",
        "operation": "create",
        "fieldsToCreateOrUpdate": {
          "fieldValues": [
            { "fieldName": "partner_id", "fieldValue": "={{ $json.partner_id }}" },
            { "fieldName": "client_order_ref", "fieldValue": "={{ $json.order_number }}" },
            { "fieldName": "note", "fieldValue": "Shopify Order #{{ $json.order_number }}" }
          ]
        }
      }
    },
    {
      "name": "Add Order Lines",
      "type": "n8n-nodes-base.odoo",
      "parameters": {
        "resource": "sale.order.line",
        "operation": "create",
        "fieldsToCreateOrUpdate": {
          "fieldValues": [
            { "fieldName": "order_id", "fieldValue": "={{ $json.sale_order_id }}" },
            { "fieldName": "product_id", "fieldValue": "={{ $json.odoo_product_id }}" },
            { "fieldName": "product_uom_qty", "fieldValue": "={{ $json.quantity }}" },
            { "fieldName": "price_unit", "fieldValue": "={{ $json.price }}" }
          ]
        }
      }
    }
  ]
}

{
  "name": "Odoo Product → Shopify",
  "nodes": [
    {
      "name": "Schedule Trigger",
      "type": "n8n-nodes-base.scheduleTrigger",
      "parameters": {
        "rule": { "interval": [{ "field": "minutes", "minutesInterval": 15 }] }
      }
    },
    {
      "name": "Get Modified Products",
      "type": "n8n-nodes-base.odoo",
      "parameters": {
        "resource": "product.template",
        "operation": "getAll",
        "filters": {
          "filter": [
            {
              "fieldName": "write_date",
              "operator": ">",
              "value": "={{ $now.minus({ minutes: 16 }).toISO() }}"
            },
            {
              "fieldName": "sale_ok",
              "operator": "=",
              "value": "true"
            }
          ]
        }
      }
    },
    {
      "name": "Check Shopify Product Exists",
      "type": "n8n-nodes-base.shopify",
      "parameters": {
        "operation": "getAll",
        "resource": "product",
        "filters": {
          "handle": "={{ $json.default_code }}"
        }
      }
    },
    {
      "name": "Create or Update Shopify Product",
      "type": "n8n-nodes-base.shopify",
      "parameters": {
        "operation": "{{ $json.shopify_id ? 'update' : 'create' }}",
        "resource": "product",
        "title": "={{ $json.name }}",
        "bodyHtml": "={{ $json.description_sale }}",
        "vendor": "={{ $json.brand }}",
        "productType": "={{ $json.categ_id.name }}",
        "variants": "={{ $json.product_variant_ids }}"
      }
    }
  ]
}

{
  "name": "Odoo Inventory → Shopify",
  "nodes": [
    {
      "name": "Schedule Trigger",
      "type": "n8n-nodes-base.scheduleTrigger",
      "parameters": {
        "rule": { "interval": [{ "field": "minutes", "minutesInterval": 5 }] }
      }
    },
    {
      "name": "Get Odoo Stock Levels",
      "type": "n8n-nodes-base.odoo",
      "parameters": {
        "resource": "product.product",
        "operation": "getAll",
        "fields": ["id", "default_code", "qty_available", "virtual_available"],
        "filters": {
          "filter": [
            { "fieldName": "type", "operator": "=", "value": "product" },
            { "fieldName": "sale_ok", "operator": "=", "value": "true" }
          ]
        }
      }
    },
    {
      "name": "Map to Shopify Inventory",
      "type": "n8n-nodes-base.set",
      "parameters": {
        "values": {
          "string": [
            { "name": "sku", "value": "={{ $json.default_code }}" }
          ],
          "number": [
            { "name": "available", "value": "={{ Math.max(0, $json.qty_available) }}" }
          ]
        }
      }
    },
    {
      "name": "Update Shopify Inventory",
      "type": "n8n-nodes-base.httpRequest",
      "parameters": {
        "method": "POST",
        "url": "https://{{ $credentials.shopifyDomain }}/admin/api/2024-01/inventory_levels/set.json",
        "headers": {
          "X-Shopify-Access-Token": "={{ $credentials.shopifyAccessToken }}"
        },
        "body": {
          "location_id": "={{ $json.shopify_location_id }}",
          "inventory_item_id": "={{ $json.shopify_inventory_item_id }}",
          "available": "={{ $json.available }}"
        }
      }
    }
  ]
}

import xmlrpc.client
import hmac
import hashlib
import json
from flask import Flask, request, abort

app = Flask(__name__)

# Odoo connection
ODOO_URL = "https://odoo.yourdomain.com"
ODOO_DB = "odoo_production"
ODOO_USER = "admin"
ODOO_PASSWORD = "your-api-key"

# Shopify webhook secret
SHOPIFY_WEBHOOK_SECRET = "your-webhook-secret"

# Authenticate with Odoo
common = xmlrpc.client.ServerProxy(f"{ODOO_URL}/xmlrpc/2/common")
uid = common.authenticate(ODOO_DB, ODOO_USER, ODOO_PASSWORD, {})
models = xmlrpc.client.ServerProxy(f"{ODOO_URL}/xmlrpc/2/object")


def verify_shopify_webhook(data, hmac_header):
    """Verify the webhook came from Shopify."""
    digest = hmac.new(
        SHOPIFY_WEBHOOK_SECRET.encode("utf-8"),
        data,
        hashlib.sha256,
    ).hexdigest()
    import base64
    computed = base64.b64encode(
        hmac.new(
            SHOPIFY_WEBHOOK_SECRET.encode("utf-8"),
            data,
            hashlib.sha256,
        ).digest()
    ).decode("utf-8")
    return hmac.compare_digest(computed, hmac_header)


def find_or_create_partner(customer):
    """Find existing partner by email, or create a new one."""
    email = customer.get("email", "")
    if email:
        partner_ids = models.execute_kw(
            ODOO_DB, uid, ODOO_PASSWORD,
            "res.partner", "search",
            [[["email", "=", email]]]
        )
        if partner_ids:
            return partner_ids[0]

    # Create new partner
    return models.execute_kw(
        ODOO_DB, uid, ODOO_PASSWORD,
        "res.partner", "create",
        [{
            "name": f"{customer['first_name']} {customer['last_name']}",
            "email": email,
            "phone": customer.get("phone", ""),
            "customer_rank": 1,
        }]
    )


def find_product_by_sku(sku):
    """Find Odoo product by internal reference (SKU)."""
    product_ids = models.execute_kw(
        ODOO_DB, uid, ODOO_PASSWORD,
        "product.product", "search",
        [[["default_code", "=", sku]]]
    )
    return product_ids[0] if product_ids else None


@app.route("/webhook/shopify/order", methods=["POST"])
def handle_order():
    data = request.get_data()
    hmac_header = request.headers.get("X-Shopify-Hmac-SHA256", "")

    if not verify_shopify_webhook(data, hmac_header):
        abort(401)

    order = json.loads(data)

    # Check for duplicate (idempotency)
    existing = models.execute_kw(
        ODOO_DB, uid, ODOO_PASSWORD,
        "sale.order", "search",
        [[["client_order_ref", "=", str(order["order_number"])]]]
    )
    if existing:
        return {"status": "duplicate", "order_id": existing[0]}, 200

    # Find or create customer
    partner_id = find_or_create_partner(order.get("customer", {}))

    # Create sale order
    sale_order_id = models.execute_kw(
        ODOO_DB, uid, ODOO_PASSWORD,
        "sale.order", "create",
        [{
            "partner_id": partner_id,
            "client_order_ref": str(order["order_number"]),
            "note": f"Shopify Order #{order['order_number']}",
        }]
    )

    # Add order lines
    for item in order.get("line_items", []):
        product_id = find_product_by_sku(item.get("sku", ""))
        if not product_id:
            # Create a placeholder product or log warning
            continue

        models.execute_kw(
            ODOO_DB, uid, ODOO_PASSWORD,
            "sale.order.line", "create",
            [{
                "order_id": sale_order_id,
                "product_id": product_id,
                "product_uom_qty": item["quantity"],
                "price_unit": float(item["price"]),
                "name": item["title"],
            }]
        )

    # Confirm the sale order
    models.execute_kw(
        ODOO_DB, uid, ODOO_PASSWORD,
        "sale.order", "action_confirm",
        [[sale_order_id]]
    )

    return {"status": "created", "sale_order_id": sale_order_id}, 201


if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000)

import xmlrpc.client
import requests

ODOO_URL = "https://odoo.yourdomain.com"
ODOO_DB = "odoo_production"
ODOO_USER = "admin"
ODOO_PASSWORD = "your-api-key"

SHOPIFY_STORE = "your-store.myshopify.com"
SHOPIFY_TOKEN = "shpat_xxxxxxxxxxxxx"
SHOPIFY_LOCATION_ID = "12345678"

# Connect to Odoo
common = xmlrpc.client.ServerProxy(f"{ODOO_URL}/xmlrpc/2/common")
uid = common.authenticate(ODOO_DB, ODOO_USER, ODOO_PASSWORD, {})
models = xmlrpc.client.ServerProxy(f"{ODOO_URL}/xmlrpc/2/object")

# Get all stockable products with a SKU
products = models.execute_kw(
    ODOO_DB, uid, ODOO_PASSWORD,
    "product.product", "search_read",
    [[
        ["type", "=", "product"],
        ["default_code", "!=", False],
        ["sale_ok", "=", True],
    ]],
    {"fields": ["id", "default_code", "qty_available"]}
)

headers = {
    "X-Shopify-Access-Token": SHOPIFY_TOKEN,
    "Content-Type": "application/json",
}

for product in products:
    sku = product["default_code"]
    available = max(0, int(product["qty_available"]))

    # Find inventory item in Shopify by SKU
    resp = requests.get(
        f"https://{SHOPIFY_STORE}/admin/api/2024-01/products.json",
        headers=headers,
        params={"fields": "id,variants", "limit": 1},
    )
    # In production, use a mapping table instead of
    # searching Shopify by SKU on every run

    # Update inventory level
    resp = requests.post(
        f"https://{SHOPIFY_STORE}/admin/api/2024-01/inventory_levels/set.json",
        headers=headers,
        json={
            "location_id": int(SHOPIFY_LOCATION_ID),
            "inventory_item_id": 0,  # Replace with actual ID
            "available": available,
        },
    )

    if resp.status_code == 200:
        print(f"Updated {sku}: {available} units")
    else:
        print(f"Failed {sku}: {resp.text}")

mutation productCreate($input: ProductInput!) {
  productCreate(input: $input) {
    product {
      id
      title
      handle
      variants(first: 100) {
        edges {
          node {
            id
            sku
            price
            inventoryQuantity
          }
        }
      }
    }
    userErrors {
      field
      message
    }
  }
}

# Variables:
# {
#   "input": {
#     "title": "Ergonomic Office Chair",
#     "bodyHtml": "<p>Premium ergonomic chair...</p>",
#     "vendor": "OfficePro",
#     "productType": "Furniture",
#     "variants": [
#       { "sku": "CHAIR-BLK-L", "price": "299.00" },
#       { "sku": "CHAIR-GRY-L", "price": "299.00" }
#     ]
#   }
# }

# Instead of creating one order at a time:
for order in shopify_orders:
    models.execute_kw(db, uid, pw, "sale.order", "create", [order])

# Batch create (much faster for 50+ orders):
order_vals = [
    {
        "partner_id": order["partner_id"],
        "client_order_ref": order["shopify_number"],
        "order_line": [
            (0, 0, {
                "product_id": line["product_id"],
                "product_uom_qty": line["qty"],
                "price_unit": line["price"],
            })
            for line in order["lines"]
        ],
    }
    for order in shopify_orders
]
sale_order_ids = models.execute_kw(
    db, uid, pw, "sale.order", "create", order_vals
)