ओडू रेस्ट एपीआई: व्यावहारिक उदाहरण और एकीकरण ट्यूटोरियल

पोस्टमैन की 2025 स्टेट ऑफ एपीआई रिपोर्ट के अनुसार, 73% व्यवसाय अब अपने ईआरपी को कम से कम तीन बाहरी प्रणालियों के साथ एकीकृत करते हैं। Odoo, दुनिया भर में 12 मिलियन से अधिक उपयोगकर्ताओं को सशक्त बनाता है, एक समृद्ध एपीआई परत के माध्यम से अपने संपूर्ण डेटा मॉडल को उजागर करता है। फिर भी दस्तावेज़ीकरण कई डेवलपर्स को प्रमाणीकरण प्रवाह, बैच संचालन और उत्पादन-ग्रेड त्रुटि प्रबंधन से जूझ रहा है।

यह ट्यूटोरियल प्रत्येक सामान्य एकीकरण पैटर्न के लिए पायथन और नोड.जेएस दोनों में कॉपी-पेस्ट-तैयार उदाहरण प्रदान करता है। चाहे आप शॉपिफाई ऑर्डर सिंक कर रहे हों, मोबाइल ऐप से डेटा पुश कर रहे हों, या कस्टम डैशबोर्ड बना रहे हों, यह गाइड आपके लिए सब कुछ है।

मुख्य बातें

• Odoo तीन API एक्सेस विधियां प्रदान करता है: XML-RPC (विरासत, सभी संस्करण), JSON-RPC (वेब ​​क्लाइंट प्रोटोकॉल), और REST API (API कुंजियों के साथ Odoo 17+) - प्रत्येक अलग प्रमाणीकरण और उपयोग के मामलों के साथ।
• एपीआई कुंजी प्रमाणीकरण (ओडू 17+) सर्वर-टू-सर्वर एकीकरण के लिए अनुशंसित दृष्टिकोण है - कोई सत्र प्रबंधन नहीं, कोई सीएसआरएफ टोकन नहीं, सीधे HTTP हेडर।
• खोज डोमेन फ़िल्टरिंग के लिए ओडू के शक्तिशाली पोलिश नोटेशन का उपयोग करें - ऑपरेटरों को मास्टर करें और आप किसी भी डेटा संयोजन को क्वेरी कर सकते हैं।
• बैच ऑपरेशन प्रदर्शन के लिए महत्वपूर्ण हैं - एक एपीआई कॉल के साथ 1,000 रिकॉर्ड बनाना 1,000 व्यक्तिगत कॉल की तुलना में 50 गुना तेज है।
• त्रुटि प्रबंधन और दर सीमित करना उत्पादन एकीकरण के लिए आवश्यक हैं - ओडू संरचित त्रुटि प्रतिक्रिया देता है जिसे आपके कोड को पार्स करना चाहिए और शानदार ढंग से संभालना चाहिए।

1. प्रमाणीकरण विधियाँ

विधि 1: एपीआई कुंजियाँ (ओडू 17+ के लिए अनुशंसित)

एपीआई कुंजी सर्वर-टू-सर्वर संचार के लिए सबसे सरल और सबसे सुरक्षित तरीका है:

# Generate an API key in Odoo:
# Settings → Users → Select user → Account Security → New API Key

# Test authentication
curl -X GET "https://your-odoo.com/api/res.partner" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json"

एपीआई कुंजी के साथ पायथन:

import requests

class OdooAPI:
    def __init__(self, url, api_key):
        self.url = url.rstrip('/')
        self.session = requests.Session()
        self.session.headers.update({
            'Authorization': f'Bearer {api_key}',
            'Content-Type': 'application/json',
        })

    def get(self, model, params=None):
        response = self.session.get(
            f'{self.url}/api/{model}',
            params=params or {}
        )
        response.raise_for_status()
        return response.json()

    def post(self, model, data):
        response = self.session.post(
            f'{self.url}/api/{model}',
            json=data
        )
        response.raise_for_status()
        return response.json()

# Usage
odoo = OdooAPI('https://your-odoo.com', 'your-api-key-here')
partners = odoo.get('res.partner', {'limit': 10})

एपीआई कुंजी के साथ नोड.जेएस:

const axios = require('axios');

class OdooAPI {
  constructor(url, apiKey) {
    this.client = axios.create({
      baseURL: `${url}/api`,
      headers: {
        'Authorization': `Bearer ${apiKey}`,
        'Content-Type': 'application/json',
      },
      timeout: 30000,
    });
  }

  async get(model, params = {}) {
    const { data } = await this.client.get(`/${model}`, { params });
    return data;
  }

  async post(model, body) {
    const { data } = await this.client.post(`/${model}`, body);
    return data;
  }

  async put(model, id, body) {
    const { data } = await this.client.put(`/${model}/${id}`, body);
    return data;
  }

  async delete(model, id) {
    const { data } = await this.client.delete(`/${model}/${id}`);
    return data;
  }
}

// Usage
const odoo = new OdooAPI('https://your-odoo.com', 'your-api-key');
const partners = await odoo.get('res.partner', { limit: 10 });

विधि 2: JSON-RPC (सभी संस्करण)

JSON-RPC वह प्रोटोकॉल है जिसका उपयोग Odoo के वेब क्लाइंट द्वारा आंतरिक रूप से किया जाता है। यह सभी Odoo संस्करणों के साथ काम करता है:

import requests
import json

class OdooJsonRpc:
    def __init__(self, url, db, username, password):
        self.url = url.rstrip('/')
        self.db = db
        self.session = requests.Session()
        self.uid = self._authenticate(username, password)

    def _authenticate(self, username, password):
        response = self._call('/web/session/authenticate', {
            'db': self.db,
            'login': username,
            'password': password,
        })
        if not response.get('uid'):
            raise Exception(f"Authentication failed: {response}")
        return response['uid']

    def _call(self, endpoint, params):
        payload = {
            'jsonrpc': '2.0',
            'method': 'call',
            'params': params,
            'id': None,
        }
        response = self.session.post(
            f'{self.url}{endpoint}',
            json=payload,
            headers={'Content-Type': 'application/json'}
        )
        result = response.json()
        if result.get('error'):
            raise Exception(result['error']['data']['message'])
        return result.get('result')

    def search_read(self, model, domain=None, fields=None, limit=80, offset=0, order=None):
        return self._call('/web/dataset/call_kw', {
            'model': model,
            'method': 'search_read',
            'args': [domain or []],
            'kwargs': {
                'fields': fields or [],
                'limit': limit,
                'offset': offset,
                'order': order or '',
            },
        })

    def create(self, model, values):
        return self._call('/web/dataset/call_kw', {
            'model': model,
            'method': 'create',
            'args': [values],
            'kwargs': {},
        })

    def write(self, model, ids, values):
        return self._call('/web/dataset/call_kw', {
            'model': model,
            'method': 'write',
            'args': [ids, values],
            'kwargs': {},
        })

# Usage
odoo = OdooJsonRpc('https://your-odoo.com', 'mydb', 'admin', 'password')
orders = odoo.search_read('sale.order', [('state', '=', 'sale')],
                          fields=['name', 'amount_total', 'partner_id'],
                          limit=20)

विधि 3: एक्सएमएल-आरपीसी (लीगेसी, यूनिवर्सल)

import xmlrpc.client

url = 'https://your-odoo.com'
db = 'mydb'
username = 'admin'
password = 'password'

# Authenticate
common = xmlrpc.client.ServerProxy(f'{url}/xmlrpc/2/common')
uid = common.authenticate(db, username, password, {})

# Create models proxy
models = xmlrpc.client.ServerProxy(f'{url}/xmlrpc/2/object')

# Search and read
partners = models.execute_kw(db, uid, password,
    'res.partner', 'search_read',
    [[('is_company', '=', True), ('country_id.code', '=', 'US')]],
    {'fields': ['name', 'email', 'phone'], 'limit': 10}
)

2. सीआरयूडी संचालन

रिकॉर्ड बनाएं

# Create a single contact
partner_id = odoo.create('res.partner', {
    'name': 'Acme Corporation',
    'is_company': True,
    'email': '[email protected]',
    'phone': '+1-555-0123',
    'street': '123 Main Street',
    'city': 'San Francisco',
    'state_id': 5,  # California
    'country_id': 233,  # United States
    'category_id': [(6, 0, [1, 3])],  # Tags: replace all with IDs 1 and 3
})

# Create a sale order with lines
order_id = odoo.create('sale.order', {
    'partner_id': partner_id,
    'date_order': '2026-03-23',
    'order_line': [
        (0, 0, {
            'product_id': 42,
            'product_uom_qty': 5,
            'price_unit': 99.99,
        }),
        (0, 0, {
            'product_id': 43,
            'product_uom_qty': 2,
            'price_unit': 149.99,
        }),
    ],
})

Node.js समतुल्य:

// Create a contact
const partnerId = await odoo.post('res.partner', {
  name: 'Acme Corporation',
  is_company: true,
  email: '[email protected]',
  phone: '+1-555-0123',
  street: '123 Main Street',
  city: 'San Francisco',
  country_id: 233,
});

// Create sale order with lines
const orderId = await odoo.post('sale.order', {
  partner_id: partnerId,
  date_order: '2026-03-23',
  order_line: [
    [0, 0, { product_id: 42, product_uom_qty: 5, price_unit: 99.99 }],
    [0, 0, { product_id: 43, product_uom_qty: 2, price_unit: 149.99 }],
  ],
});

रिकॉर्ड पढ़ें

# Read specific fields from specific records
data = odoo.search_read('sale.order',
    domain=[('state', '=', 'sale'), ('amount_total', '>', 500)],
    fields=['name', 'partner_id', 'amount_total', 'date_order', 'state'],
    limit=50,
    offset=0,
    order='date_order desc'
)

# Read a single record by ID (REST API)
# GET /api/sale.order/42?fields=name,amount_total

// Node.js — read with pagination
async function fetchAllOrders(odoo) {
  const pageSize = 100;
  let offset = 0;
  let allOrders = [];

  while (true) {
    const orders = await odoo.get('sale.order', {
      domain: JSON.stringify([['state', '=', 'sale']]),
      fields: 'name,partner_id,amount_total',
      limit: pageSize,
      offset,
      order: 'date_order desc',
    });

    allOrders = allOrders.concat(orders);
    if (orders.length < pageSize) break;
    offset += pageSize;
  }

  return allOrders;
}

रिकार्ड अद्यतन करें

# Update a single record
odoo.write('res.partner', [partner_id], {
    'phone': '+1-555-9999',
    'website': 'https://acme.com',
})

# Update multiple records at once
draft_orders = odoo.search_read('sale.order',
    [('state', '=', 'draft'), ('date_order', '<', '2026-01-01')],
    fields=['id']
)
ids = [o['id'] for o in draft_orders]
odoo.write('sale.order', ids, {'note': 'Reviewed Q1 2026'})

रिकॉर्ड हटाएं

# Delete records (use with caution)
odoo.write('res.partner', [obsolete_id], {'active': False})  # Prefer archiving

# Actually delete (rarely needed)
# models.execute_kw(db, uid, password, 'res.partner', 'unlink', [[obsolete_id]])

3. उन्नत खोज डोमेन

Odoo के खोज डोमेन शर्तों को संयोजित करने के लिए पोलिश नोटेशन (उपसर्ग नोटेशन) का उपयोग करते हैं। शर्तों के बीच डिफ़ॉल्ट ऑपरेटर AND है। पाइप का प्रयोग करें '|' OR के लिए और स्पष्ट AND के लिए एम्परसेंड '&'। प्रत्येक पत्ती फ़ील्ड नाम, ऑपरेटर और मान का एक टुपल है। ओडू संबंधित मॉडल फ़ील्ड पर फ़िल्टर करने के लिए डॉट नोटेशन का समर्थन करता है, जैसे ग्राहक के देश के अनुसार ऑर्डर फ़िल्टर करने के लिए 'partner_id.country_id.code'।

# Complex domain examples

# Orders from US customers with amount > $1000, created this year
domain = [
    ('partner_id.country_id.code', '=', 'US'),
    ('amount_total', '>', 1000),
    ('date_order', '>=', '2026-01-01'),
    ('state', 'in', ['sale', 'done']),
]

# OR condition: email contains 'gmail' OR 'yahoo'
domain = [
    '|',
    ('email', 'ilike', 'gmail.com'),
    ('email', 'ilike', 'yahoo.com'),
]

# Complex: (state=sale AND amount>1000) OR (state=done AND amount>5000)
domain = [
    '|',
    '&', ('state', '=', 'sale'), ('amount_total', '>', 1000),
    '&', ('state', '=', 'done'), ('amount_total', '>', 5000),
]

# Negation: NOT archived
domain = [('active', '!=', False)]

# NULL check: has no email
domain = [('email', '=', False)]

# Hierarchical: all child categories of 'Electronics'
domain = [('categ_id', 'child_of', electronics_id)]

# Date ranges
from datetime import datetime, timedelta
domain = [
    ('create_date', '>=', (datetime.now() - timedelta(days=30)).strftime('%Y-%m-%d')),
    ('create_date', '<', datetime.now().strftime('%Y-%m-%d')),
]

ऑपरेटर संदर्भ

4. बैच संचालन

प्रदर्शन के लिए बैच संचालन आवश्यक है। लूप में कभी भी एक-एक करके रिकॉर्ड न बनाएं:

# BAD: 1000 API calls (slow, ~300 seconds)
for customer in customers:
    odoo.create('res.partner', customer)

# GOOD: 1 API call with batch (fast, ~3 seconds)
# Using JSON-RPC batch create
partner_ids = odoo._call('/web/dataset/call_kw', {
    'model': 'res.partner',
    'method': 'create',
    'args': [customers],  # Pass list of dicts
    'kwargs': {},
})

// Node.js batch pattern with chunking
async function batchCreate(odoo, model, records, chunkSize = 200) {
  const results = [];

  for (let i = 0; i < records.length; i += chunkSize) {
    const chunk = records.slice(i, i + chunkSize);
    console.log(`Creating ${model} batch ${i / chunkSize + 1}/${Math.ceil(records.length / chunkSize)}`);

    const ids = await odoo.post(model, chunk);
    results.push(...(Array.isArray(ids) ? ids : [ids]));

    // Respect rate limits
    if (i + chunkSize < records.length) {
      await new Promise(resolve => setTimeout(resolve, 500));
    }
  }

  return results;
}

// Usage
const customers = generateCustomerData(); // Array of 5000 objects
const ids = await batchCreate(odoo, 'res.partner', customers);
console.log(`Created ${ids.length} partners`);

5. त्रुटि प्रबंधन

उत्पादन एकीकरणों को त्रुटियों को शालीनता से संभालना चाहिए:

import requests
import logging
import time

logger = logging.getLogger(__name__)

class OdooAPIClient:
    MAX_RETRIES = 3
    RETRY_DELAY = 2  # seconds

    def __init__(self, url, api_key):
        self.url = url.rstrip('/')
        self.session = requests.Session()
        self.session.headers.update({
            'Authorization': f'Bearer {api_key}',
            'Content-Type': 'application/json',
        })

    def _request(self, method, endpoint, **kwargs):
        last_error = None

        for attempt in range(self.MAX_RETRIES):
            try:
                response = self.session.request(
                    method,
                    f'{self.url}{endpoint}',
                    timeout=30,
                    **kwargs
                )

                if response.status_code == 429:
                    retry_after = int(response.headers.get('Retry-After', 60))
                    logger.warning(f"Rate limited. Retrying after {retry_after}s")
                    time.sleep(retry_after)
                    continue

                if response.status_code == 401:
                    raise AuthenticationError("Invalid API key or session expired")

                if response.status_code == 403:
                    raise PermissionError(f"Access denied: {response.text}")

                if response.status_code == 404:
                    raise RecordNotFoundError(f"Record not found: {endpoint}")

                if response.status_code >= 500:
                    logger.error(f"Server error {response.status_code}: {response.text}")
                    if attempt < self.MAX_RETRIES - 1:
                        time.sleep(self.RETRY_DELAY * (attempt + 1))
                        continue
                    raise ServerError(f"Server error after {self.MAX_RETRIES} retries")

                response.raise_for_status()
                return response.json()

            except requests.exceptions.ConnectionError as e:
                last_error = e
                logger.warning(f"Connection error (attempt {attempt + 1}): {e}")
                if attempt < self.MAX_RETRIES - 1:
                    time.sleep(self.RETRY_DELAY * (attempt + 1))

            except requests.exceptions.Timeout as e:
                last_error = e
                logger.warning(f"Request timeout (attempt {attempt + 1}): {e}")
                if attempt < self.MAX_RETRIES - 1:
                    time.sleep(self.RETRY_DELAY * (attempt + 1))

        raise ConnectionError(f"Failed after {self.MAX_RETRIES} attempts: {last_error}")

class AuthenticationError(Exception): pass
class PermissionError(Exception): pass
class RecordNotFoundError(Exception): pass
class ServerError(Exception): pass

// Node.js error handling with axios interceptors
const axios = require('axios');

function createOdooClient(url, apiKey) {
  const client = axios.create({
    baseURL: `${url}/api`,
    headers: { Authorization: `Bearer ${apiKey}` },
    timeout: 30000,
  });

  // Response interceptor for error handling
  client.interceptors.response.use(
    (response) => response,
    async (error) => {
      const { config, response } = error;
      config.__retryCount = config.__retryCount || 0;

      // Rate limiting
      if (response?.status === 429) {
        const retryAfter = parseInt(response.headers['retry-after'] || '60', 10);
        console.warn(`Rate limited. Waiting ${retryAfter}s...`);
        await new Promise((r) => setTimeout(r, retryAfter * 1000));
        return client(config);
      }

      // Retry on server errors (max 3)
      if (response?.status >= 500 && config.__retryCount < 3) {
        config.__retryCount += 1;
        const delay = config.__retryCount * 2000;
        console.warn(`Server error ${response.status}. Retry ${config.__retryCount}/3 in ${delay}ms`);
        await new Promise((r) => setTimeout(r, delay));
        return client(config);
      }

      // Structured error response
      const errorMessage = response?.data?.error?.message
        || response?.data?.message
        || error.message;

      throw new Error(`Odoo API Error [${response?.status}]: ${errorMessage}`);
    }
  );

  return client;
}

6. वास्तविक-विश्व एकीकरण के उदाहरण

ओडू ऑर्डर सिंक के लिए शॉपिफाई करें

class ShopifyOdooSync:
    def __init__(self, odoo_client, shopify_client):
        self.odoo = odoo_client
        self.shopify = shopify_client

    def sync_order(self, shopify_order):
        # 1. Find or create customer
        partner = self._get_or_create_partner(shopify_order['customer'])

        # 2. Map products
        order_lines = []
        for item in shopify_order['line_items']:
            product_id = self._find_product_by_sku(item['sku'])
            if not product_id:
                logger.warning(f"Product not found for SKU: {item['sku']}")
                continue
            order_lines.append((0, 0, {
                'product_id': product_id,
                'product_uom_qty': item['quantity'],
                'price_unit': float(item['price']),
                'discount': self._calc_discount(item),
            }))

        # 3. Create sale order
        order_id = self.odoo.create('sale.order', {
            'partner_id': partner['id'],
            'client_order_ref': shopify_order['name'],  # Shopify order #
            'order_line': order_lines,
            'note': f"Shopify Order: {shopify_order['id']}",
        })

        # 4. Auto-confirm if paid
        if shopify_order['financial_status'] == 'paid':
            self.odoo._call('/web/dataset/call_kw', {
                'model': 'sale.order',
                'method': 'action_confirm',
                'args': [[order_id]],
                'kwargs': {},
            })

        return order_id

    def _get_or_create_partner(self, customer):
        # Search by email first
        existing = self.odoo.search_read('res.partner',
            [('email', '=', customer['email'])],
            fields=['id', 'name'], limit=1)

        if existing:
            return existing[0]

        return {'id': self.odoo.create('res.partner', {
            'name': f"{customer['first_name']} {customer['last_name']}",
            'email': customer['email'],
            'phone': customer.get('phone'),
        })}

    def _find_product_by_sku(self, sku):
        products = self.odoo.search_read('product.product',
            [('default_code', '=', sku)],
            fields=['id'], limit=1)
        return products[0]['id'] if products else None

वेबहुक रिसीवर (फ्लास्क उदाहरण)

from flask import Flask, request, jsonify
import hmac
import hashlib

app = Flask(__name__)

@app.route('/webhook/odoo/order', methods=['POST'])
def handle_odoo_webhook():
    # Verify signature
    signature = request.headers.get('X-Odoo-Signature')
    expected = hmac.new(
        WEBHOOK_SECRET.encode(),
        request.data,
        hashlib.sha256
    ).hexdigest()

    if not hmac.compare_digest(signature, expected):
        return jsonify({'error': 'Invalid signature'}), 401

    payload = request.json
    event_type = payload.get('event')

    if event_type == 'sale.order.confirmed':
        handle_order_confirmed(payload['data'])
    elif event_type == 'stock.picking.done':
        handle_shipment_complete(payload['data'])

    return jsonify({'status': 'ok'}), 200

7. प्रदर्शन युक्तियाँ

| युक्ति | प्रभाव | विवरण | |----||------||------| | fields पैरामीटर का उपयोग करें | उच्च | केवल आवश्यक फ़ील्ड का अनुरोध करें - पेलोड 5-10x कम कर देता है | | बैच बनाता है | उच्च | 500 रिकॉर्ड के साथ 1 कॉल बनाम 500 कॉल - 50 गुना तेज | | बड़े डेटासेट को पेजिनेट करें | मध्यम | limit और offset का उपयोग करें - 100K रिकॉर्ड लोड करने से बचें | | कैश रीड-ओनली डेटा | मध्यम | कैश उत्पाद कैटलॉग, श्रेणियां (टीटीएल 5-15 मिनट) | | search_count का प्रयोग करें | निम्न | लाने से पहले गिनें - केवल गिनने के लिए डेटा लोड करने से बचें | | कनेक्शन पूलिंग | मध्यम | HTTP सत्रों का पुन: उपयोग करें - टीएलएस हैंडशेक ओवरहेड बचाता है |

अक्सर पूछे जाने वाले प्रश्न

Odoo में XML-RPC, JSON-RPC और REST API के बीच क्या अंतर है?

XML-RPC सभी Odoo संस्करणों में उपलब्ध विरासत प्रोटोकॉल है - यह वर्बोज़ है लेकिन सार्वभौमिक रूप से समर्थित है। JSON-RPC, Odoo के वेब क्लाइंट द्वारा उपयोग किया जाने वाला प्रोटोकॉल है और JSON पेलोड के साथ समान कार्यक्षमता प्रदान करता है। REST API को Odoo 17 में पेश किया गया था और यह API कुंजी प्रमाणीकरण के साथ मानक HTTP एंडपॉइंट प्रदान करता है, जिससे यह आधुनिक एकीकरण के लिए सबसे आसान विकल्प बन जाता है। यदि आप Odoo 17 या उसके बाद के संस्करण पर हैं, तो नई परियोजनाओं के लिए REST API का उपयोग करें।

मैं ओडू एपीआई दर सीमा को कैसे प्रबंधित करूं?

Odoo.sh आपके प्लान स्तर के आधार पर दर सीमा लागू करता है। जब आपको 429 प्रतिक्रिया प्राप्त हो, तो पुनः प्रयास-आफ्टर शीर्षक पढ़ें और पुनः प्रयास करने से पहले प्रतीक्षा करें। उच्च-मात्रा एकीकरण के लिए, घातीय बैकऑफ़ लागू करें, एपीआई कॉल की संख्या को कम करने के लिए अपने संचालन को बैच करें, और गैर-महत्वपूर्ण सिंक के लिए वास्तविक समय एपीआई कॉल के बजाय बल्क प्रोसेसिंग के लिए ओडू की निर्धारित क्रियाओं का उपयोग करने पर विचार करें।

क्या मैं एपीआई के माध्यम से कस्टम पायथन तरीकों को कॉल कर सकता हूं?

हाँ। Odoo मॉडल पर किसी भी सार्वजनिक विधि को XML-RPC या JSON-RPC के माध्यम सेexecute_kw का उपयोग करके कॉल किया जा सकता है। REST API के लिए, आपको @http.route के साथ एक कस्टम कंट्रोलर एंडपॉइंट बनाना होगा। अंडरस्कोर से शुरू होने वाली विधियाँ निजी हैं और इन्हें XML-RPC के माध्यम से बाह्य रूप से नहीं बुलाया जा सकता है। इंजेक्शन हमलों को रोकने के लिए हमेशा अपने कस्टम तरीकों में इनपुट को मान्य करें।

मैं बड़े डेटासेट को कुशलतापूर्वक कैसे सिंक करूं?

रणनीतियों के संयोजन का उपयोग करें: बैच संचालन और पेजिनेशन के साथ प्रारंभिक पूर्ण सिंक (प्रति अनुरोध 200 रिकॉर्ड सीमित करें), फिर अंतिम सिंक के बाद से संशोधित रिकॉर्ड लाने के लिए राइट_डेट फ़िल्टरिंग का उपयोग करके वृद्धिशील सिंक। अंतिम सिंक टाइमस्टैम्प को संग्रहीत करें और इसे डोमेन फ़िल्टर के रूप में उपयोग करें। 100,000 रिकॉर्ड से अधिक के बहुत बड़े डेटासेट के लिए, एपीआई सिंक्रनाइज़ेशन के बजाय सीधे डेटाबेस प्रतिकृति पर विचार करें।

क्या Odoo REST API Odoo सामुदायिक संस्करण में उपलब्ध है?

एपीआई कुंजी प्रमाणीकरण के साथ मूल REST API को Odoo 17 एंटरप्राइज़ में पेश किया गया था। ओडू समुदाय के लिए, आप XML-RPC या JSON-RPC का उपयोग कर सकते हैं जो सभी संस्करणों में उपलब्ध हैं, या OCA के रेस्ट-फ्रेमवर्क जैसे सामुदायिक मॉड्यूल स्थापित कर सकते हैं जो RESTful एंडपॉइंट जोड़ते हैं। ECOSIRE की एकीकरण सेवाएँ सभी Odoo संस्करणों और API प्रोटोकॉल का समर्थन करती हैं।

मैं एपीआई कॉल में मेनी2मैनी और वन2मैनी फ़ील्ड को कैसे संभालूं?

रिलेशनल फ़ील्ड विशेष कमांड टुपल्स का उपयोग करते हैं: (0, 0, मान) एक नया रिकॉर्ड बनाने और लिंक करने के लिए, (1, आईडी, मान) एक लिंक किए गए रिकॉर्ड को अपडेट करने के लिए, (2, आईडी, 0) एक लिंक किए गए रिकॉर्ड को हटाने के लिए, (3, आईडी, 0) बिना हटाए अनलिंक करने के लिए, (4, आईडी, 0) मौजूदा रिकॉर्ड को लिंक करने के लिए, (5, 0, 0) सभी को अनलिंक करने के लिए, और (6, 0, [आईडी]) सभी लिंक को बदलने के लिए। पढ़ने के लिए, ये फ़ील्ड डिफ़ॉल्ट रूप से आईडी की सूचियाँ लौटाते हैं - पूर्ण डेटा प्राप्त करने के लिए फ़ील्ड नाम के साथ search_read का उपयोग करें।

अगले चरण

एपीआई एकीकरण आधुनिक व्यापार प्रणालियों की रीढ़ है। चाहे आप एक साधारण डेटा सिंक या एक जटिल मल्टी-प्लेटफ़ॉर्म ऑर्केस्ट्रेशन का निर्माण कर रहे हों, इस गाइड के पैटर्न आपकी अच्छी सेवा करेंगे।

संबंधित संसाधन:

• ओडू पायथन डेवलपमेंट गाइड - ओडू के पायथन बैकएंड में गहराई से उतरें
• वेबहुक डिबगिंग गाइड - वेबहुक एकीकरण का समस्या निवारण
• ECOSIRE मार्केटप्लेस कनेक्टर्स - प्रमुख प्लेटफार्मों के लिए पूर्व-निर्मित एकीकरण

Odoo API एकीकरण में सहायता चाहिए? ECOSIRE की एकीकरण टीम ने ओडू को शॉपिफाई, अमेज़ॅन, सेल्सफोर्स और कस्टम ईआरपी सहित 50 से अधिक बाहरी प्लेटफार्मों से जोड़ा है। सरल डेटा सिंक से लेकर वास्तविक समय के द्विदिशात्मक ऑर्केस्ट्रेशन तक, हम उस पैमाने पर एकीकरण बनाते हैं। निःशुल्क तकनीकी परामर्श शेड्यूल करें।