Code Samples

Complete client implementations in Python, Java, and Node.js.

The following examples demonstrate full API client implementations with authentication, product creation, document creation, and stock queries. Adapt them to your language and framework of choice.

Python

import requests
import time


class LogisticsWMSClient:
    """Complete Python client for the LogisticsWMS External API."""

    def __init__(self, base_url, client_id, client_secret):
        self.base_url = base_url.rstrip("/")
        self.client_id = client_id
        self.client_secret = client_secret
        self.token = None
        self.token_expires_at = 0

    def authenticate(self):
        """Obtain or refresh the API client access token."""
        if self.token and time.time() < self.token_expires_at:
            return self.token

        response = requests.post(
            f"{self.base_url}/api/external/v1/auth/token",
            data={
                "client_id": self.client_id,
                "client_secret": self.client_secret,
            },
        )
        response.raise_for_status()
        data = response.json()
        self.token = data["access_token"]
        self.token_expires_at = time.time() + data["expires_in"] - 300
        return self.token

    def _headers(self):
        return {
            "Authorization": f"Bearer {self.authenticate()}",
            "Content-Type": "application/json",
        }

    def create_product(self, external_code, description, barcode=None, **kwargs):
        """Create a new product in the WMS."""
        payload = {
            "externalCode": external_code,
            "description": description,
        }
        if barcode:
            payload["barcode"] = barcode
        payload.update(kwargs)

        response = requests.post(
            f"{self.base_url}/api/external/v1/product",
            headers=self._headers(),
            json=payload,
        )
        response.raise_for_status()
        return response.json()

    def create_document(self, external_code, document_type, lines, **kwargs):
        """Create a new warehouse document."""
        payload = {
            "externalCode": external_code,
            "documentType": document_type,
            "lines": lines,
        }
        payload.update(kwargs)

        response = requests.post(
            f"{self.base_url}/api/external/v1/document",
            headers=self._headers(),
            json=payload,
        )
        response.raise_for_status()
        return response.json()

    def get_stock(self, external_codes):
        """Query stock levels for one or more products."""
        response = requests.post(
            f"{self.base_url}/api/external/v1/product/stock",
            headers=self._headers(),
            json={"externalCodes": external_codes},
        )
        response.raise_for_status()
        return response.json()


# Usage
client = LogisticsWMSClient(
    base_url="https://app.logistics-wms.com",
    client_id="YOUR_CLIENT_ID",
    client_secret="YOUR_CLIENT_SECRET",
)

# Create a product
product = client.create_product(
    external_code="ERP-SKU-001",
    description="Wireless Bluetooth Headphones",
    barcode="5901234123457",
    weight=0.35,
)
print(f"Product created: {product['externalCode']}")

# Create a purchase order
document = client.create_document(
    external_code="PO-2026-0001",
    document_type="PURCHASE_ORDER",
    originCode="SUPPLIER-ACME",
    lines=[{"externalCode": "ERP-SKU-001", "quantity": 500, "lineNumber": 1}],
)
print(f"Document created: {document['externalCode']} ({document['status']})")

# Query stock
stock = client.get_stock(["ERP-SKU-001"])
for item in stock:
    print(f"{item['externalCode']}: {item['available']} available")

Java

import org.springframework.http.*;
import org.springframework.web.client.RestTemplate;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.util.*;

public class LogisticsWMSClient {

    private final String baseUrl;
    private final String clientId;
    private final String clientSecret;
    private final RestTemplate restTemplate = new RestTemplate();
    private final ObjectMapper mapper = new ObjectMapper();
    private String token;
    private long tokenExpiresAt;

    public LogisticsWMSClient(String baseUrl, String clientId,
                               String clientSecret) {
        this.baseUrl = baseUrl;
        this.clientId = clientId;
        this.clientSecret = clientSecret;
    }

    public String authenticate() {
        if (token != null && System.currentTimeMillis() / 1000 < tokenExpiresAt) {
            return token;
        }

        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);
        String body = "client_id=" + clientId + "&client_secret=" + clientSecret;
        HttpEntity<String> request = new HttpEntity<>(body, headers);

        ResponseEntity<JsonNode> response = restTemplate.postForEntity(
            baseUrl + "/api/external/v1/auth/token",
            request, JsonNode.class);

        JsonNode data = response.getBody();
        token = data.get("access_token").asText();
        tokenExpiresAt = System.currentTimeMillis() / 1000
            + data.get("expires_in").asLong() - 300;
        return token;
    }

    private HttpHeaders authHeaders() {
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);
        headers.setBearerAuth(authenticate());
        return headers;
    }

    public JsonNode createProduct(Map<String, Object> product) {
        HttpEntity<Map<String, Object>> request =
            new HttpEntity<>(product, authHeaders());
        ResponseEntity<JsonNode> response = restTemplate.postForEntity(
            baseUrl + "/api/external/v1/product", request, JsonNode.class);
        return response.getBody();
    }

    public JsonNode getStock(List<String> externalCodes) {
        Map<String, Object> body = Map.of("externalCodes", externalCodes);
        HttpEntity<Map<String, Object>> request =
            new HttpEntity<>(body, authHeaders());
        ResponseEntity<JsonNode> response = restTemplate.postForEntity(
            baseUrl + "/api/external/v1/product/stock",
            request, JsonNode.class);
        return response.getBody();
    }
}

// Usage
LogisticsWMSClient client = new LogisticsWMSClient(
    "https://app.logistics-wms.com",
    "YOUR_CLIENT_ID",
    "YOUR_CLIENT_SECRET"
);

// Create a product
JsonNode product = client.createProduct(Map.of(
    "externalCode", "ERP-SKU-001",
    "description", "Wireless Bluetooth Headphones",
    "barcode", "5901234123457",
    "weight", 0.35
));
System.out.println("Product created: " + product.get("externalCode").asText());

// Query stock
JsonNode stock = client.getStock(List.of("ERP-SKU-001"));
System.out.println("Stock: " + stock.toPrettyString());

Node.js

const axios = require("axios");

class LogisticsWMSClient {
  constructor(baseUrl, clientId, clientSecret) {
    this.baseUrl = baseUrl.replace(/\/$/, "");
    this.clientId = clientId;
    this.clientSecret = clientSecret;
    this.token = null;
    this.tokenExpiresAt = 0;
  }

  async authenticate() {
    if (this.token && Date.now() / 1000 < this.tokenExpiresAt) {
      return this.token;
    }

    const response = await axios.post(
      `${this.baseUrl}/api/external/v1/auth/token`,
      `client_id=${this.clientId}&client_secret=${this.clientSecret}`,
      { headers: { "Content-Type": "application/x-www-form-urlencoded" } }
    );

    this.token = response.data.access_token;
    this.tokenExpiresAt = Date.now() / 1000 + response.data.expires_in - 300;
    return this.token;
  }

  async _headers() {
    const token = await this.authenticate();
    return {
      Authorization: `Bearer ${token}`,
      "Content-Type": "application/json",
    };
  }

  async createProduct(product) {
    const headers = await this._headers();
    const response = await axios.post(
      `${this.baseUrl}/api/external/v1/product`,
      product,
      { headers }
    );
    return response.data;
  }

  async getStock(externalCodes) {
    const headers = await this._headers();
    const response = await axios.post(
      `${this.baseUrl}/api/external/v1/product/stock`,
      { externalCodes },
      { headers }
    );
    return response.data;
  }
}

// Usage
(async () => {
  const client = new LogisticsWMSClient(
    "https://app.logistics-wms.com",
    "YOUR_CLIENT_ID",
    "YOUR_CLIENT_SECRET"
  );

  // Create a product
  const product = await client.createProduct({
    externalCode: "ERP-SKU-001",
    description: "Wireless Bluetooth Headphones",
    barcode: "5901234123457",
    weight: 0.35,
  });
  console.log(`Product created: ${product.externalCode}`);

  // Query stock
  const stock = await client.getStock(["ERP-SKU-001"]);
  stock.forEach((item) => {
    console.log(`${item.externalCode}: ${item.available} available`);
  });
})();