Ziel dieses Tutorials ist es, eine Auftragsbestätigung per E-Mail direkt aus der SAP-Transaktion VA03 heraus zu versenden. Über einen Pushbutton wird eine .NET-Methode aufgerufen, die die Auftragsdaten per BAPI abruft und als formatierte HTML-E-Mail verschickt.

Wir fügen zunächst einen Pushbutton in die SAP-Maske ein:

GuiXT
pushbutton (3,22) "@J8\QSend order as e-mail@Per E-Mail versenden " _
    process="send_email_order_va03.txt"

Im Prozessscript send_email_order_va03.txt setzen wir zunächst eine Variable für die CC-Adresse und rufen anschließend die .NET-Methode asynchron über callvbasync auf. Die aktuelle Auftragsnummer wird als GuiXT-Feldwert übergeben:

GuiXT
// E-Mail-Kopie an
Set V[ccRef] "your@email.com"

// Auftragsübersicht per E-Mail versenden
callvbasync tutorials.utilities.send_order_html "&F[Auftrag]" _
    "your@email.com" "Synactive Mitarbeiter" "ccRef" _
    "Auftrag &F[Auftrag]"

Damit GuiXT .NET-Methoden aufrufen kann, muss die guinet.dll als Projektverweis in die Klassenbibliothek eingebunden werden:

Das Script fetchData wird von der .NET-Methode über g.Process() aufgerufen. Es ruft per BAPI BAPI_SALESORDER_GETDETAILBOS die Kopfdaten, Positionen und Adressinformationen des Auftrags ab. Die drei Datenbereiche werden mit dem Trennzeichen <|> zu einem einzigen Rückgabestring verbunden:

GuiXT (fetchData)
PARAMETER vbeln

// Auftragskopfdaten
CreateStructure V[orderheader] _
  sold_to doc_date purch_no net_val_hd currency purch_date

// Positionen
CreateTable V[orderitems] _
  itm_number material short_text req_qty sales_unit subtot_pp1

// Adressen
CreateStructure V[orderaddress] name street country postl_code city
CreateTable V[orderaddresses] include=V[orderaddress]

Call "BAPI_SALESORDER_GETDETAILBOS" _
  export.SALESDOCUMENT="vbeln" _
  import.ORDERHEADER="orderheader" _
  import.ORDERADDRESS="orderaddresses" _
  import.ORDERITEMS="orderitems"

return "&V[orderheader]<|>&V[orderitems]<|>&V[orderaddresses]"

Die Klasse Email enthält die SMTP-Konfiguration und den Versandaufruf. send_order erstellt eine MailMessage mit optionalem CC-Empfänger, aktiviert SSL über TLS 1.2/1.3 und verschickt die E-Mail über einen SmtpClient:

using guinet;
using System;
using System.Globalization;
using System.Net;
using System.Net.Mail;
using System.Text.Json.Nodes;

namespace Emails
{
    public class Email
    {
        private readonly string smtpHost = "your.server.de";
        private readonly int smtpPort = 587;

        private readonly string smtpUser = "your@email.com";
        private readonly string smtpPass = "password";

        public void send_order(
            string toEmail,
            string toName,
            string ccRef,
            string subject,
            string html)
        {
            MailMessage mail = new MailMessage();

            mail.From = new MailAddress(smtpUser, "Shop");
            mail.To.Add(new MailAddress(toEmail, toName));

            if (!string.IsNullOrEmpty(ccRef))
                mail.CC.Add(ccRef);

            mail.Subject = subject;
            mail.Body = html;
            mail.IsBodyHtml = true;

            SmtpClient smtp = new SmtpClient(smtpHost, smtpPort);

            smtp.Credentials = new NetworkCredential(
                smtpUser,
                smtpPass
            );

            smtp.EnableSsl = true;

            System.Net.ServicePointManager.SecurityProtocol =
                SecurityProtocolType.Tls12 |
                SecurityProtocolType.Tls13;

            smtp.Send(mail);
        }
    }

    // ...

Die Klasse SMTPUtils übernimmt den gesamten Aufbau der HTML-E-Mail. Die Hilfsmethode format normalisiert SAP-Dezimalzahlen: SAP gibt Beträge mit Komma als Dezimaltrennzeichen zurück (z.B. 1234,56), während Single.Parse mit CultureInfo.InvariantCulture einen Punkt erwartet. Das Komma wird daher ersetzt, der Wert geparst und mit zwei festen Nachkommastellen zurückgegeben.

send_order_html ist der Einstiegspunkt, den callvbasync aufruft. Über g.Process("fetchData", orderno) führt GuiXT das fetchData-Script im Kontext der aktuellen SAP-Sitzung aus und liefert den Rückgabestring direkt zurück. Als Trennzeichen zwischen den drei JSON-Blöcken dient <|> — eine Zeichenkombination, die in keinem SAP-Feldwert vorkommen kann. Nach dem Split werden Kopfdaten, Positionen und Adresse als separate JsonNode-Objekte geparst und die Auftrags-Kurzübersicht in den HTML-Body geschrieben:

    // ...

    public class SMTPUtils
    {
        // Normalisiert SAP-Dezimalzahlen in das Format "0,00"
        public string format(string input)
        {
            input = input.Replace(",", ".");
            float val = float.Parse(
                input, CultureInfo.InvariantCulture);
            return val.ToString(
                "0.00", CultureInfo.InvariantCulture);
        }

        public string send_order_html(
            string orderno,
            string toEmail,
            string toName,
            string ccRef,
            string subject)
        {
            guixt g = new guixt();

            // HTML-Dokumentkopf aufbauen
            string HTML =
                "<!doctype html><html><head>" +
                "<meta charset='utf-8'></meta>";

            try
            {
                HTML += table_add_css() + "</head>";
                HTML += "<body><hr>" +
                    "Kurzübersicht über Bestellung " +
                    orderno + "<br><hr><br><br>";

                // g.Process führt das fetchData-Script aus
                string data = g.Process("fetchData", orderno);
                // <|> als Trennzeichen — kommt in keinem Feldwert vor
                string[] data_arr = data.Split(
                    new[] { "<|>" },
                    StringSplitOptions.None
                );

                // Drei JSON-Blöcke parsen: Kopf, Positionen, Adresse
                JsonNode oHeader = JsonNode.Parse(data_arr[0]);
                JsonArray oItems =
                    JsonNode.Parse(data_arr[1]).AsArray();
                JsonNode oAddr =
                    JsonNode.Parse(data_arr[2])?[0];

                // Adressstring aus dem ersten Adresseintrag aufbauen
                string address =
                    $"{oAddr["name"]}/{oAddr["street"]}/" +
                    $"{oAddr["country"]}-" +
                    $"{oAddr["postl_code"]} {oAddr["city"]}";

                // Auftragsübersicht in den HTML-Body schreiben
                HTML += "Nettowert: " +
                    format(oHeader["net_val_hd"].ToString()) + " ";
                HTML += oHeader["currency"] + "<br>";
                HTML += "Auftraggeber: " +
                    address + "<br>";
                HTML += "Warenempfänger: " +
                    oHeader["sold_to"] + "<br>";
                HTML += "Bestellnummer: " +
                    oHeader["purch_no"] + "<br>";
                HTML += "Bestelldatum: " +
                    oHeader["purch_date"] + "<br>";

                HTML += "<br>Positionen:<br><br>";

                // ...

Die Positionstabelle wird vollständig als HTML-String aufgebaut. SAP liefert Positionsnummern mit führenden Nullen (z.B. 000010). Der Wert wird daher per Integer.Parse in eine Ganzzahl gewandelt und anschließend wieder als String ausgegeben — das entfernt die führenden Nullen zuverlässig ohne Zeichenkettenmanipulation. Die Zwischensumme aus dem BAPI-Feld subtot_pp1 wird über format normalisiert und zusammen mit der Währung aus den Kopfdaten in die letzte Spalte geschrieben:

                // ...

                // Positionstabelle aufbauen
                HTML += "<table cellspacing='0'><thead><tr>";
                HTML += "<th>Pos</th>";
                HTML += "<th>Mat.-Nr.</th>";
                HTML += "<th>Menge</th>";
                HTML += "<th>Einheit</th>";
                HTML += "<th>Beschreibung</th>";
                HTML += "<th>Zwischensumme</th>";
                HTML += "</tr></thead><tbody>";

                foreach (JsonObject item in oItems)
                {
                  // Integer.Parse entfernt führende Nullen, z.B. "000010" -> "10"
                    string itmNum = item["itm_number"].ToString();
                    int pos = int.Parse(itmNum);
                    HTML += "<tr>";
                    HTML += "<td>" + pos + "</td>";
                    HTML += "<td>" +
                        item["material"] + "</td>";
                    HTML += "<td>" +
                        item["req_qty"] + "</td>";
                    HTML += "<td>" +
                        item["sales_unit"] + "</td>";
                    HTML += "<td>" +
                        item["short_text"] + "</td>";
                    HTML += "<td>" +
                        format(item["subtot_pp1"].ToString()) +
                        " " + oHeader["currency"] +
                        "</td>";
                    HTML += "</tr>";
                }

                HTML += "</tbody></table>";

            // ...

Im Fehlerfall gibt send_order_html die Exception-Meldung als Rückgabewert zurück — GuiXT zeigt diesen String dann als Ergebnis von callvbasync an, was die Fehlersuche erleichtert.

table_add_css gibt einen <style>-Block zurück, der direkt in den HTML-Body eingebettet wird. Das ist notwendig, weil die meisten E-Mail-Clients — darunter Outlook und Gmail — CSS im <head> ignorieren oder entfernen. Inline-CSS im Body stellt sicher, dass die Tabelle in allen Clients korrekt dargestellt wird:

            // ...

            catch (Exception ex)
            {
                return ex.Message;
            }

            Email e = new Email();
            e.send_order(toEmail, toName, ccRef, subject, HTML);

            return HTML;
        }

        private string table_add_css()
        {
            return @"
<style>
table {
    width: 100%;
    border-collapse: collapse;
    font-family: Arial, sans-serif;
}
th, td {
    border: 1px solid #ddd;
    padding: 10px;
    text-align: left;
}
th {
    background-color: #f4f4f4;
    font-weight: bold;
}
tr:nth-child(even) {
    background-color: #fafafa;
}
tr:hover {
    background-color: #f1f1f1;
}
</style>";
        }
    }
}

Das Ergebnis:

E-Mail-Skripte herunterladen (ZIP)