📡 Documentation API IzyScan Server

// 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');
          // Traiter les produits...
        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 ou 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: 'Le prix doit être un nombre positif'
    });
  }
  
  const product = await db.products.findOne({ barcode });
  
  if (!product) {
    return res.status(404).json({
      status: 'error',
      error_code: 'PRODUCT_NOT_FOUND',
      message: 'Produit non trouvé'
    });
  }
  
  const oldPrice = product.price;
  product.price = price;
  product.updated_at = new Date();
  await product.save();
  
  res.json({
    status: 'success',
    message: 'Prix mis à jour avec succès',
    data: {
      server_id: product._id,
      barcode: product.barcode,
      old_price: parseFloat(oldPrice),
      new_price: parseFloat(price),
      updated_at: product.updated_at.toISOString(),
    }
  });
}

// C# - PUT ou 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 = "Le prix doit être un nombre positif"
        });
    }
    
    var product = await _context.Products
        .FirstOrDefaultAsync(p => p.Barcode == barcode);
    
    if (product == null)
    {
        return NotFound(new ErrorResponse
        {
            ErrorCode = "PRODUCT_NOT_FOUND",
            Message = "Produit non trouvé"
        });
    }
    
    var oldPrice = product.Price;
    product.Price = request.Price;
    product.UpdatedAt = DateTime.UtcNow;
    
    await _context.SaveChangesAsync();
    
    return Ok(new
    {
        status = "success",
        message = "Prix mis à jour avec succès",
        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 ou 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", "Le prix doit être un nombre positif"
        ));
    }
    
    Optional productOpt = productRepository.findByBarcode(barcode);
    
    if (productOpt.isEmpty()) {
        return ResponseEntity.status(404).body(Map.of(
            "status", "error",
            "error_code", "PRODUCT_NOT_FOUND",
            "message", "Produit non trouvé"
        ));
    }
    
    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", "Prix mis à jour avec succès",
        "data", Map.of(
            "server_id", product.getId(),
            "barcode", product.getBarcode(),
            "old_price", oldPrice,
            "new_price", product.getPrice(),
            "updated_at", product.getUpdatedAt().toString()
        )
    ));
}

# Python - PUT ou 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': 'Le prix doit être un nombre positif'
        }), 400
    
    product = Product.query.filter_by(barcode=barcode).first()
    
    if not product:
        return jsonify({
            'status': 'error',
            'error_code': 'PRODUCT_NOT_FOUND',
            'message': 'Produit non trouvé'
        }), 404
    
    old_price = product.price
    product.price = data['price']
    product.updated_at = datetime.utcnow()
    
    db.session.commit()
    
    return jsonify({
        'status': 'success',
        'message': 'Prix mis à jour avec succès',
        '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 ou 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('Prix mis à jour avec succès');
        finally
          ResponseJSON.Free;
        end;
      end;
    finally
      RequestBody.Free;
    end;
  finally
    HttpClient.Free;
  end;
end;

// WinDev - PUT ou 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  // ou 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("Prix mis à jour", "Ancien: " + vRéponse.data.old_price, "Nouveau: " + vRéponse.data.new_price)
            RENVOYER Vrai
        FIN
    FIN
    
    RENVOYER Faux
FIN

// 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: 'Données requises manquantes'
    });
  }

  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: 'Inventaire créé avec succès',
      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: 'Erreur lors de la création de l\'inventaire'
    });
  } 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 = "Données invalides" });
    }

    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 = "Inventaire créé avec succès",
            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 = "Erreur lors de la création de l'inventaire" });
    }
}

// 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", "Inventaire créé avec succès",
            "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", "Erreur lors de la création de l'inventaire"
        ));
    }
}

# 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'Champ requis manquant: {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()  # Pour obtenir l'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': 'Inventaire créé avec succès',
            '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': 'Erreur lors de la création de l\'inventaire'
        }), 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('Inventaire créé avec succès');
        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("Inventaire créé", "ID: " + vRéponse.data.inventory_id)
            RENVOYER vRéponse.data.inventory_id
        FIN
    FIN

    RENVOYER 0
FIN