Commissioning

Commission events in the TrustStack.

In supply chains, it’s common to record the moment when something is first created, introduced or made traceable - this could be:

• Harvesting grain from a paddock.
• Marking livestock for the first time.
• Manufacturing a batch of product (like cans of tuna, or pallets of flour)

In EPCIS, these creation moments are usually modeled using an ObjectEvent with:

• action set to ADD
• epcList or quantityList containing the identifier of the products that were created.
• and often accompanied by a bizStep like commissioning or receiving depending on context.

Product Identifiers

At the end of a commissioning event, we need unique identifiers for the products that were created. The TrustStack supports master data concepts such as Trade Items. As a refresh, a Trade Item is anything that can be priced in sold in a supply chain.

We can reference a TradeItem when creating a Event to generate a unique identifier for the product.

Example

Let’s say we are building a grain farm management application, and we need users to be able commission a batch of wheat.

Such as, the farmer has harvested a paddock of wheat, and we need to create a unique identifier for the batch wheat.

Farm and Paddock

Let’s use the TrustStack SDK to create a new Farm and Paddock for our example.

import {TrustStack} from "@truststack/sdk";

const truststack = new TrustStack({
  apiKey: "your-api-key",
});

const farm = await truststack.masterData.createFarm(
  {
    name: "Farm 1",
  },
  {organizationId: "farm-organization-id"}
);

const paddock = await truststack.masterData.createPaddock(
  {
    name: "Paddock 1",
    parentLocationId: farm.id,
  },
  {organizationId: "farm-organization-id"}
);

We now have a Farm and Paddock in the TrustStack for this farming enterprise.

Wheat Trade Item

This farmer is harvesting Wheat, this can be priced and sold in the supply chain, so it is a TradeItem.

Let’s create a TradeItem for Wheat.

const wheat = await truststack.masterData.createTradeItem(
  {
    name: "Wheat",
  },
  {organizationId: "farm-organization-id"}
);

Harvest Event

Now, the farmer has harvested the wheat from the paddock, and we need to create an event to record this.

const harvestEvent = await truststack.event.createEvent(
  {
    action: "ADD",
    eventType: "OBJECT_EVENT",
    eventTime: new Date(),
    bizStep: "COMMISSIONING",
    disposition: "ACTIVE",
    readPoint: {
      location: paddock.id,
    },
    quantityList: [
      {
        tradeItem: wheat.id,
        quantity: 10000,
        unit: "KGM",
      },
    ],
  },
  {organizationId: "farm-organization-id"}
);

console.log(harvestEvent);

The output of this event will be:

{
  "id": "123e4567-e89b-12d3-a456-426614174000",
  "eventTime": "2021-01-01T00:00:00.000Z",
  "eventType": "OBJECT_EVENT",
  "bizStep": "COMMISSIONING",
  "disposition": "ACTIVE",
  "readPoint": {
    "location": "<PADDOCK-ID>"
  },
  "quantityList": [
    {
      "tradeItem": "XXXX.1.1",
      "quantity": 10000,
      "unit": "KGM"
    }
  ]
}

An event has now been created:

• The readPoint is the paddock that the wheat was harvested from.
• The quantityList contains a batch/lot level identifier of the Wheat TradeItem that was harvested, and the quantity harvested.
• The eventTime is the date and time the harvest event occurred.
• The bizStep is the business step of the harvest event, in this case COMMISSIONING.
• The disposition is the disposition of the event, in this case ACTIVE.

Assistant

Responses are generated using AI and may contain mistakes.