EDI Tasks

Overview

This document describes the tasks available for parsing, creating, and managing EDI (Electronic Data Interchange) files within the CXTMS System. These tasks support X12 transaction sets (204, 214, 216, 856, 861, 990) and EDIFACT message types (IFTMIN, CONTRL, APERAK) with INTTRA D99B specification support.

YAML Structure

EDI tasks follow a consistent structure that allows for flexible configuration of EDI processing operations.

Attribute Description

EDI/Parse

The EDI/Parse task converts raw EDI data into structured JSON format for further processing.

task: "EDI/Parse@1"
name: parseEDI
inputs:
  ediData: "ISA*00*          *00*          *ZZ*ABCDEFGH      *ZZ*123456789      *210101*1030*U*00401*000000001*0*P*>\nGS*SH*ABCDEFGH*123456789*20210101*1030*1*X*004010\nST*856*0001\n..."
  transactionSet: "856" # Optional - Specific transaction set to parse
  validateSchema: true # Optional - Validate against EDI schema
  preserveWhitespace: false # Optional - Preserve whitespace in element data
outputs:
  - name: "parsedData"
    mapping: "result"
  - name: "transactionType"
    mapping: "transactionType"

Attribute Details:

Input Parameter	Description
ediData	Raw EDI data string to be parsed
transactionSet	Specific EDI transaction set to parse (e.g., 856, 214)
validateSchema	Whether to validate the EDI data against its schema
preserveWhitespace	Whether to preserve whitespace in element data

Output:

{
  "parsedData": {
    "interchangeHeader": {...},
    "functionalGroups": [...],
    "segments": [...],
    "transactionSets": [...]
  },
  "transactionType": "856"
}

EDI/Generate

The EDI/Generate task creates EDI files from structured data.

task: "EDI/Generate@1"
name: generateEDI
inputs:
  data:
    {
      "header":
        {
          "senderId": "ABCDEFGH",
          "receiverId": "123456789",
          "controlNumber": "000000001",
        },
      "shipment": { "billOfLadingNumber": "BOL12345", "shipDate": "20230515" },
    }
  transactionSet: "856" # Required - Transaction set to generate
  template: "standard" # Optional - Template name to use
  options:
    segmentTerminator: "~"
    elementSeparator: "*"
    subElementSeparator: ">"
    lineEnding: "\n"
outputs:
  - name: "ediString"
    mapping: "ediString"
  - name: "controlNumbers"
    mapping: "controlNumbers"

Attribute Details:

Input Parameter	Description
data	Structured data to convert to EDI format
transactionSet	EDI transaction set to generate
template	Named template to use for generation
options.segmentTerminator	Character used to terminate segments
options.elementSeparator	Character used to separate elements
options.subElementSeparator	Character used to separate sub-elements
options.lineEnding	Line ending character sequence

Output:

{
  "ediString": "ISA*00*          *00*          *ZZ*ABCDEFGH      *ZZ*123456789      *230515*1030*U*00401*000000001*0*P*>\nGS*SH*ABCDEFGH*123456789*20230515*1030*1*X*004010\nST*856*0001\n...",
  "controlNumbers": {
    "interchangeControlNumber": "000000001",
    "groupControlNumber": "1",
    "transactionSetControlNumber": "0001"
  }
}

EDI/Validate

The EDI/Validate task validates EDI data against standard schemas or custom validation rules.

task: "EDI/Validate@1"
name: validateEDI
inputs:
  ediData: "ISA*00*          *00*          *ZZ*ABCDEFGH      *ZZ*123456789      *210101*1030*U*00401*000000001*0*P*>\nGS*SH*ABCDEFGH*123456789*20210101*1030*1*X*004010\nST*856*0001\n..."
  transactionSet: "856" # Required - Transaction set to validate
  customRules:
    [
      {
        "segment": "REF",
        "element": "REF01",
        "rule": "required",
        "message": "Reference qualifier is required",
      },
    ]
  strictMode: true # Optional - Fail on any validation error
outputs:
  - name: "isValid"
    mapping: "isValid"
  - name: "validationErrors"
    mapping: "errors"

Attribute Details:

Input Parameter	Description
ediData	Raw EDI data string to validate
transactionSet	EDI transaction set to validate against
customRules	Array of custom validation rules
strictMode	Whether to fail on any validation error

Output:

{
  "isValid": false,
  "validationErrors": [
    {
      "segment": "REF",
      "position": 12,
      "element": "REF01",
      "message": "Reference qualifier is required",
      "severity": "error"
    }
  ]
}

EDI/Transform

The EDI/Transform task converts between different EDI formats or maps EDI data to custom formats.

task: "EDI/Transform@1"
name: transformEDI
inputs:
  sourceData:
    {
      "interchangeHeader": { ... },
      "functionalGroups": [...],
      "segments": [...],
      "transactionSets": [...],
    }
  sourceFormat: "X12" # Required - Source EDI format
  targetFormat: "EDIFACT" # Required - Target EDI format
  mappingTemplate: "x12ToEdifact856" # Optional - Named mapping template
  customMapping:
    {
      "sourceField": "targetField",
      "sourceSegment.element": "targetSegment.element",
    }
outputs:
  - name: "transformedData"
    mapping: "result"

Attribute Details:

Input Parameter	Description
sourceData	Source EDI data (parsed or raw)
sourceFormat	Source EDI format (X12, EDIFACT, etc.)
targetFormat	Target EDI format
mappingTemplate	Named template for transformation
customMapping	Custom field mapping rules

Output:

{
  "transformedData": {
    "raw": "UNB+UNOA:1+SENDER+RECEIVER+230515:1030+1+++++1'\nUNH+1+DESADV:D:96A:UN'\n...",
    "structured": {
      "interchangeHeader": {...},
      "messages": [...]
    }
  }
}

EDI/ExtractData

The EDI/ExtractData task extracts specific data elements from EDI documents.

task: "EDI/ExtractData@1"
name: extractEDIData
inputs:
  ediData: "ISA*00*          *00*          *ZZ*ABCDEFGH      *ZZ*123456789      *210101*1030*U*00401*000000001*0*P*>\nGS*SH*ABCDEFGH*123456789*20210101*1030*1*X*004010\nST*856*0001\n..."
  extractionRules:
    [
      { "path": "ST-856/HL-S/TD1/TD101", "name": "packagingCode" },
      { "path": "ST-856/HL-S/TD1/TD102", "name": "ladingQuantity" },
      {
        "path": "ST-856/HL-S/REF[REF01=BM]/REF02",
        "name": "billOfLadingNumber",
      },
    ]
outputs:
  - name: "extractedData"
    mapping: "data"

Attribute Details:

Input Parameter	Description
ediData	Raw EDI data string to extract from
extractionRules	Array of rules defining what data to extract

Output:

{
  "extractedData": {
    "packagingCode": "PLT",
    "ladingQuantity": "10",
    "billOfLadingNumber": "BOL12345"
  }
}

EDI/Acknowledge

The EDI/Acknowledge task generates functional acknowledgments (997/999) for received EDI documents.

task: "EDI/Acknowledge@1"
name: acknowledgeEDI
inputs:
  ediData: "ISA*00*          *00*          *ZZ*ABCDEFGH      *ZZ*123456789      *210101*1030*U*00401*000000001*0*P*>\nGS*SH*ABCDEFGH*123456789*20210101*1030*1*X*004010\nST*856*0001\n..."
  acknowledgmentType: "997" # Required - 997 or 999
  status: "A" # Optional - A (Accepted), P (Partially Accepted), R (Rejected)
  errors:
    [
      {
        "segment": "N1",
        "position": 15,
        "code": "7",
        "description": "Missing required segment",
      },
    ]
  options:
    swapIds: true # Swap sender/receiver IDs
    useOriginalControlNumbers: false
outputs:
  - name: "acknowledgment"
    mapping: "ediString"

Attribute Details:

Input Parameter	Description
ediData	Original EDI data to acknowledge
acknowledgmentType	Type of acknowledgment to generate (997 or 999)
status	Overall acknowledgment status
errors	Array of errors to include in acknowledgment
options.swapIds	Whether to swap sender/receiver IDs
options.useOriginalControlNumbers	Whether to reference original control numbers

Output:

{
  "acknowledgment": "ISA*00*          *00*          *ZZ*123456789      *ZZ*ABCDEFGH      *210101*1030*U*00401*000000002*0*P*>\nGS*FA*123456789*ABCDEFGH*20210101*1030*2*X*004010\nST*997*0001\n..."
}

EDI/BatchProcess

The EDI/BatchProcess task processes multiple EDI files in a single operation.

task: "EDI/BatchProcess@1"
name: batchProcessEDI
inputs:
  files:
    [
      {
        "name": "order1.edi",
        "content": "ISA*00*...",
        "transactionSet": "850",
      },
      {
        "name": "shipment1.edi",
        "content": "ISA*00*...",
        "transactionSet": "856",
      },
    ]
  operation: "parse" # Required - Operation to perform (parse, validate, transform)
  options:
    continueOnError: true
    groupByTransactionSet: true
outputs:
  - name: "results"
    mapping: "results"
  - name: "summary"
    mapping: "summary"

Attribute Details:

Input Parameter	Description
files	Array of EDI files to process
operation	Operation to perform on each file
options.continueOnError	Whether to continue processing after errors
options.groupByTransactionSet	Whether to group results by transaction set

Output:

{
  "results": [
    {
      "fileName": "order1.edi",
      "transactionSet": "850",
      "success": true,
      "data": {...}
    },
    {
      "fileName": "shipment1.edi",
      "transactionSet": "856",
      "success": true,
      "data": {...}
    }
  ],
  "summary": {
    "total": 2,
    "successful": 2,
    "failed": 0,
    "byTransactionSet": {
      "850": 1,
      "856": 1
    }
  }
}

EDIFACT Tasks

The following tasks handle UN/EDIFACT messages using the indice.Edi serialization library. They support INTTRA D99B specifications for ocean shipping instruction workflows.

EDIFACT/Parse

The EDIFACT/Parse task deserializes raw EDIFACT data into strongly-typed POCO models. Supports IFTMIN (Instruction for Transport), CONTRL (Syntax and Service Report), and APERAK (Application Error and Acknowledgement) message types.

task: "EDIFACT/Parse@1"
name: parseEdifact
inputs:
  edifactData: "{{ workflow.input.rawEdifact }}"
  messageType: "IFTMIN" # Required - IFTMIN, CONTRL, or APERAK
outputs:
  - name: "parsedData"
    mapping: "parsedData"
  - name: "messageType"
    mapping: "messageType"
  - name: "success"
    mapping: "success"

Attribute Details:

Input Parameter	Description
edifactData	Raw EDIFACT data string to parse
messageType	EDIFACT message type: IFTMIN, CONTRL, or APERAK

Supported Message Types:

Message Type	Description	INTTRA Spec
IFTMIN	Instruction for Transport (D99B/D01B)	v3.08
CONTRL	Syntax and Service Report (D99B)	v1.1
APERAK	Application Error & Acknowledgement	v1.4

Output (IFTMIN example):

{
  "parsedData": {
    "syntaxIdentifier": "UNOB",
    "senderId": "SHIPPER01",
    "recipientId": "INTTRA",
    "messages": [{
      "messageType": "IFTMIN",
      "messageVersionNumber": "D",
      "messageReleaseNumber": "99B",
      "beginningOfMessage": {
        "documentNameCode": "340",
        "documentNumber": "SI-2026-001",
        "messageFunctionCode": "9"
      },
      "parties": [...],
      "transportDetails": [...],
      "goodsItems": [...],
      "equipment": [...]
    }]
  },
  "messageType": "IFTMIN",
  "success": true
}

Output (CONTRL example):

{
  "parsedData": {
    "senderId": "CARRIER01",
    "recipientId": "SHIPPER01",
    "messages": [{
      "interchangeResponse": {
        "interchangeControlReference": "REF001",
        "actionCode": "7"
      },
      "messageResponses": [{
        "messageType": "IFTMIN",
        "actionCode": "7"
      }]
    }]
  },
  "messageType": "CONTRL",
  "success": true
}

Output (APERAK example):

{
  "parsedData": {
    "senderId": "CARRIER01",
    "recipientId": "SHIPPER01",
    "messages": [{
      "beginningOfMessage": {
        "documentNameCode": "23",
        "documentName": "IFTMIN",
        "responseTypeCode": "AP"
      },
      "freeTexts": [{ "freeTextValue": "Accepted" }],
      "references": [{ "referenceCodeQualifier": "BN", "referenceIdentifier": "BKG123" }]
    }]
  },
  "messageType": "APERAK",
  "success": true
}

EDIFACT/Generate

The EDIFACT/Generate task serializes structured data into raw EDIFACT format. Currently supports IFTMIN message generation with full INTTRA D99B compliance.

task: "EDIFACT/Generate@1"
name: generateEdifact
inputs:
  messageType: "IFTMIN" # Required - Currently supports IFTMIN
  sender:
    id: "{{ company.ediId }}"
    qualifier: "ZZZ"
  recipient:
    id: "INTTRA"
    qualifier: "ZZZ"
  documentNumber: "{{ shipment.siNumber }}"
  messageReferenceNumber: "{{ sequence.messageRef }}" # Optional, auto-generated if omitted
  messageFunctionCode: "9" # 9 = Original, 5 = Replace
  documentRevisionNumber: "000001"
  dates:
    - qualifier: "137"
      value: "{{ formatDate now 'yyyyMMddHHmm' }}"
      formatCode: "203"
  transportServiceRequirements:
    contractConditionCode: "30" # 27=Door-Door, 28=Door-Pier, 29=Pier-Door, 30=Pier-Pier
    serviceRequirementCode: "2" # 2 = Full loads
  references:
    - qualifier: "BN"
      identifier: "{{ shipment.bookingNumber }}"
    - qualifier: "BM"
      identifier: "{{ shipment.billOfLading }}"
  parties:
    - functionCode: "HI" # Requestor (mandatory for INTTRA)
      identification: "{{ company.inttraAlias }}"
      name: "{{ company.name }}"
    - functionCode: "CZ" # Shipper (mandatory)
      name: "{{ shipper.name }}"
      streetAddress: "{{ shipper.address }}"
      city: "{{ shipper.city }}"
      country: "{{ shipper.countryCode }}"
    - functionCode: "CA" # Carrier (mandatory)
      identification: "{{ carrier.scac }}"
      codeListAgency: "172" # SCAC
    - functionCode: "CN" # Consignee
      name: "{{ consignee.name }}"
  transportDetails:
    - stageQualifier: "20" # Main transport
      modeOfTransport: "1" # Maritime
      carrierIdentification: "{{ carrier.scac }}"
      vesselName: "{{ vessel.name }}"
      voyageNumber: "{{ voyage.number }}"
  locations:
    - functionCode: "88" # Place of receipt
      locationIdentifier: "{{ origin.unlocode }}"
    - functionCode: "9" # Port of loading
      locationIdentifier: "{{ pol.unlocode }}"
    - functionCode: "11" # Port of discharge
      locationIdentifier: "{{ pod.unlocode }}"
  goodsItems:
    - itemNumber: 1
      numberOfPackages: "{{ cargo.packageCount }}"
      packageType: "{{ cargo.packageTypeCode }}"
      packageTypeDescription: "{{ cargo.packageTypeDescription }}"
      packageTypeAgencyCode: "6" # Auto-set to "6" (UN/ECE) when packageType is provided
      packageTypeDescriptionText: "{{ cargo.packageTypeDescriptionText }}" # Printed on B/L
      grossWeight: "{{ cargo.grossWeight }}"
      weightUnit: "KGM"
      description: "{{ cargo.description }}"
  equipment:
    - equipmentQualifier: "CN" # Container
      equipmentIdentification: "{{ container.number }}"
      sizeTypeCode: "{{ container.sizeType }}"
      fullEmptyIndicator: "5" # Full
      sealNumber: "{{ container.sealNumber }}"
      sealIssuerCode: "CA" # Carrier
outputs:
  - name: "edifactData"
    mapping: "edifactData"
  - name: "success"
    mapping: "success"

Key Input Parameters:

Input Parameter	Description
messageType	EDIFACT message type (currently IFTMIN)
sender	Sender identification (id, qualifier)
recipient	Recipient identification (id, qualifier)
documentNumber	Shipment Identification Number (mandatory for INTTRA)
messageFunctionCode	9 = Original, 5 = Replace
transportServiceRequirements	Contract conditions and service type codes
references	Business references (BN=Booking, BM=B/L, FF=Forwarder ref, etc)
parties	Party details (HI, CZ, CA, CN, NI, FW, etc)
transportDetails	Transport stage, mode, vessel/voyage
locations	Location codes (origin, POL, POD, delivery)
goodsItems	Cargo details (packages, weight, dimensions, DG). Includes packageTypeAgencyCode (auto-set to "6" = UN/ECE when packageType provided) and packageTypeDescriptionText (B/L text)
equipment	Container/equipment details with seals

INTTRA Party Codes:

Code	Role	Required
HI	Requestor	Yes
CZ	Consignor/Shipper	Yes
CA	Carrier (SCAC in C082)	Yes
CN	Consignee	Yes
NI	Notify party	No
FW	Freight forwarder	No
FP	Freight/charges payer	No
EX	Exporter	No
MR	Message recipient	No

INTTRA Location Codes:

Code	Function
88	Place of receipt
9	Port of loading
11	Port of discharge
7	Place of delivery

Output:

{
  "edifactData": "UNB+UNOB:3+SHIPPER01:ZZZ+INTTRA:ZZZ+260306:1130+REF001'UNH+1+IFTMIN:D:99B:UN'BGM+340+SI-2026-001+9'...",
  "messageType": "IFTMIN",
  "success": true
}

EDIFACT Message Models

The backend uses strongly-typed C# POCO classes with indice.Edi serialization attributes for EDIFACT processing:

IFTMIN (Instruction for Transport)

Structure follows IFTMIN D99B specification segment positions:

UNB → UNH → BGM(0020) → DTM(0050) → TSR?(0060) → CUX*(0070) → MOA*(0080) → FTX*(0090) → CNT*(0100) → SG1[LOC+DTM]*(0130) → SG3[RFF+DTM]*(0190) → SG6[CPI]*(0310) → SG8[TDT+LOC+DTM]*(0470) → SG11[NAD+CTA+COM+DOC+RFF]*(0570) → SG18[GID+...]*(0900) → SG37[EQD+SEL+TMP+RNG]*(1650) → UNT → UNZ

Key segments:

• BGM (pos 0020, M 1) — Document type (340=Shipping Instructions) and shipment ID
• DTM (pos 0050, C 1) — Document date/time (auto-generated as DTM+137)
• TSR (pos 0060, C 1) — Carriage conditions (27-30: Door/Pier combinations) and service type
• CUX (pos 0070, C 9) — Currencies for the message
• MOA (pos 0080, C 99) — Monetary amounts
• FTX (pos 0090, C 99) — Free text (AAI=General, BLC=B/L clause, CCI=Customs instructions)
• CNT (pos 0100, C 5) — Control totals
• SG1: LOC+DTM (pos 0130, C 2) — Locations with optional date/time (nested DTM per location)
• SG3: RFF+DTM (pos 0190, C 999) — References (BN=Booking, BM=B/L, TN=ITN, CT=Contract)
• SG6: CPI (pos 0310, C 9) — Charge payment instructions
• SG8: TDT+LOC+DTM (pos 0470, C 99) — Transport details with vessel/voyage; now supports nested LOC segments (e.g., port of discharge, place of delivery)
• SG11: NAD+CTA+COM+DOC+RFF (pos 0570, M 99) — Parties with contacts (CTA), communication details (COM), documents (DOC), and party-level references (SG15 RFF — e.g., FMC number for HI party)
• SG18: GID+... (pos 0900, C 999) — Goods items with measurements (MEA), dangerous goods (DGS), free text. GID numeric fields (item number, package counts) are serialized as strings to avoid zero-padding issues with EDIFACT 9(n) format specifiers. The outer packaging composite (C213) includes an auto-set agency code (3055 = "6" for UN/ECE) when a package type code is provided, plus a description text field (7064) for B/L printing.
• SG37: EQD+SEL+TMP+RNG (pos 1650, C 999) — Equipment with seals (SEL) and temperatures (TMP/RNG)

CONTRL (Syntax and Service Report)

Structure: UNB → UNH → UCI → [UCM → [UCS → [UCD]]] → UNT → UNZ

• UCI — Interchange-level response (action code: 4=rejected, 7=acknowledged)
• UCM — Message-level response with error codes
• UCS — Segment error indication (position in message body)
• UCD — Data element error indication (element/component position)

APERAK (Application Error and Acknowledgement)

Structure: UNB → UNH → BGM → DTM* → FTX* → RFF* → NAD* → UNT → UNZ

• BGM — Status information (code 23), response type (AP=Accepted, RE=Rejected)
• FTX — Status text ("Accepted" / "Rejected")
• RFF — References back to original SI (BN=Booking, ERN=Exporter ref, ZZZ=INTTRA SI Number)
• NAD — Carrier (CA) and Requestor (HI)

Examples

Parsing an EDI 856 Shipment Notice

task: "EDI/Parse@1"
name: parseShipmentNotice
inputs:
  ediData: "{{ workflow.input.ediContent }}"
  transactionSet: "856"
  validateSchema: true
outputs:
  - name: "shipmentData"
    mapping: "result"
  - name: "transactionType"
    mapping: "transactionType"

Generating an EDI 214 Shipment Status Message

task: "EDI/Generate@1"
name: generateStatusUpdate
inputs:
  data:
    {
      "header":
        {
          "senderId": "{{ company.ediId }}",
          "receiverId": "{{ partner.ediId }}",
          "controlNumber": "{{ sequence.ediControl }}",
        },
      "statusDetails":
        {
          "shipmentId": "{{ shipment.id }}",
          "statusCode": "AG",
          "statusDescription": "Delivered",
          "statusDate": "{{ formatDate shipment.deliveryDate 'YYYYMMDD' }}",
          "statusTime": "{{ formatDate shipment.deliveryTime 'HHmm' }}",
        },
    }
  transactionSet: "214"
  template: "standardDelivery"
outputs:
  - name: "ediMessage"
    mapping: "ediString"
  - name: "controlInfo"
    mapping: "controlNumbers"

Creating and Validating an EDI 204 Motor Carrier Load Tender

task: "EDI/Generate@1"
name: generateLoadTender
inputs:
  data: "{{ shipment }}"
  transactionSet: "204"
  template: "carrierLoadTender"
outputs:
  - name: "ediTender"
    mapping: "ediString"

task: "EDI/Validate@1"
name: validateLoadTender
inputs:
  ediData: "{{ generateLoadTender.ediTender }}"
  transactionSet: "204"
  strictMode: true
outputs:
  - name: "isValid"
    mapping: "isValid"
  - name: "validationErrors"
    mapping: "errors"

Generating an EDIFACT IFTMIN Shipping Instruction via INTTRA

task: "EDIFACT/Generate@1"
name: generateShippingInstruction
inputs:
  messageType: "IFTMIN"
  sender:
    id: "{{ company.inttraAlias }}"
    qualifier: "ZZZ"
  recipient:
    id: "INTTRA"
    qualifier: "ZZZ"
  documentNumber: "{{ shipment.siNumber }}"
  messageFunctionCode: "9"
  references:
    - qualifier: "BN"
      identifier: "{{ shipment.bookingNumber }}"
  parties:
    - functionCode: "HI"
      identification: "{{ company.inttraAlias }}"
    - functionCode: "CZ"
      name: "{{ shipper.name }}"
    - functionCode: "CA"
      identification: "{{ carrier.scac }}"
    - functionCode: "CN"
      name: "{{ consignee.name }}"
  equipment:
    - equipmentQualifier: "CN"
      equipmentIdentification: "{{ container.number }}"
      sizeTypeCode: "4510"
      fullEmptyIndicator: "5"
outputs:
  - name: "ediMessage"
    mapping: "edifactData"

Parsing an EDIFACT CONTRL Response

task: "EDIFACT/Parse@1"
name: parseContrlResponse
inputs:
  edifactData: "{{ workflow.input.edifactResponse }}"
  messageType: "CONTRL"
outputs:
  - name: "contrlData"
    mapping: "parsedData"
  - name: "isAccepted"
    mapping: "parsedData.messages[0].interchangeResponse.actionCode"

Parsing an EDIFACT APERAK Acknowledgement

task: "EDIFACT/Parse@1"
name: parseAperakResponse
inputs:
  edifactData: "{{ workflow.input.aperakData }}"
  messageType: "APERAK"
outputs:
  - name: "aperakData"
    mapping: "parsedData"
  - name: "responseType"
    mapping: "parsedData.messages[0].beginningOfMessage.responseTypeCode"

Full INTTRA Shipping Instruction Workflow

steps:
  - task: "EDIFACT/Generate@1"
    name: generateSI
    inputs:
      messageType: "IFTMIN"
      sender:
        id: "{{ company.inttraAlias }}"
        qualifier: "ZZZ"
      recipient:
        id: "INTTRA"
        qualifier: "ZZZ"
      documentNumber: "{{ shipment.siNumber }}"
      messageFunctionCode: "9"
      references:
        - qualifier: "BN"
          identifier: "{{ shipment.bookingNumber }}"
      parties:
        - functionCode: "HI"
          identification: "{{ company.inttraAlias }}"
        - functionCode: "CZ"
          name: "{{ shipper.name }}"
        - functionCode: "CA"
          identification: "{{ carrier.scac }}"
        - functionCode: "CN"
          name: "{{ consignee.name }}"

  - task: "HTTP/Request@1"
    name: sendToInttra
    inputs:
      url: "{{ config.inttra.endpoint }}"
      method: "POST"
      body: "{{ generateSI.ediMessage }}"

  - task: "EDIFACT/Parse@1"
    name: parseContrl
    inputs:
      edifactData: "{{ sendToInttra.response }}"
      messageType: "CONTRL"

  - task: "EDIFACT/Parse@1"
    name: parseAperak
    inputs:
      edifactData: "{{ workflow.input.aperakCallback }}"
      messageType: "APERAK"
    conditions:
      - expression: "{{ workflow.input.aperakCallback != null }}"

Best Practices

1. Pre-validate Data: Always validate your data structures before generating EDI documents to prevent syntax errors.

2. Use Templates: Create reusable templates for common EDI transaction sets to ensure consistency.

3. Implement Error Handling: Set up proper error handling for EDI parsing and validation to gracefully handle malformed documents.

4. Control Number Management: Implement a robust system for managing EDI control numbers to prevent duplicates.

5. Logging: Log all EDI transactions for audit and troubleshooting purposes.

6. Testing: Test EDI documents with trading partners' test systems before moving to production.

7. Acknowledgments: Always process and respond to acknowledgments (997/999) to ensure successful transmission.

Related Topics

• Utilities Tasks
• Order Tasks
• Document Tasks
• HTTP Request Task