std.edi.shipping

Lieferschein und Wareneingangsbestätigung per EDIFACT. DESADV bildet die dreistufige Verpackungshierarchie (Palette → Karton → Artikel) über die EDIFACT-Segmente CPS/PAC/GIN/LIN ab. Jedes Packstück trägt eine SSCC-18-Nummer zur lückenlosen Rückverfolgung.

DESADV (BGM 351) — Dispatch Advice: Lieferschein mit Verpackungsstruktur und SSCC-Nummern
RECADV (BGM 632) — Receiving Advice: Wareneingangsbestätigung mit Soll-/Ist-Mengen und optionalem Abweichungsgrund

SSCC-18-Funktionen:

EdiSsccCheck — Prüft Prüfziffer (GS1 Mod-10)
EdiSsccGenerate — Berechnet Prüfziffer aus 17-stelliger Basis

import std.edi.shipping;

// SSCC generieren
var base17: pchar := "00400000000000001";  // Erweiterungsziffer + GS1 Prefix + Seriennr.
var sscc: int64 := alloc(19);              // 18 Ziffern + NUL
EdiSsccGenerate(base17 as int64, sscc);

PrintLn("SSCC: " + (sscc as pchar));

free(sscc, 19);

Imports

std.edi.core
std.alloc

Konstanten — Pakettypen

Konstante	Wert	Bedeutung
`EDI_PKG_PALLET`	1	Palette (CPS+PAC mit Code 201)
`EDI_PKG_CARTON`	2	Karton (CPS+PAC mit Code CT)
`EDI_PKG_ITEM`	3	Artikel-Ebene (CPS+LIN+QTY)

Structs

EdiPackage (EDI_PACKAGE_SIZE = 56 Bytes)

Offset-Konstante	Inhalt
`EDI_PACKAGE_SSCC / EDI_PACKAGE_SSCCLEN`	SSCC-Zeiger (18 Zeichen) und -Länge
`EDI_PACKAGE_TYPE`	Pakettyp: `EDI_PKG_PALLET` / `EDI_PKG_CARTON` / `EDI_PKG_ITEM`
`EDI_PACKAGE_PARENT`	Index des übergeordneten Packstücks (0-basiert); `-1` wenn keins
`EDI_PACKAGE_GTIN / EDI_PACKAGE_GTINLEN`	GTIN (nur bei Items)
`EDI_PACKAGE_QTY`	Menge (nur bei Items)

Reihenfolge beim Schreiben: Erst alle Paletten, dann Kartons, dann Artikel. Der Parent-Index verweist auf den 0-basierten Index im Array.

EdiRecadvLine (EDI_RECADV_LINE_SIZE = 56 Bytes)

Offset-Konstante	Inhalt
`EDI_RECADV_LINE_GTIN / EDI_RECADV_LINE_GTINLEN`	GTIN-Zeiger und -Länge
`EDI_RECADV_LINE_ORDERED`	Bestellte Menge (QTY+21)
`EDI_RECADV_LINE_DELIVERED`	Gelieferte Menge (QTY+12)
`EDI_RECADV_LINE_ACCEPTED`	Akzeptierte Menge (QTY+192)
`EDI_RECADV_LINE_REASON / EDI_RECADV_LINE_REASONLEN`	Abweichungsgrund als Freitext (FTX+AAI, optional; 0 wenn keiner)

Funktionen

SSCC-18-Validierung & -Generierung

Signatur	Beschreibung
`EdiSsccCheck(ptr: int64, len: int64): int64`	Prüft SSCC-18-Prüfziffer (GS1 Mod-10). Gibt 1=gültig, 0=ungültig. Erwartet exakt 18 Stellen.
`EdiSsccGenerate(base17: int64, out: int64): void`	Berechnet Prüfziffer aus 17-stelliger Basis-SSCC. Schreibt 18 Stellen + NUL in `out` (mind. 19 Bytes).

DESADV

Signatur	Beschreibung
`EdiDesadvWrite(refNum: int64, date: int64, packages: int64, packCount: int64, out: int64, outMax: int64): int64`	Schreibt DESADV. Pakete müssen in Hierarchie-Reihenfolge vorliegen (Paletten → Kartons → Items).
`EdiDesadvRead(buf: int64, bufLen: int64, packages: int64, maxPacks: int64): int64`	Parst DESADV; gibt Paketanzahl zurück oder `-1` bei doppelter SSCC.

RECADV

Signatur	Beschreibung
`EdiRecadvWrite(orderRef: int64, date: int64, lines: int64, lineCount: int64, out: int64, outMax: int64): int64`	Schreibt RECADV mit Kreuzreferenz auf Bestellnummer (`RFF+ON`).
`EdiRecadvRead(buf: int64, bufLen: int64, lines: int64, maxLines: int64): int64`	Parst RECADV; gibt Zeilenanzahl zurück.

Codebeispiel — DESADV mit Palettenstruktur

import std.edi.shipping;

// 1 Palette → 1 Karton → 2 Artikel
var packs: int64 := alloc(4 * EDI_PACKAGE_SIZE);

// Palette (Index 0, kein Parent)
poke64(packs + 0 * EDI_PACKAGE_SIZE + EDI_PACKAGE_SSCC,   "004000000000000011" as int64);
poke64(packs + 0 * EDI_PACKAGE_SIZE + EDI_PACKAGE_SSCCLEN, 18);
poke64(packs + 0 * EDI_PACKAGE_SIZE + EDI_PACKAGE_TYPE,    EDI_PKG_PALLET);
poke64(packs + 0 * EDI_PACKAGE_SIZE + EDI_PACKAGE_PARENT,  0 - 1);

// Karton (Index 1, Parent=0)
poke64(packs + 1 * EDI_PACKAGE_SIZE + EDI_PACKAGE_SSCC,   "004000000000000028" as int64);
poke64(packs + 1 * EDI_PACKAGE_SIZE + EDI_PACKAGE_SSCCLEN, 18);
poke64(packs + 1 * EDI_PACKAGE_SIZE + EDI_PACKAGE_TYPE,    EDI_PKG_CARTON);
poke64(packs + 1 * EDI_PACKAGE_SIZE + EDI_PACKAGE_PARENT,  0);

// Artikel 1 (Index 2, Parent=1)
poke64(packs + 2 * EDI_PACKAGE_SIZE + EDI_PACKAGE_GTIN,    "04012345678901" as int64);
poke64(packs + 2 * EDI_PACKAGE_SIZE + EDI_PACKAGE_GTINLEN, 14);
poke64(packs + 2 * EDI_PACKAGE_SIZE + EDI_PACKAGE_QTY,     50);
poke64(packs + 2 * EDI_PACKAGE_SIZE + EDI_PACKAGE_TYPE,    EDI_PKG_ITEM);
poke64(packs + 2 * EDI_PACKAGE_SIZE + EDI_PACKAGE_PARENT,  1);

var out: int64 := alloc(16384);
var n: int64 := EdiDesadvWrite(
    "LFG-2026-001" as int64,
    "20261201" as int64,
    packs, 3, out, 16384);

free(packs, 4 * EDI_PACKAGE_SIZE);
free(out, 16384);

Hinweise

SSCC-Duplikatserkennung: EdiDesadvRead gibt -1 zurück wenn dieselbe SSCC-Nummer bereits im Pakete-Array vorkommt.
Hierarchie-Reihenfolge: Beim Schreiben müssen Paletten (EDI_PKG_PALLET) vor Kartons und Artikel kommen. Das entspricht der CPS-Reihenfolge in EDIFACT.
RECADV Kreuzreferenz: EdiRecadvWrite setzt automatisch RFF+ON mit dem orderRef-Wert. So kann die Gegenseite Wareneingang und Bestellung zuordnen.

Quelldatei

Unit	Datei
`std.edi.shipping`	`std/edi/shipping.lyx`

Letzte Aktualisierung: 2026-06-16