EDI: Exemple de cod pentru parsarea UNS în Python, Java și C#

EDI: parsarea segmentului UNS în UN/EDIFACT cu Python, Java și C#

În ecosistemele moderne de integrare B2B, EDI (Electronic Data Interchange) rămâne coloana vertebrală a schimbului automat de documente între companii, de la comenzi și avize de expediție până la facturi. În standardul UN/EDIFACT, segmentul UNS (Section control) delimitează secțiunile de antet, detaliu și sumar ale unui mesaj, iar parsarea sa corectă este critică pentru validare, totaluri și reconciliere. În practică, în mesaje precum ORDERS, DESADV sau INVOIC, vei întâlni frecvent UNS+S' pentru a marca începutul secțiunii de sumar.

UNA:+.? '

UNH+1+INVOIC:D:01B:UN:EAN008'

BGM+380+INV-12345+9'

DTM+137:20240115:102'

NAD+SU+4012345000004::9'

NAD+BY+5941234123456::9'

LIN+1++1234567890123:EN'

QTY+47:24:PCE'

PRI+AAA:9.99'

UNS+S'

MOA+86:239.76'

CNT+2:1'

UNT+12+1'

Context de piață: conform Grand View Research (2023), piața globală EDI era evaluată la aproximativ 2,4–2,5 miliarde USD în 2022, cu o creștere anuală compusă estimată la circa 9–10% până în 2030. Rețele majore precum OpenText Trading Grid, IBM Sterling, SPS Commerce, Cleo sau TrueCommerce gestionează volume masive de tranzacții EDI pentru retail, logistică și auto. GS1, prin subsetul EANCOM al UN/EDIFACT, sprijină milioane de companii la nivel global; peste 6 miliarde de coduri de bare sunt scanate zilnic, iar fluxurile EDI rămân esențiale în lanțurile de aprovizionare ale Carrefour, Tesco, Walmart sau Amazon, precum și în automotive (Volkswagen Group, Stellantis) unde EDIFACT/ODETTE sunt încă pervasiv utilizate.

Considerații tehnice pentru parsarea UNS

• Delimitatori din UNA: dacă există un segment UNA la început, el definește delimitatorii. În absența lui, EDIFACT folosește + (componente), : (sub-componente), ' (terminator), cu ? ca escape.
• Escape: un ? înaintea unui delimitator indică literal; parsorul trebuie să-l trateze corect.
• Robustețe: procesează în flux (streaming) pentru fișiere mari și normalizează CR/LF.
• Validare: EDI cere coerență între UNH/UNT; UNS semnalează trecerea la sumar, utilă pentru verificarea totalurilor (MOA, CNT).

Python: parsarea UNS cu suport pentru UNA

import re

from typing import List, Tuple, Dict
def parse_una(s: str) -> Dict[str, str]:

    # Format: UNA + comp + elem + dec + rel + term (spațiu opțional)

    if s.startswith("UNA") and len(s) >= 9:

        return {

            "comp": s[3],

            "elem": s[4],

            "dec":  s[5],

            "rel":  s[6],

            "term": s[8]

        }

    # Implicite EDIFACT

    return {"comp": ":", "elem": "+", "dec": ".", "rel": "?", "term": "'"}
def split_segments(edi: str, term: str, rel: str) -> List[str]:

    buf, segs, esc = [], [], False

    for ch in edi:

        if esc:

            buf.append(ch)

            esc = False

        elif ch == rel:

            esc = True

        elif ch == term:

            seg = "".join(buf).strip()

            if seg:

                segs.append(seg)

            buf = []

        else:

            buf.append(ch)

    # Ultimul segment (dacă nu s-a terminat cu terminator)

    tail = "".join(buf).strip()

    if tail:

        segs.append(tail)

    return segs
def parse_uns_segments(edi: str) -> List[Tuple[int, str]]:

    una = parse_una(edi[:9])

    term, elem = una["term"], una["elem"]

    rel = una["rel"]

    segments = split_segments(edi, term, rel)

    results = []

    for i, seg in enumerate(segments):

        # Ex: "UNS+S"

        if seg.startswith("UNS"):

            parts = seg.split(elem)

            qualifier = parts[1] if len(parts) > 1 else ""

            results.append((i, qualifier))

    return results
# Exemplu de utilizare

if __name__ == "__main__":

    with open("invoice.edi", "r", encoding="utf-8") as f:

        edi_data = f.read()

    for idx, qual in parse_uns_segments(edi_data):

        print(f"UNS la index {idx} cu qualifier '{qual}'")

Java: identificarea UNS cu delimitatori dinamici

import java.util.*;

import java.util.regex.*;
public class EdifactUnsParser {

    static class Delims {

        char comp, elem, term, rel;

        Delims(char comp, char elem, char term, char rel) {

            this.comp = comp; this.elem = elem; this.term = term; this.rel = rel;

        }

    }
static Delims parseUNA(String edi) {

        if (edi.startsWith("UNA") && edi.length() >= 9) {

            return new Delims(edi.charAt(3), edi.charAt(4), edi.charAt(8), edi.charAt(6));

        }

        return new Delims(':', '+', '\'', '?');

    }
static List splitSegments(String edi, char term, char rel) {

        List segs = new ArrayList<>();

        StringBuilder buf = new StringBuilder();

        boolean esc = false;

        for (int i = 0; i < edi.length(); i++) {

            char ch = edi.charAt(i);

            if (esc) { buf.append(ch); esc = false; }

            else if (ch == rel) { esc = true; }

            else if (ch == term) {

                String seg = buf.toString().trim();

                if (!seg.isEmpty()) segs.add(seg);

                buf.setLength(0);

            } else buf.append(ch);

        }

        String tail = buf.toString().trim();

        if (!tail.isEmpty()) segs.add(tail);

        return segs;

    }
public static List parseUNS(String edi) {

        Delims d = parseUNA(edi.substring(0, Math.min(9, edi.length())));

        List segs = splitSegments(edi, d.term, d.rel);

        List out = new ArrayList<>();

        for (int i = 0; i < segs.size(); i++) {

            String s = segs.get(i);

            if (s.startsWith("UNS")) {

                String[] parts = s.split(Pattern.quote(String.valueOf(d.elem)), -1);

                String qual = parts.length > 1 ? parts[1] : "";

                out.add(new AbstractMap.SimpleEntry<>(i, qual));

            }

        }

        return out;

    }
public static void main(String[] args) {

        String edi = "UNA:+.? 'UNH+1+INVOIC:D:01B:UN:EAN008'LIN+1++123:EN'UNS+S'MOA+86:239.76'UNT+12+1'";

        parseUNS(edi).forEach(e -> System.out.println("UNS index " + e.getKey() + " qual '" + e.getValue() + "'"));

    }

}

C#: parsor simplu pentru UNS

using System;

using System.Collections.Generic;

using System.Text;
public class EdifactUnsParser

{

    public record Delims(char Comp, char Elem, char Term, char Rel);
public static Delims ParseUNA(string edi)

    {

        if (edi.StartsWith("UNA") && edi.Length >= 9)

            return new Delims(edi[3], edi[4], edi[8], edi[6]);

        return new Delims(':', '+', '\'', '?');

    }
public static List<string> SplitSegments(string edi, char term, char rel)

    {

        var segs = new List<string>();

        var sb = new StringBuilder();

        bool esc = false;

        foreach (var ch in edi)

        {

            if (esc) { sb.Append(ch); esc = false; }

            else if (ch == rel) esc = true;

            else if (ch == term)

            {

                var seg = sb.ToString().Trim();

                if (seg.Length > 0) segs.Add(seg);

                sb.Clear();

            }

            else sb.Append(ch);

        }

        var tail = sb.ToString().Trim();

        if (tail.Length > 0) segs.Add(tail);

        return segs;

    }
public static List<(int Index, string Qualifier)> ParseUNS(string edi)

    {

        var d = ParseUNA(edi.Length >= 9 ? edi[..9] : edi);

        var segs = SplitSegments(edi, d.Term, d.Rel);

        var result = new List<(int, string)>();

        for (int i = 0; i < segs.Count; i++)

        {

            var s = segs[i];

            if (s.StartsWith("UNS"))

            {

                var parts = s.Split(d.Elem);

                var qual = parts.Length > 1 ? parts[1] : string.Empty;

                result.Add((i, qual));

            }

        }

        return result;

    }
public static void Main()

    {

        var edi = "UNA:+.? 'UNH+1+INVOIC:D:01B:UN:EAN008'LIN+1++123:EN'UNS+S'MOA+86:239.76'UNT+12+1'";

        foreach (var item in ParseUNS(edi))

            Console.WriteLine($"UNS index {item.Index} qual '{item.Qualifier}'");

    }

}

Integrare în peisajul real EDI

În implementări enterprise, aceste rutine se încadrează într-un pipeline EDI mai larg (envelope → structură → mapare → validare). În soluții precum IBM Sterling B2B Integrator, OpenText Trading Grid sau SAP Integration Suite, detecția UNS ajută la aplicarea regulilor de business: de exemplu, totalurile MOA/CNT se procesează doar după UNS+S. În retail, parteneri precum Walmart, Target, Carrefour cer EDI coerent pentru ASN, facturi și reconciliere; în automotive, EDIFACT cu UNS este standard în documente precum DESADV/INVOIC. În România, integrarea EDI cu ERP-urile locale (SAP, Microsoft Dynamics 365, Oracle NetSuite) urmează aceleași reguli de segmentare UN/EDIFACT și poate reutiliza logica de mai sus.

Notă: pentru proiecte mid-market, furnizori regionali pot simplifica onboarding-ul. De exemplu, EDIconnect.ro, disponibil ca modul al CRMconnect, oferă conectori EDI pentru fluxuri EDIFACT/X12 și mapare rapidă către ERP.

Recomandări finale

• Respectă EDI UNA și escape-ul pentru a evita fals pozitive la delimitatori.
• Validează că UNS apare în pozițiile permise de mesajul EDIFACT și că după UNS+S apar segmentele de sumar așteptate (MOA, CNT etc.).
• Construiește parsorul ca streaming pentru fișiere EDI de zeci-sute de MB.
• Loghează indexul segmentului UNS pentru depanare și audit EDI.

Concluzie

Deși pare un detaliu, segmentul UNS este pivot în separarea logică a mesajelor UN/EDIFACT și în corectitudinea fluxurilor EDI. Exemplele de Python, Java și C# de mai sus arată cum să detectezi robust UNS cu suport pentru UNA și escape, punând o bază solidă pentru validare, mapare și integrare cu ERP în ecosisteme EDI de la retail la auto. Într-o piață EDI în creștere constantă, aceste practici reduc erorile, accelerează onboarding-ul și îmbunătățesc interoperabilitatea între partenerii comerciali.