Click Reply™ WMS Integration with CubeMaster API

A step-by-step guide to integrate Click Reply™ Warehouse Management System with the CubeMaster API POST /loads endpoint.

Current Date: March 10, 2025

Overview

Endpoint: https://api.cubemaster.net/loads

Method: POST

Purpose: Builds an optimized load plan for a mixed truck load based on cargo items, container specifications, and rules.

What is a RESTful API? (For Beginners)

A RESTful API (Representational State Transfer) is a way for programs to talk to each other over the internet, like a waiter taking your order to the kitchen. It uses standard web commands (called HTTP methods) such as:

  • GET: Retrieve information (e.g., fetch a load plan).
  • POST: Send data to create something (e.g., build a new load plan, as we’re doing here).
  • PUT: Update existing data.
  • DELETE: Remove data.

RESTful APIs use URLs (like /loads) to specify what you’re working with, and they often send/receive data in JSON format—a lightweight, readable way to structure information (like a digital packing list).

Signing Up for CubeMaster API

To use the CubeMaster API, you need an API key (TokenID) for authentication. Here's how to get started:

  1. Visit the CubeMaster website: https://cubemaster.net.
  2. Locate the "Sign In" option (typically found in the top-right corner).
  3. Fill out the registration form with your details (e.g., name, email, password, company information).
  4. After signing up, log in to your account dashboard.
  5. Navigate to the "Settings" - "Integration" section to generate your API key (TokenID).
  6. Generate an API key. Once generated, you’ll receive a unique TokenID (e.g., abc123xyz789). Copy this key and store it securely, as it will be used in the HTTP headers of your API requests.
  7. Copy the TokenID and store it securely.

Note: The TokenID will be used in the HTTP headers of your POST request for authentication.

Authentication

Method: Use your TokenID in the HTTP header:

TokenID: your-token-id-here

This tells CubeMaster you’re allowed to use the API.

Request and Response Format

Request Format: JSON with fields like Title, Cargoes, and Containers (detailed in Step 3).

Response Format: Detailed JSON with load plans, placements, and graphics (detailed in Step 5).

  1. Access Configuration Tools:
    • Log into Click Reply™ WMS with admin privileges.
    • Navigate to Configuration or Integration module.
  2. Set Up External System Connection:
    • Go to External Systems or API Integration.
    • Add a new external system:
      • Name: CubeMaster API
      • Base URL: https://api.cubemaster.net
      • Authentication Type: API Key
      • TokenID: Enter your CubeMaster TokenID (e.g., abc123xyz789).
      • Header: TokenID: your-token-id-here
  3. Define Endpoint Mapping:
    • Add a new endpoint:
      • Endpoint Path: /loads
      • Method: POST
      • Description: Build Mixed Truck Load

Use Click Reply’s flexibility (over 1,000 parameters) to map warehouse data to the CubeMaster request structure.

  1. Create a Data Template:
    • In Process Configuration or Workflow Designer:
    • Define a new process: Build Mixed Load with CubeMaster.
    • Map fields from Click Reply™ to the request JSON.
  2. Request JSON Mapping:
    • Title: Static or dynamic (e.g., "New Mixed Truck Load").
      • Source: Static value or Shipment.ID + " Mixed Load"
    • Description: Optional note (e.g., "Hello Web API").
      • Source: Static value or user input
    • Cargoes: Array of items to load.
      • Source: Inventory and Map or Outbound module
      • Mapping:
        • Name: Inventory.Item.SKU
        • Length, Width, Height: Product.Dimensions (in inches)
        • Weight: Product.Weight (in pounds)
        • OrientationsAllowed: Static "OrientationsAll"
        • TurnAllowedOnFloor: Static false or dynamic
        • Qty: Inventory.Item.Quantity
        • ColorKnownName: Optional, Product.Attributes.Color
    • Containers: Truck/container details.
      • Source: Outbound or static fleet data
      • Mapping:
        • VehicleType: Static "Dry"
        • Name: Static "53FT-Intermodal"
        • Length, Width, Height: Static 630, 98, 106 (inches)
        • ColorKnownName: Static "Blue"
    • Rules: Load optimization rules.
      • Source: Static or warehouse policy
      • Mapping:
        • IsWeightLimited: Static true
        • IsSequenceUsed: Static false
        • FillDirection: Static "FrontToRear"
        • CalculationType: Static "MixLoad"
  3. Sample Request JSON:

    This is the exact request JSON you provided, showing how data is structured:

    {
    "Title": "New Mixed Truck Load",
    "Description": "Hello Web API",
    "Cargoes": [
        {
            "Name": "ITEM001",
            "Length": 72,
            "Width": 30,
            "Height": 75,
            "Weight": 1002.45,
            "OrientationsAllowed": "OrientationsAll",
            "TurnAllowedOnFloor": false,
            "Qty": 16,
            "ColorKnownName": "Brown"
        },
        {
            "Name": "ITEM002",
            "Length": 27.31,
            "Width": 37.5,
            "Height": 76.67,
            "Weight": 521.45,
            "OrientationsAllowed": "OrientationsAll",
            "TurnAllowedOnFloor": false,
            "Qty": 28,
            "ColorKnownName": "Aqua"
        },
        {
            "Name": "SKU0005",
            "Length": 27.31,
            "Width": 9.5,
            "Height": 75.67,
            "Weight": 501.45,
            "OrientationsAllowed": "OrientationsAll",
            "TurnAllowedOnFloor": true,
            "Qty": 24,
            "ColorKnownName": "Beige"
        },
        {
            "Name": "SKU0005",
            "Qty": 23
        },
        {
            "Name": "SKU0008",
            "Qty": 34
        }
    ],
    "Containers": [
        {
            "VehicleType": "Dry",
            "Name": "53FT-Intermodal",
            "Length": 630,
            "Width": 98,
            "Height": 106,
            "ColorKnownName": "Blue"
        }
    ],
    "Rules": {
        "IsWeightLimited": true,
        "IsSequenceUsed": false,
        "FillDirection": "FrontToRear",
        "CalculationType": "MixLoad"
    }
}
  4. Sample Mapping Configuration: 
    Parameter: Title
Source: "New Mixed Truck Load"
---
Parameter: Cargoes.Name
Source: Inventory.Item.SKU
---
Parameter: Cargoes.Length
Source: Product.Dimensions.Length
---
Parameter: Cargoes.Qty
Source: Inventory.Item.Quantity
---
Parameter: Containers.Name
Source: Static "53FT-Intermodal"
---
Parameter: Rules.FillDirection
Source: Static "FrontToRear"
  5. Transform to JSON:

    Use Click Reply’s JSON transformation tool to format the mapped data into the request structure shown above.

  1. Set Up the API Call:
    • In the Build Mixed Load with CubeMaster process:
    • Add an HTTP Request action:
      • URL: https://api.cubemaster.net/loads
      • Method: POST
      • Headers: Content-Type: application/json, TokenID: your-token-id-here
      • Body: JSON template from Step 3
  2. Test the Call:
    • Use Click Reply’s sandbox mode:
    • Input sample data (e.g., ITEM001, ITEM002, SKU0005).
    • Verify the request matches the JSON in Step 3.

The response is detailed; focus on key elements for warehouse operations.

  1. Parse the Response:
    • Add a Response Handling step in the process.
    • Map CubeMaster response fields to Click Reply™.
  2. Response JSON Mapping:
    • status: Check "succeed" for success.
      • Target: Log to Productivity module
    • message: Success or error details.
      • Target: Log for operator visibility
    • document.title: Load identifier.
      • Target: Load.LoadID
    • loadSummary: Overall load stats.
      • cargoesLoaded, piecesLoaded: Load.ItemsLoaded
      • volumeLoaded, weightLoaded: Load.TotalVolume, Load.TotalWeight
    • filledContainers: Detailed placement data.
      • name: Load.ContainerID
      • loadSummary.volumeUtilization, weightUtilization: Track in Productivity dashboards
      • placements:
        • cargo.name: Load.Item.SKU
        • pos.length, pos.width, pos.height: Load.Item.Position
        • size: Verify against Product.Dimensions
    • graphics.images: Visual diagrams.
      • path3DDiagram: Load.Graphics.3D
    • manifest: Summary per cargo type.
      • cargo.name, piecesLoaded: Load.Item.Manifest
  3. Sample Response JSON:

    This is the exact response JSON you provided (abridged for readability):

    {
    "status": "succeed",
    "message": "Engine created. 5 cargoes. 1 empty containers. Calculation started. Calculation ended. The load built successfully. The load saved to the cloud database.",
    "calculationError": "InvalidCargoSize",
    "document": {
        "title": "New Mixed Truck Load",
        "description": "Hello Web API",
        "calculationTimeInSeconds": 0.6152743,
        "createdBy": "CHANG@LOGEN.CO.KR",
        "createdAt": "2023-02-11T01:17:01.7392204+09:00"
    },
    "loadSummary": {
        "cargoesLoaded": 68,
        "piecesLoaded": 68,
        "cargoesLeft": 0,
        "piecesLeft": 57,
        "volumeLoaded": 5261723.4606,
        "weightLoaded": 42674.59999999999
    },
    "filledContainers": [
        {
            "name": "#1 53FT-Intermodal",
            "loadSummary": {
                "volumeUtilization": 80.39990374424703,
                "weightLoaded": 42674.59999999999
            },
            "placements": [
                {
                    "sequence": 1,
                    "cargo": {
                        "name": "ITEM002",
                        "length": 27.31,
                        "width": 37.5,
                        "height": 76.67,
                        "weight": 521.45
                    },
                    "pos": {
                        "length": 0,
                        "width": 0,
                        "height": 0
                    }
                }
                // ... (additional placements truncated)
            ],
            "graphics": {
                "images": {
                    "path3DDiagram": "https://api.cubemaster.net/runtimes/b28413ca_51ed_44c9_b92e_13147363fd61.PNG"
                }
            }
        }
    ],
    "manifest": [
        {
            "cargo": {
                "name": "ITEM002",
                "qty": 28
            },
            "piecesLoaded": 28
        },
        // ... (additional manifest items truncated)
    ],
    "uom": "UnitEnglish"
}

    Note: Full response is over 184,000 characters; this is a summary. Key sections like placements and manifest are detailed in the actual response.

  4. Sample Mapping: 
    Response Field: document.title
Target: Load.LoadID
---
Response Field: loadSummary.weightLoaded
Target: Load.TotalWeight
---
Response Field: filledContainers.placements.cargo.name
Target: Load.Item.SKU
---
Response Field: filledContainers.placements.pos
Target: Load.Item.Position
---
Response Field: graphics.images.path3DDiagram
Target: Load.Graphics.3D
  5. Real-Time Execution:
    • Use Real-Time Execution (RF terminals, voice, or web wizards) to display:
    • Item positions (placements.pos) for operators.
    • Graphics URLs for visual loading instructions.

  1. Use Productivity Tools:
    • Configure dashboards to track:
    • volumeUtilization and weightUtilization for efficiency.
    • piecesLoaded vs. piecesLeft for completeness.
    • Example: Compare loadSummary.weightLoaded (42,674.6 lbs) against container capacity.
  2. Error Handling:
    • Check calculationError (e.g., "InvalidCargoSize"):
    • Log errors and alert operators via Logistics Execution Tools.
    • If status ≠ "succeed", retry or escalate.

  1. Deploy the Integration:
    • Move to production and test with live data (e.g., ITEM001, 16 units).
  2. Scale for Multi-Site:
    • Extend to other sites by adjusting warehouseId or Containers dynamically.

Request: Sends ITEM001 (16 units), ITEM002 (28 units), SKU0005 (24+23 units), etc., into a 53FT truck (see Step 3).

Response: Confirms 68 pieces loaded (out of 125 requested), with detailed positions (e.g., ITEM002 at pos: {length: 0, width: 0, height: 0}) and 80.4% volume utilization (see Step 5).

  • Units: Ensure Click Reply™ data matches "UnitEnglish" (inches, pounds). Convert if necessary.
  • Incomplete Cargoes: Handle cases where only some items are loaded (e.g., 68/125 pieces) by updating inventory.
  • Graphics: Leverage image URLs for operator training or validation.