📡 Documentation API IzyScan Server

// Node.js - GET /api/products
app.get('/api/products', async (req, res) => {
  const { updated_since, limit = 1000, offset = 0 } = req.query;
  
  let query = db.products.find({ barcode: { $ne: null } });
  
  if (updated_since) {
    query = query.where('updated_at').gte(new Date(updated_since));
  }
  
  const products = await query
    .skip(parseInt(offset))
    .limit(Math.min(parseInt(limit), 1000))
    .exec();
    
  const total = await db.products.countDocuments({ barcode: { $ne: null } });
  
  res.json({
    status: 'success',
    data: products.map(product => ({
      server_id: product._id,
      barcode: product.barcode,
      name: product.name,
      price: parseFloat(product.price),
      promo_price: parseFloat(product.promo_price || 0),
      created_at: product.created_at.toISOString(),
      updated_at: product.updated_at.toISOString(),
    })),
    pagination: {
      total,
      limit: parseInt(limit),
      offset: parseInt(offset),
      has_more: (parseInt(offset) + parseInt(limit)) < total,
    }
  });
});

// C# - GET /api/products
[HttpGet("products")]
public async Task GetProducts(
    [FromQuery] DateTime? updatedSince,
    [FromQuery] int limit = 1000,
    [FromQuery] int offset = 0)
{
    limit = Math.Min(limit, 1000);
    
    var query = _context.Products
        .Where(p => p.Barcode != null);
    
    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
        {
            server_id = p.Id,
            barcode = p.Barcode,
            name = p.Name,
            price = p.Price,
            promo_price = p.PromoPrice,
            created_at = p.CreatedAt.ToString("yyyy-MM-dd'T'HH:mm:ss'Z'"),
            updated_at = p.UpdatedAt.ToString("yyyy-MM-dd'T'HH:mm:ss'Z'")
        })
        .ToListAsync();
    
    return Ok(new
    {
        status = "success",
        data = products,
        pagination = new
        {
            total,
            limit,
            offset,
            has_more = (offset + limit) < total
        }
    });
}

// Java - GET /api/products
@GetMapping("/api/products")
public ResponseEntity getProducts(
    @RequestParam(required = false) String updatedSince,
    @RequestParam(defaultValue = "1000") int limit,
    @RequestParam(defaultValue = "0") int offset) {
    
    limit = Math.min(limit, 1000);
    
    Specification spec = (root, query, cb) -> 
        cb.isNotNull(root.get("barcode"));
    
    if (updatedSince != null) {
        LocalDateTime date = LocalDateTime.parse(updatedSince);
        spec = spec.and((root, query, cb) -> 
            cb.greaterThanOrEqualTo(root.get("updatedAt"), date));
    }
    
    Pageable pageable = PageRequest.of(offset / limit, limit);
    Page page = productRepository.findAll(spec, pageable);
    
    List> products = page.getContent().stream()
        .map(p -> Map.of(
            "server_id", p.getId(),
            "barcode", p.getBarcode(),
            "name", p.getName(),
            "price", p.getPrice(),
            "promo_price", p.getPromoPrice(),
            "created_at", p.getCreatedAt().toString(),
            "updated_at", p.getUpdatedAt().toString()
        ))
        .collect(Collectors.toList());
    
    return ResponseEntity.ok(Map.of(
        "status", "success",
        "data", products,
        "pagination", Map.of(
            "total", page.getTotalElements(),
            "limit", limit,
            "offset", offset,
            "has_more", offset + limit < page.getTotalElements()
        )
    ));
}

# 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', 1000)), 1000)
    offset = int(request.args.get('offset', 0))
    
    query = Product.query.filter(Product.barcode.isnot(None))
    
    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({
        'status': 'success',
        'data': [{
            'server_id': p.id,
            'barcode': p.barcode,
            'name': p.name,
            'price': float(p.price),
            'promo_price': float(p.promo_price) if p.promo_price else None,
            'created_at': p.created_at.isoformat() + 'Z',
            'updated_at': p.updated_at.isoformat() + 'Z'
        } for p in products],
        'pagination': {
            'total': total,
            'limit': limit,
            'offset': offset,
            '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 = 1000, 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)
        
        SI vJSON.status = "success" ALORS
            POUR TOUT vProduit DE vJSON.data
                stProduit est un STProduct
                stProduit.server_id = vProduit.server_id
                stProduit.barcode = vProduit.barcode
                stProduit.name = vProduit.name
                stProduit.price = vProduit.price
                
                Ajoute(tabProduits, stProduit)
            FIN
        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, device_id, status, lines, created_at, updated_at, started_at, finished_at } = req.body;
  
  // Validation
  if (!name || !device_id || !status || !lines || !Array.isArray(lines)) {
    return res.status(400).json({
      status: 'error',
      message: 'Données requises manquantes'
    });
  }
  
  const session = await mongoose.startSession();
  session.startTransaction();
  
  try {
    const inventory = new Inventory({
      name,
      device_id,
      status,
      created_at: created_at || new Date(),
      updated_at: updated_at || new Date(),
      started_at,
      finished_at
    });
    
    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,
        product_name: line.product_name,
        quantity: line.quantity,
        scanned_at: 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({
      status: '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 ErrorResponse
        {
            ErrorCode = "VALIDATION_ERROR",
            Message = "Données invalides"
        });
    }
    
    using var transaction = await _context.Database.BeginTransactionAsync();
    
    try
    {
        var inventory = new Inventory
        {
            Name = request.Name,
            DeviceId = request.DeviceId,
            Status = request.Status,
            CreatedAt = request.CreatedAt,
            UpdatedAt = request.UpdatedAt,
            StartedAt = request.StartedAt,
            FinishedAt = request.FinishedAt
        };
        
        _context.Inventories.Add(inventory);
        await _context.SaveChangesAsync();
        
        var inventoryLines = request.Lines.Select(line => new InventoryLine
        {
            InventoryId = inventory.Id,
            Barcode = line.Barcode,
            ProductName = line.ProductName,
            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 ErrorResponse
        {
            ErrorCode = "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.setDeviceId(request.getDeviceId());
        inventory.setStatus(request.getStatus());
        inventory.setCreatedAt(request.getCreatedAt());
        inventory.setUpdatedAt(request.getUpdatedAt());
        inventory.setStartedAt(request.getStartedAt());
        inventory.setFinishedAt(request.getFinishedAt());
        
        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.setProductName(lineRequest.getProductName());
            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(
            "status", "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', 'device_id', 'status', 'lines']
    for field in required_fields:
        if field not in data:
            return jsonify({
                'status': 'error',
                'message': f'Champ requis manquant: {field}'
            }), 400
    
    try:
        # Début de transaction
        inventory = Inventory(
            name=data['name'],
            device_id=data['device_id'],
            status=data['status'],
            created_at=datetime.fromisoformat(data.get('created_at', datetime.utcnow().isoformat())),
            updated_at=datetime.fromisoformat(data.get('updated_at', datetime.utcnow().isoformat())),
            started_at=datetime.fromisoformat(data['started_at']) if 'started_at' in data else None,
            finished_at=datetime.fromisoformat(data['finished_at']) if 'finished_at' in data 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'],
                product_name=line_data['product_name'],
                quantity=line_data['quantity'],
                scanned_at=datetime.fromisoformat(line_data['scanned_at'])
            )
            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({
            'status': '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('device_id', InventoryData.DeviceId);
      RequestJSON.AddPair('status', InventoryData.Status);
      RequestJSON.AddPair('created_at', DateTimeToISO8601(InventoryData.CreatedAt));
      RequestJSON.AddPair('updated_at', DateTimeToISO8601(InventoryData.UpdatedAt));
      RequestJSON.AddPair('started_at', DateTimeToISO8601(InventoryData.StartedAt));
      RequestJSON.AddPair('finished_at', DateTimeToISO8601(InventoryData.FinishedAt));
      
      LinesArray := TJSONArray.Create;
      for Line in InventoryData.Lines do
      begin
        LineJSON := TJSONObject.Create;
        LineJSON.AddPair('barcode', Line.Barcode);
        LineJSON.AddPair('product_name', Line.ProductName);
        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, sDeviceID est une chaîne, tabLignes est un tableau de STInventoryLine) : entier
    vInventaire est un Variant
    vInventaire.name = sNom
    vInventaire.device_id = sDeviceID
    vInventaire.status = "finished"
    vInventaire.created_at = DateHeureVersISO8601(DateHeureSys())
    vInventaire.updated_at = DateHeureVersISO8601(DateHeureSys())
    vInventaire.started_at = DateHeureVersISO8601(DateHeureSys())
    vInventaire.finished_at = DateHeureVersISO8601(DateHeureSys())
    
    Dimension(vInventaire.lines, 0)
    POUR TOUT stLigne DE tabLignes
        vLigne est un Variant
        vLigne.barcode = stLigne.barcode
        vLigne.product_name = stLigne.product_name
        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