اربط برنامجك بأرض المتجر.

// Node.js - GET /api/ping
app.get('/api/ping', (req, res) => {
  res.status(200).json({
    status: 'ok',
    message: 'pong'
  });
});

// C# - GET /api/ping
[HttpGet("ping")]
public IActionResult Ping()
{
    return Ok(new
    {
        status = "ok",
        message = "pong"
    });
}

// Java - GET /api/ping
@GetMapping("/api/ping")
public ResponseEntity ping() {
    return ResponseEntity.ok(Map.of(
        "status", "ok",
        "message", "pong"
    ));
}

# Python - GET /api/ping
@app.route('/api/ping', methods=['GET'])
def ping():
    return jsonify({
        'status': 'ok',
        'message': 'pong'
    }), 200

// Delphi - GET /api/ping
procedure TSimpleServer.HandlePing(AContext: TIdContext;
  ARequestInfo: TIdHTTPRequestInfo; AResponseInfo: TIdHTTPResponseInfo);
begin
  AResponseInfo.ContentType := 'application/json';
  AResponseInfo.ResponseNo := 200;
  AResponseInfo.ContentText := '{"status":"ok","message":"pong"}';
end;

// WinDev - GET /api/ping
PROCEDURE ProcédurePing(Requête est un httpRequête, Réponse est un httpRéponse)
    Réponse..TypeContenu = "application/json"
    Réponse..CodeStatut = 200

    vRéponse est un Variant
    vRéponse.status = "ok"
    vRéponse.message = "pong"

    Réponse..Contenu = VariantVersJSON(vRéponse)
FIN

// Node.js - GET /api/products
app.get('/api/products', async (req, res) => {
  const { updated_since, limit = 2000, offset = 0 } = req.query;

  let query = db.products.find({
    barcode: { $ne: null, $ne: '' }
  });

  if (updated_since) {
    query = query.where('updated_at').gte(new Date(updated_since));
  }

  const total = await db.products.countDocuments({
    barcode: { $ne: null, $ne: '' }
  });

  const products = await query
    .skip(parseInt(offset))
    .limit(Math.min(parseInt(limit), 2000))
    .exec();

  res.json({
    data: products.map(product => ({
      id: product._id,
      name: product.name,
      barcode: product.barcode,
      price: parseFloat(product.price),
      promo_price: product.promo_price ? parseFloat(product.promo_price) : null,
      server_id: product._id,
    })),
    pagination: {
      total,
      offset: parseInt(offset),
      limit: parseInt(limit),
      has_more: (parseInt(offset) + parseInt(limit)) < total,
    }
  });
});

// C# - GET /api/products
[HttpGet("products")]
public async Task GetProducts(
    [FromQuery] DateTime? updatedSince,
    [FromQuery] int limit = 2000,
    [FromQuery] int offset = 0)
{
    limit = Math.Min(limit, 2000);

    var query = _context.Products
        .Where(p => p.Barcode != null && p.Barcode != "");

    if (updatedSince.HasValue)
    {
        query = query.Where(p => p.UpdatedAt >= updatedSince.Value);
    }

    var total = await query.CountAsync();

    var products = await query
        .Skip(offset)
        .Take(limit)
        .Select(p => new
        {
            id = p.Id,
            name = p.Name,
            barcode = p.Barcode,
            price = p.Price,
            promo_price = (decimal?)p.PromoPrice,
            server_id = p.Id
        })
        .ToListAsync();

    return Ok(new
    {
        data = products,
        pagination = new
        {
            total,
            offset,
            limit,
            has_more = (offset + limit) < total
        }
    });
}

// Java - GET /api/products
@GetMapping("/api/products")
public ResponseEntity getProducts(
    @RequestParam(required = false) String updatedSince,
    @RequestParam(defaultValue = "2000") int limit,
    @RequestParam(defaultValue = "0") int offset) {

    limit = Math.min(limit, 2000);

    Specification spec = (root, query, cb) ->
        cb.and(
            cb.isNotNull(root.get("barcode")),
            cb.notEqual(root.get("barcode"), "")
        );

    if (updatedSince != null) {
        LocalDateTime date = LocalDateTime.parse(updatedSince);
        spec = spec.and((root, query, cb) ->
            cb.greaterThanOrEqualTo(root.get("updatedAt"), date));
    }

    long total = productRepository.count(spec);
    Pageable pageable = PageRequest.of(offset / limit, limit);
    Page page = productRepository.findAll(spec, pageable);

    List> products = page.getContent().stream()
        .map(p -> Map.of(
            "id", p.getId(),
            "name", p.getName(),
            "barcode", p.getBarcode(),
            "price", p.getPrice(),
            "promo_price", p.getPromoPrice(),
            "server_id", p.getId()
        ))
        .collect(Collectors.toList());

    return ResponseEntity.ok(Map.of(
        "data", products,
        "pagination", Map.of(
            "total", total,
            "offset", offset,
            "limit", limit,
            "has_more", offset + limit < total
        )
    ));
}

# Python - GET /api/products
from flask import Flask, request, jsonify
from datetime import datetime

@app.route('/api/products', methods=['GET'])
def get_products():
    updated_since = request.args.get('updated_since')
    limit = min(int(request.args.get('limit', 2000)), 2000)
    offset = int(request.args.get('offset', 0))

    query = Product.query.filter(
        Product.barcode.isnot(None),
        Product.barcode != ''
    )

    if updated_since:
        date = datetime.fromisoformat(updated_since.replace('Z', '+00:00'))
        query = query.filter(Product.updated_at >= date)

    total = query.count()
    products = query.offset(offset).limit(limit).all()

    return jsonify({
        'data': [{
            'id': p.id,
            'name': p.name,
            'barcode': p.barcode,
            'price': float(p.price),
            'promo_price': float(p.promo_price) if p.promo_price else None,
            'server_id': p.id
        } for p in products],
        'pagination': {
            'total': total,
            'offset': offset,
            'limit': limit,
            'has_more': (offset + limit) < total
        }
    })

// Delphi - GET /api/products
procedure GetProducts(const UpdatedSince: string; Limit, Offset: Integer);
var
  HttpClient: TNetHTTPClient;
  Response: IHTTPResponse;
  URL: string;
  JSONResponse: TJSONObject;
  Products: TJSONArray;
begin
  HttpClient := TNetHTTPClient.Create(nil);
  try
    URL := Format('https://api.example.com/api/products?limit=%d&offset=%d',
                  [Limit, Offset]);
    
    if UpdatedSince <> '' then
      URL := URL + '&updated_since=' + UpdatedSince;
    
    HttpClient.Accept := 'application/json';
    Response := HttpClient.Get(URL);
    
    if Response.StatusCode = 200 then
    begin
      JSONResponse := TJSONObject.ParseJSONValue(Response.ContentAsString) as TJSONObject;
      try
        if JSONResponse.GetValue('status').Value = 'success' then
        begin
          Products := JSONResponse.GetValue('data');
          // Process the products...
        end;
      finally
        JSONResponse.Free;
      end;
    end;
  finally
    HttpClient.Free;
  end;
end;

// WinDev - GET /api/products
PROCEDURE RécupérerProduits(dtDepuisMiseAJour est un DateHeure = "", nLimite est un entier = 2000, nOffset est un entier = 0)
    tabProduits est un tableau de STProduct

    sURL = gsURLAPI + "/api/products?"
    sURL += "limit=" + nLimite
    sURL += "&offset=" + nOffset

    SI dtDepuisMiseAJour <> "" ALORS
        sURL += "&updated_since=" + DateHeureVersISO8601(dtDepuisMiseAJour)
    FIN

    requeteHTTP est un httpRequête
    requeteHTTP.URL = sURL
    requeteHTTP.Méthode = httpGet

    tabEntetes est un tableau associatif de chaînes = ObtenirEntetes()
    POUR TOUT sValeur, sCle DE tabEntetes
        requeteHTTP.Entête[sCle] = sValeur
    FIN

    réponseHTTP est un httpRéponse = HTTPEnvoie(requeteHTTP)

    SI réponseHTTP.CodeEtat = 200 ALORS
        vJSON est un Variant = JSONVersVariant(réponseHTTP.Contenu)

        POUR TOUT vProduit DE vJSON.data
            stProduit est un STProduct
            stProduit.id = vProduit.id
            stProduit.name = vProduit.name
            stProduit.barcode = vProduit.barcode
            stProduit.price = vProduit.price
            stProduit.promo_price = vProduit.promo_price
            stProduit.server_id = vProduit.server_id

            Ajoute(tabProduits, stProduit)
        FIN
    FIN

    RENVOYER tabProduits
FIN

// Node.js - PUT or POST /api/products/:barcode/price
app.put('/api/products/:barcode/price', updatePrice);
app.post('/api/products/:barcode/price', updatePrice);

async function updatePrice(req, res) {
  const { barcode } = req.params;
  const { price, server_id } = req.body;
  
  if (!price || price < 0) {
    return res.status(400).json({
      status: 'error',
      error_code: 'INVALID_PRICE',
      message: 'Price must be a positive number'
    });
  }
  
  const product = await db.products.findOne({ barcode });
  
  if (!product) {
    return res.status(404).json({
      status: 'error',
      error_code: 'PRODUCT_NOT_FOUND',
      message: 'Product not found'
    });
  }
  
  const oldPrice = product.price;
  product.price = price;
  product.updated_at = new Date();
  await product.save();
  
  res.json({
    status: 'success',
    message: 'Price updated successfully',
    data: {
      server_id: product._id,
      barcode: product.barcode,
      old_price: parseFloat(oldPrice),
      new_price: parseFloat(price),
      updated_at: product.updated_at.toISOString(),
    }
  });
}

// C# - PUT or POST /api/products/{barcode}/price
[HttpPut("products/{barcode}/price")]
[HttpPost("products/{barcode}/price")]
public async Task UpdatePrice(
    string barcode,
    [FromBody] PriceUpdateRequest request)
{
    if (request.Price < 0)
    {
        return BadRequest(new ErrorResponse
        {
            ErrorCode = "INVALID_PRICE",
            Message = "Price must be a positive number"
        });
    }
    
    var product = await _context.Products
        .FirstOrDefaultAsync(p => p.Barcode == barcode);
    
    if (product == null)
    {
        return NotFound(new ErrorResponse
        {
            ErrorCode = "PRODUCT_NOT_FOUND",
            Message = "Product not found"
        });
    }
    
    var oldPrice = product.Price;
    product.Price = request.Price;
    product.UpdatedAt = DateTime.UtcNow;
    
    await _context.SaveChangesAsync();
    
    return Ok(new
    {
        status = "success",
        message = "Price updated successfully",
        data = new
        {
            server_id = product.Id,
            barcode = product.Barcode,
            old_price = oldPrice,
            new_price = product.Price,
            updated_at = product.UpdatedAt.ToString("yyyy-MM-dd'T'HH:mm:ss'Z'")
        }
    });
}

// Java - PUT or POST /api/products/{barcode}/price
@PutMapping("/api/products/{barcode}/price")
@PostMapping("/api/products/{barcode}/price")
public ResponseEntity updatePrice(
    @PathVariable String barcode,
    @RequestBody PriceUpdateRequest request) {
    
    if (request.getPrice().compareTo(BigDecimal.ZERO) < 0) {
        return ResponseEntity.badRequest().body(Map.of(
            "status", "error",
            "error_code", "INVALID_PRICE",
            "message", "Price must be a positive number"
        ));
    }
    
    Optional productOpt = productRepository.findByBarcode(barcode);
    
    if (productOpt.isEmpty()) {
        return ResponseEntity.status(404).body(Map.of(
            "status", "error",
            "error_code", "PRODUCT_NOT_FOUND",
            "message", "Product not found"
        ));
    }
    
    Product product = productOpt.get();
    BigDecimal oldPrice = product.getPrice();
    product.setPrice(request.getPrice());
    product.setUpdatedAt(LocalDateTime.now());
    
    productRepository.save(product);
    
    return ResponseEntity.ok(Map.of(
        "status", "success",
        "message", "Price updated successfully",
        "data", Map.of(
            "server_id", product.getId(),
            "barcode", product.getBarcode(),
            "old_price", oldPrice,
            "new_price", product.getPrice(),
            "updated_at", product.getUpdatedAt().toString()
        )
    ));
}

# Python - PUT or POST /api/products/{barcode}/price
@app.route('/api/products//price', methods=['PUT', 'POST'])
def update_price(barcode):
    data = request.get_json()
    
    if 'price' not in data or data['price'] < 0:
        return jsonify({
            'status': 'error',
            'error_code': 'INVALID_PRICE',
            'message': 'Price must be a positive number'
        }), 400
    
    product = Product.query.filter_by(barcode=barcode).first()
    
    if not product:
        return jsonify({
            'status': 'error',
            'error_code': 'PRODUCT_NOT_FOUND',
            'message': 'Product not found'
        }), 404
    
    old_price = product.price
    product.price = data['price']
    product.updated_at = datetime.utcnow()
    
    db.session.commit()
    
    return jsonify({
        'status': 'success',
        'message': 'Price updated successfully',
        'data': {
            'server_id': product.id,
            'barcode': product.barcode,
            'old_price': float(old_price),
            'new_price': float(product.price),
            'updated_at': product.updated_at.isoformat() + 'Z'
        }
    })

// Delphi - PUT or POST /api/products/{barcode}/price
procedure UpdatePrice(const Barcode: string; NewPrice: Currency; ServerID: Integer);
var
  HttpClient: TNetHTTPClient;
  Response: IHTTPResponse;
  RequestBody: TJSONObject;
  ResponseJSON: TJSONObject;
begin
  HttpClient := TNetHTTPClient.Create(nil);
  try
    RequestBody := TJSONObject.Create;
    try
      RequestBody.AddPair('barcode', Barcode);
      RequestBody.AddPair('price', TJSONNumber.Create(NewPrice));
      RequestBody.AddPair('server_id', TJSONNumber.Create(ServerID));
      
      HttpClient.ContentType := 'application/json';
      HttpClient.Accept := 'application/json';
      
      Response := HttpClient.Put(
        Format('https://api.example.com/api/products/%s/price', [Barcode]),
        TStringStream.Create(RequestBody.ToString, TEncoding.UTF8)
      );
      
      if Response.StatusCode = 200 then
      begin
        ResponseJSON := TJSONObject.ParseJSONValue(Response.ContentAsString) as TJSONObject;
        try
          ShowMessage('Price updated successfully');
        finally
          ResponseJSON.Free;
        end;
      end;
    finally
      RequestBody.Free;
    end;
  finally
    HttpClient.Free;
  end;
end;

// WinDev - PUT or POST /api/products/{barcode}/price
PROCEDURE MettreAJourPrix(sBarcode est une chaîne, mNouveauPrix est un monétaire, nServerID est un entier) : booléen
    vRequete est un Variant
    vRequete.barcode = sBarcode
    vRequete.price = mNouveauPrix
    vRequete.server_id = nServerID
    
    sJSONRequete = VariantVersJSON(vRequete)
    
    requeteHTTP est un httpRequête
    requeteHTTP.URL = gsURLAPI + "/api/products/" + sBarcode + "/price"
    requeteHTTP.Méthode = httpPut  // or httpPost
    requeteHTTP.Contenu = sJSONRequete
    
    tabEntetes est un tableau associatif de chaînes = ObtenirEntetes()
    POUR TOUT sValeur, sCle DE tabEntetes
        requeteHTTP.Entête[sCle] = sValeur
    FIN
    
    réponseHTTP est un httpRéponse = HTTPEnvoie(requeteHTTP)
    
    SI réponseHTTP.CodeEtat = 200 ALORS
        vRéponse est un Variant = JSONVersVariant(réponseHTTP.Contenu)
        SI vRéponse.status = "success" ALORS
            Info("Price updated", "Old: " + vRéponse.data.old_price, "New: " + vRéponse.data.new_price)
            RENVOYER Vrai
        FIN
    FIN
    
    RENVOYER Faux
FIN

// Node.js — Send a price change to izySCAN
async function pushPriceUpdate(izyscanHost, port, token, products) {
    const url = `http://${izyscanHost}:${port}/push_prices`;

    const headers = { 'Content-Type': 'application/json' };
    if (token) {
        headers['Authorization'] = `Bearer ${token}`;
    }

    const response = await fetch(url, {
        method: 'POST',
        headers,
        body: JSON.stringify({ products }),
    });

    return await response.json();
}

// Usage — Call this function on every price change
const result = await pushPriceUpdate('192.168.1.100', 8000, 'your_token', [
    {
        barcode: '6281001210016',
        name: 'Lait Entier 1L',
        price: 12.50,
        promo_price: 9.90,
    },
]);
console.log(`Result: ${result.updated} updated, ${result.created} created`);

// C# — Send a price change to izySCAN
public async Task<string> PushPriceUpdate(
    string izyscanHost, int port, string token, object[] products)
{
    using var client = new HttpClient();
    client.Timeout = TimeSpan.FromSeconds(10);

    if (!string.IsNullOrEmpty(token))
        client.DefaultRequestHeaders.Authorization =
            new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", token);

    var payload = new { products };
    var json = System.Text.Json.JsonSerializer.Serialize(payload);
    var content = new StringContent(json, Encoding.UTF8, "application/json");

    var response = await client.PostAsync(
        $"http://{izyscanHost}:{port}/push_prices", content);

    return await response.Content.ReadAsStringAsync();
}

// Usage — in your price-change event handler
var result = await PushPriceUpdate("192.168.1.100", 8000, "your_token",
    new object[] {
        new { barcode = "6281001210016", name = "Lait Entier 1L",
              price = 12.50, promo_price = 9.90 }
    });

// Java — Send a price change to izySCAN
import java.net.http.*;
import java.net.URI;

public String pushPriceUpdate(
        String host, int port, String token, String jsonProducts)
        throws Exception {

    HttpClient client = HttpClient.newBuilder()
        .connectTimeout(Duration.ofSeconds(10))
        .build();

    HttpRequest.Builder builder = HttpRequest.newBuilder()
        .uri(URI.create("http://" + host + ":" + port + "/push_prices"))
        .header("Content-Type", "application/json")
        .POST(HttpRequest.BodyPublishers.ofString(jsonProducts));

    if (token != null && !token.isEmpty()) {
        builder.header("Authorization", "Bearer " + token);
    }

    HttpResponse<String> response =
        client.send(builder.build(), HttpResponse.BodyHandlers.ofString());

    return response.body();
}

// Usage
String json = "{\"products\":[{\"barcode\":\"6281001210016\","
    + "\"name\":\"Lait Entier 1L\",\"price\":12.5,\"promo_price\":9.9}]}";
String result = pushPriceUpdate("192.168.1.100", 8000, "your_token", json);

# Python — Send a price change to izySCAN
import requests

def push_price_update(izyscan_host, port, token, products):
    url = f"http://{izyscan_host}:{port}/push_prices"

    headers = {"Content-Type": "application/json"}
    if token:
        headers["Authorization"] = f"Bearer {token}"

    response = requests.post(
        url,
        json={"products": products},
        headers=headers,
        timeout=10,
    )
    response.raise_for_status()
    return response.json()

# Usage — call on every price change in your system
result = push_price_update("192.168.1.100", 8000, "your_token", [
    {
        "barcode": "6281001210016",
        "name": "Lait Entier 1L",
        "price": 12.50,
        "promo_price": 9.90,
    },
])
print(f"Updated: {result['updated']}, Created: {result['created']}")

// Delphi — Send a price change to izySCAN
uses System.Net.HttpClient, System.JSON;

function PushPriceUpdate(const AIzyScanHost: string; APort: Integer;
  const AToken: string; AProducts: TJSONArray): TJSONObject;
var
  LClient: THTTPClient;
  LResponse: IHTTPResponse;
  LPayload: TJSONObject;
  LContent: TStringStream;
begin
  LClient := THTTPClient.Create;
  try
    LClient.ConnectionTimeout := 10000;
    LClient.ContentType := 'application/json';

    if AToken <> '' then
      LClient.CustomHeaders['Authorization'] := 'Bearer ' + AToken;

    LPayload := TJSONObject.Create;
    LPayload.AddPair('products', AProducts);

    LContent := TStringStream.Create(LPayload.ToJSON, TEncoding.UTF8);
    try
      LResponse := LClient.Post(
        Format('http://%s:%d/push_prices', [AIzyScanHost, APort]),
        LContent);

      Result := TJSONObject.ParseJSONValue(
        LResponse.ContentAsString) as TJSONObject;
    finally
      LContent.Free;
      LPayload.Free;
    end;
  finally
    LClient.Free;
  end;
end;

// Usage
var Products := TJSONArray.Create;
var Product := TJSONObject.Create;
Product.AddPair('barcode', '6281001210016');
Product.AddPair('name', 'Lait Entier 1L');
Product.AddPair('price', TJSONNumber.Create(12.50));
Product.AddPair('promo_price', TJSONNumber.Create(9.90));
Products.Add(Product);

var Result := PushPriceUpdate('192.168.1.100', 8000, 'your_token', Products);

// WinDev — Send a price change to izySCAN
PROCÉDURE PushPriceUpdate(sHôte est une chaîne,
    nPort est un entier, sToken est une chaîne,
    tabProduits est un tableau de STProductPush)

    sURL est une chaîne = ChaîneConstruit(
        "http://%1:%2/push_prices", sHôte, nPort)

    // Build the JSON
    vPayload est un Variant
    vPayload.products = tabProduits
    sJSON est une chaîne = VariantVersJSON(vPayload)

    // Prepare the request
    cRequête est un httpRequête
    cRequête.URL = sURL
    cRequête.Méthode = httpPost
    cRequête.ContentType = "application/json"
    cRequête.Contenu = sJSON
    cRequête.Timeout = 10s

    SI sToken <> "" ALORS
        cRequête.Entête["Authorization"] = "Bearer " + sToken
    FIN

    // Send
    cRéponse est un httpRéponse = HTTPEnvoie(cRequête)

    SI cRéponse.CodeEtat = 200 ALORS
        Info("Prices updated successfully")
    SINON
        Erreur("Failed: " + cRéponse.Contenu)
    FIN

FIN

// Usage — call whenever a price is changed
stProduit est un STProductPush
stProduit.barcode = "6281001210016"
stProduit.name = "Lait Entier 1L"
stProduit.price = 12.50
stProduit.promo_price = 9.90

tabProduits est un tableau de STProductPush
Ajoute(tabProduits, stProduit)

PushPriceUpdate("192.168.1.100", 8000, "your_token", tabProduits)

// Node.js - POST /api/inventories
app.post('/api/inventories', async (req, res) => {
  const { name, date_created, date_started, date_finished, lines } = req.body;

  // Validation
  if (!name || !date_created || !lines || !Array.isArray(lines)) {
    return res.status(400).json({
      error: 'VALIDATION_ERROR',
      message: 'Missing required data'
    });
  }

  const session = await mongoose.startSession();
  session.startTransaction();

  try {
    const inventory = new Inventory({
      name,
      date_created: new Date(date_created),
      date_started: date_started ? new Date(date_started) : null,
      date_finished: date_finished ? new Date(date_finished) : null
    });

    await inventory.save({ session });

    let totalQuantity = 0;
    const inventoryLines = [];

    for (const line of lines) {
      const inventoryLine = new InventoryLine({
        inventory_id: inventory._id,
        barcode: line.barcode,
        quantity: line.quantity,
        scanned_at: new Date(line.scanned_at)
      });

      inventoryLines.push(inventoryLine);
      totalQuantity += line.quantity;
    }

    await InventoryLine.insertMany(inventoryLines, { session });

    await session.commitTransaction();

    res.status(201).json({
      status: 'success',
      message: 'Inventory created successfully',
      data: {
        inventory_id: inventory._id,
        lines_processed: lines.length,
        total_quantity: totalQuantity
      }
    });

  } catch (error) {
    await session.abortTransaction();
    res.status(500).json({
      error: 'INTERNAL_ERROR',
      message: 'Error while creating the inventory'
    });
  } finally {
    session.endSession();
  }
});

// C# - POST /api/inventories
[HttpPost("inventories")]
public async Task CreateInventory([FromBody] InventoryRequest request)
{
    if (!ModelState.IsValid)
    {
        return BadRequest(new { error = "VALIDATION_ERROR", message = "Invalid data" });
    }

    using var transaction = await _context.Database.BeginTransactionAsync();

    try
    {
        var inventory = new Inventory
        {
            Name = request.Name,
            DateCreated = request.DateCreated,
            DateStarted = request.DateStarted,
            DateFinished = request.DateFinished
        };

        _context.Inventories.Add(inventory);
        await _context.SaveChangesAsync();

        var inventoryLines = request.Lines.Select(line => new InventoryLine
        {
            InventoryId = inventory.Id,
            Barcode = line.Barcode,
            Quantity = line.Quantity,
            ScannedAt = line.ScannedAt
        }).ToList();

        _context.InventoryLines.AddRange(inventoryLines);
        await _context.SaveChangesAsync();

        await transaction.CommitAsync();

        var totalQuantity = request.Lines.Sum(l => l.Quantity);

        return StatusCode(201, new
        {
            status = "success",
            message = "Inventory created successfully",
            data = new
            {
                inventory_id = inventory.Id,
                lines_processed = request.Lines.Count,
                total_quantity = totalQuantity
            }
        });
    }
    catch (Exception)
    {
        await transaction.RollbackAsync();
        return StatusCode(500, new { error = "INTERNAL_ERROR", message = "Error while creating the inventory" });
    }
}

// Java - POST /api/inventories
@PostMapping("/api/inventories")
@Transactional
public ResponseEntity createInventory(@RequestBody @Valid InventoryRequest request) {
    try {
        Inventory inventory = new Inventory();
        inventory.setName(request.getName());
        inventory.setDateCreated(request.getDateCreated());
        inventory.setDateStarted(request.getDateStarted());
        inventory.setDateFinished(request.getDateFinished());

        inventory = inventoryRepository.save(inventory);

        List lines = new ArrayList<>();
        BigDecimal totalQuantity = BigDecimal.ZERO;

        for (InventoryLineRequest lineRequest : request.getLines()) {
            InventoryLine line = new InventoryLine();
            line.setInventory(inventory);
            line.setBarcode(lineRequest.getBarcode());
            line.setQuantity(lineRequest.getQuantity());
            line.setScannedAt(lineRequest.getScannedAt());

            lines.add(line);
            totalQuantity = totalQuantity.add(lineRequest.getQuantity());
        }

        inventoryLineRepository.saveAll(lines);

        return ResponseEntity.status(201).body(Map.of(
            "status", "success",
            "message", "Inventory created successfully",
            "data", Map.of(
                "inventory_id", inventory.getId(),
                "lines_processed", lines.size(),
                "total_quantity", totalQuantity
            )
        ));

    } catch (Exception e) {
        return ResponseEntity.status(500).body(Map.of(
            "error", "INTERNAL_ERROR",
            "message", "Error while creating the inventory"
        ));
    }
}

# Python - POST /api/inventories
@app.route('/api/inventories', methods=['POST'])
def create_inventory():
    data = request.get_json()

    # Validation
    required_fields = ['name', 'date_created', 'lines']
    for field in required_fields:
        if field not in data:
            return jsonify({
                'error': 'VALIDATION_ERROR',
                'message': f'Missing required field: {field}'
            }), 400

    try:
        inventory = Inventory(
            name=data['name'],
            date_created=datetime.fromisoformat(data['date_created'].replace('Z', '+00:00')),
            date_started=datetime.fromisoformat(data['date_started'].replace('Z', '+00:00')) if data.get('date_started') else None,
            date_finished=datetime.fromisoformat(data['date_finished'].replace('Z', '+00:00')) if data.get('date_finished') else None
        )

        db.session.add(inventory)
        db.session.flush()  # To obtain the ID

        total_quantity = 0
        for line_data in data['lines']:
            line = InventoryLine(
                inventory_id=inventory.id,
                barcode=line_data['barcode'],
                quantity=line_data['quantity'],
                scanned_at=datetime.fromisoformat(line_data['scanned_at'].replace('Z', '+00:00'))
            )
            db.session.add(line)
            total_quantity += line_data['quantity']

        db.session.commit()

        return jsonify({
            'status': 'success',
            'message': 'Inventory created successfully',
            'data': {
                'inventory_id': inventory.id,
                'lines_processed': len(data['lines']),
                'total_quantity': total_quantity
            }
        }), 201

    except Exception as e:
        db.session.rollback()
        return jsonify({
            'error': 'INTERNAL_ERROR',
            'message': 'Error while creating the inventory'
        }), 500

// Delphi - POST /api/inventories
procedure CreateInventory(const InventoryData: TInventoryRequest);
var
  HttpClient: TNetHTTPClient;
  Response: IHTTPResponse;
  RequestJSON, LineJSON: TJSONObject;
  LinesArray: TJSONArray;
  Line: TInventoryLine;
  ResponseJSON: TJSONObject;
begin
  HttpClient := TNetHTTPClient.Create(nil);
  try
    RequestJSON := TJSONObject.Create;
    try
      RequestJSON.AddPair('name', InventoryData.Name);
      RequestJSON.AddPair('date_created', DateTimeToISO8601(InventoryData.DateCreated));
      if InventoryData.DateStarted > 0 then
        RequestJSON.AddPair('date_started', DateTimeToISO8601(InventoryData.DateStarted));
      if InventoryData.DateFinished > 0 then
        RequestJSON.AddPair('date_finished', DateTimeToISO8601(InventoryData.DateFinished));

      LinesArray := TJSONArray.Create;
      for Line in InventoryData.Lines do
      begin
        LineJSON := TJSONObject.Create;
        LineJSON.AddPair('barcode', Line.Barcode);
        LineJSON.AddPair('quantity', TJSONNumber.Create(Line.Quantity));
        LineJSON.AddPair('scanned_at', DateTimeToISO8601(Line.ScannedAt));
        LinesArray.AddElement(LineJSON);
      end;
      RequestJSON.AddPair('lines', LinesArray);

      HttpClient.ContentType := 'application/json';
      HttpClient.Accept := 'application/json';

      Response := HttpClient.Post(
        'https://api.example.com/api/inventories',
        TStringStream.Create(RequestJSON.ToString, TEncoding.UTF8)
      );

      if Response.StatusCode = 201 then
      begin
        ResponseJSON := TJSONObject.ParseJSONValue(Response.ContentAsString) as TJSONObject;
        try
          if ResponseJSON.GetValue('status').Value = 'success' then
            ShowMessage('Inventory created successfully');
        finally
          ResponseJSON.Free;
        end;
      end;
    finally
      RequestJSON.Free;
    end;
  finally
    HttpClient.Free;
  end;
end;

// WinDev - POST /api/inventories
PROCEDURE CréerInventaire(sNom est une chaîne, dtDateCreated est un DateHeure, dtDateStarted est un DateHeure = "", dtDateFinished est un DateHeure = "", tabLignes est un tableau de STInventoryLine) : entier
    vInventaire est un Variant
    vInventaire.name = sNom
    vInventaire.date_created = DateHeureVersISO8601(dtDateCreated)

    SI dtDateStarted <> "" ALORS
        vInventaire.date_started = DateHeureVersISO8601(dtDateStarted)
    FIN
    SI dtDateFinished <> "" ALORS
        vInventaire.date_finished = DateHeureVersISO8601(dtDateFinished)
    FIN

    Dimension(vInventaire.lines, 0)
    POUR TOUT stLigne DE tabLignes
        vLigne est un Variant
        vLigne.barcode = stLigne.barcode
        vLigne.quantity = stLigne.quantity
        vLigne.scanned_at = stLigne.scanned_at

        Ajoute(vInventaire.lines, vLigne)
    FIN

    sJSONRequete = VariantVersJSON(vInventaire)

    requeteHTTP est un httpRequête
    requeteHTTP.URL = gsURLAPI + "/api/inventories"
    requeteHTTP.Méthode = httpPost
    requeteHTTP.Contenu = sJSONRequete

    tabEntetes est un tableau associatif de chaînes = ObtenirEntetes()
    POUR TOUT sValeur, sCle DE tabEntetes
        requeteHTTP.Entête[sCle] = sValeur
    FIN

    réponseHTTP est un httpRéponse = HTTPEnvoie(requeteHTTP)

    SI réponseHTTP.CodeEtat = 201 ALORS
        vRéponse est un Variant = JSONVersVariant(réponseHTTP.Contenu)
        SI vRéponse.status = "success" ALORS
            Info("Inventory created", "ID: " + vRéponse.data.inventory_id)
            RENVOYER vRéponse.data.inventory_id
        FIN
    FIN

    RENVOYER 0
FIN