Variantenfunktionen 

Verwendung

Mit Hilfe von Variantenfunktionen können Sie Prüfungen und Herleitungen von Werten auslösen. Sie können Variantenfunktionen zum Beispiel benutzen, um

·        komplexe Berechnungen aufgrund von Merkmalswerten der Konfiguration oder

·        aufwendige Gültigkeitsprüfungen für erlaubte Merkmalswerte durchzuführen.

Wenn Sie Variantenfunktionen einsetzen wollen, müssen Sie diese Funktionen selbst bereitstellen, daher werden sie auch benutzerdefinierte Variantenfunktionen genannt.

Integration

Variantenfunktionen sind als kundenspezifisches Coding zu erstellen, das mit den Schlüsselwörtern FUNCTION und PFUNCTION aus dem Beziehungswissen aufgerufen wird. Dabei werden Merkmale und Merkmalswerte in einer Liste von paarweise aufgeführten Parameternamen und zugehörigen Parameterwerten übergeben. Variantenfunktionen sind Teil der Wissensbasis.

Um Variantenfunktionen in der Variantenkonfiguration des mySAP ERP verwenden zu können, müssen sie in ABAP programmiert werden; zur Verwendung in der Produktkonfiguration mit der Configuration Engine müssen sie jedoch in Java implementiert sein.

Eine Variantenfunktionen müssen Sie in jedem Fall als ABAP-Baustein anlegen, der in seinem Rumpf zumindest die Anforderungen an die Schnittstelle abdeckt. Denn Sie können eine Variantenfunktion nur dann in den Status Freigegeben versetzen, wenn sie sich als ausführbar erweist.

Es gibt keine automatische Übersetzung von ABAP in Java.

Die Produktkonfiguration mit der Configuration Engine basiert auf Laufzeitversionen von Wissensbasisobjekten. Daraus resultieren Einschränkungen bezüglich der Verfügbarkeit von Stammdaten (siehe ERP-Stammdaten und Configuration Engine). Prüfen Sie jede Variantenfunktion, ob sie mit den verfügbaren Daten wie gewünscht arbeitet.

Variantenfunktionen in mySAP ERP

Die Parameter für Import und Export einer Variantenfunktion definieren Sie im ERP mit Hilfe der Transaktionen cu65, cu66 und cu67. Dabei implementieren Sie Variantenfunktionen als ABAP-Funktionen (siehe Benutzerdefinierte Funktionen).

Variantenfunktionen und Configuration Engine

Da die Configuration Engine nicht mit ABAP-Funktionen arbeiten kann, müssen Sie die im ERP definierten Variantenfunktionen noch einmal in Java erstellen.

Beim Start einer Konfiguration durchsucht die Configuration Engine die Wissensbasis automatisch nach Java-Klassen der Variantenfunktionen, die exakt denselben Namen tragen müssen, wie die im ERP erstellten. Ist keine Variantenfunktion auffindbar, so führt die Configuration Engine stellvertretend die Funktion sce_noop_fn aus, mit der Ausgabe true.

Voraussetzungen

Wenn Sie Variantenfunktionen implementieren wollen, sollten Sie über folgende Voraussetzungen verfügen:

·        Grundverständnis der Produktkonfiguration

·        ABAP-Kenntnisse zum Grundverständnis von Variantenfunktionen

·        Kenntnisse der Java-Programmierung

·        Optional eine Java-integrierte Entwicklungsumgebung (IDE)

Funktionsumfang

Es gibt zwei Typen von Variantenfunktionen, die sich in Definition und Form gleichen. Sie adressieren jedoch unterschiedliche Objekte und bieten daher unterschiedliche Möglichkeiten:

Eigenschaften	FUNCTION	PFUNCTION
Funktion	Liest die Wissensbasis, um Exportparameter herzuleiten. Mit Exportparametern können Werte gesetzt werden. Liest Informationen bzgl. des Modells aus der Wissensbasis.	Liest und schreibt im Zugriff auf die Konfiguration und dynamische Datenbank (DDB)
Verwendung im Beziehungswissen	Verwendbar in Prozeduren, Constraints, Vorbedingungen und Selektionsbedingungen	Verwendbar nur in Prozeduren
Adressierung	Import- und Exportparameter und Wissensbasis	Alle Objekte der Konfiguration
Risiken	Keine	Es können inkonsistente Zustände auftreten, wenn Änderungen der Konfiguration auftreten, die an den Schnittstellen vorbei gehen.

Variantenfunktionen erstellen

Beim Erstellen von Variantenfunktionen für Modelle zur Produktkonfiguration mit der Configuration Engine müssen Sie berücksichtigen, dass die Configuration Engine auf dem Java Transaction Server aufsetzt und dessen Infrastruktur benutzt. Weitere Information hierzu sowie zu den nachfolgend beschriebenen Schritten finden Sie im SAP-Hinweis 870201.

Systemumgebung

Gehen Sie zur Erstellung von Variantenfunktionen wie folgt vor:

       1.      Laden Sie die erforderlichen Java-Klassen der Configuration Engine aus Ihrer Systemumgebung, z. B. dem ERP in Ihre Entwicklungsumgebung. Hierfür steht Ihnen ein Report zur Verfügung.

       2.      Implementieren Sie Ihre Variantenfunktionen und berücksichtigen Sie dabei bestimmte Einschränkungen, die sich aus der Notwendigkeit zur Serialisierung ergeben. Kompilieren Sie die Variantenfunktionen mithilfe der Configuration Engine Java-Klassen und bereiten Sie die Funktionen für das Laden ins System vor.

       3.      Laden Sie die Variantenfunktionen mithilfe eines Reports in das System.

Wenn Sie die neu ins System geladenen Variantenfunktionen überprüfen wollen, benötigen Sie – wie generell zum Test Ihres Modells – eine aktuelle Laufzeitversion der Wissensbasis.

Implementierung

Erstellen Sie Variantenfunktionen in Form von Java-Klassen; benennen Sie diese Java-Klassen nach dem Muster com.sap.sce.user.<name>

Alle Benutzerfunktionen müssen die Schnittstelle sce_user_fn anwenden (siehe API-Dokumentation). Diese Schnittstelle kennt nur eine Methode: boolean execute(fn_args args, Object obj). Ein Beispiel für die Anwendung der Schnittstelle mithilfe einer Java-Klasse finden Sie nachfolgend.

Die formale Struktur einer Java-Klasse ist vom Typ der Variantenfunktion unabhängig und sollte mindestens folgenden Kern enthalten:

package com.sap.sce.user;

public class ZZ_FUNCTION implements sce_user_fn {

   public boolean execute(fn_args args, Object obj) {

      return true;

   }

}

Ausgabeparameter

Der Ausgabeparameter, vom Typ boolean, ist vor allem für solche Variantenfunktionen wichtig, die komplexe Bedingungen prüfen, z. B. in einem Constraint oder als Selektionsbedingung.

Der Parameter false entspricht der Ausnahme FAIL in ABAP. Der Ausgabeparameter kann auch zur Anzeige von Fehlern benutzt werden. Allgemein jedoch sollte der Ausgabeparameter auf true lauten, weil nur dann die Exportparameter der Variantenfunktion wirklich gesetzt werden.

Argument

Das Argument (args aus der Klasse fn_args) beinhaltet eine Reihe von Parametern der Variantenfunktion wie z. B. die Merkmale, die als Import oder Export der Funktion benutzt werden.

Importparameter müssen immer einen Wert beinhalten (≠ 0).

Methoden

Für den Import wird in ABAP die Struktur QUERY benutzt; für den Export die Struktur MATCH. Für die meisten Anwendungen sind folgende Methoden geeignet:

·        get_value: liest den Wert des Importparameters arg.

Die Ausgabe in Form eines Strings eignet sich für alphanumerische Merkmale.

Für numerische Merkmale eignet sich die Methode get_internal_value. Um das interne Format der Ausgabe in Zahlenwerte zu wandeln, wenden Sie Hilfsmethoden an (siehe Hilfsmethoden).

·        get_instance: referenziert $self instance (nur relevant für PFUNCTION).

Den meisten Zugriffen auf die DDB liegt diese Methode zugrunde.

Um auf andere Instanzen der Konfiguration zuzugreifen, können Sie Hilfsmethoden anwenden (siehe Hilfsmethoden).

·        set_value: setzt den Wert eines Exportparameters.

Ist für einen Exportparameter kein Wert setzbar, so resultiert daraus ein Laufzeitfehler.

Hilfsmethoden

Eine Sammlung nützlicher Methoden und Funktionen finden Sie in der SCELIB im Java-Klassen-Package com.sap.sce.user. Nutzen Sie diese Hilfsmittel um beispielsweise

·        komplexe Operationen mit nur einem Methodenaufruf oder

·        String-Vergleiche und Zeichenkonversionen durchzuführen.

Die meisten dieser Methoden eigenen sich für PFUNCTION, weil sie auf die DDB zugreifen, wie dies z. B. alle Methoden tun, die eine Instanz referenzieren.

Es gibt unter diesen Hilfsmethoden auch solche, die den ABAP-Funktionsmodulen der Gruppe CUPR entsprechen.

Weitere Informationen zu den Hilfsmethoden finden Sie in der API-Dokumentation.

Variantenfunktionen kompilieren

Kompilieren Sie die Quelldaten mit Hilfe Ihrer IDE oder dem entsprechenden Javac-Befehl.

Beispiel

package com.sap.sce.user;

import com.sap.sce.engine.*;

/*

 * Java Class for variant function Z_CABIN_LABEL.

 *

 * This variant function (PFUNCTION) does the following:

 * 1) Read the values of three characteristics:

 *    - ELEVATOR_TYPE (mandatory, using the standard characteristic
 *      interface)

 *    - MAX_LOAD (mandatory, using the standard characteristic interface)

 *    - ELEVATOR_OPTIONS (optional, multi-valued, using a method of SCELIB
 *      (similar to function group CUPR)

 * 2) Generate a string from the values in 1) and set it as value

 *    for characteristic CABIN_LABEL.

 *

 * Motivation:

 * 1) Since MAX_LOAD is numeric the string label cannot be generated

 *    using classical dependencies.

 * 2) Since ELEVATOR_OPTIONS is multi-valued, its values cannot be passed

 *    via the variant function interface and must be read directly from the

 *    configuration using a read access method (SCELIB).

 *

 * The variant function is activated as follows:

 * 1) Create an equally named variant function in ERP with input
 *    characteristics "ELEVATOR_TYPE" and "MAX_LOAD" and output parameter
.*    "CABIN_LABEL".

 * 2) Create a procedure with the following code and link it to the
 *    config.profile:

 *    pfunction Z_CABIN_LABEL (ELEVATOR_TYPE = $self.ELEVATOR_TYPE,

 *                             MAX_LOAD      = $self.MAX_LOAD,

 *                             CABIN_LABEL   = $self.CABIN_LABEL)

 */

 

public class Z_CABIN_LABEL implements sce_user_fn

   {

 

      public boolean execute(fn_args args, Object obj)

      {

            // get the target instance of the PFUNCTION

            ddb_inst inst = args.get_instance();

 

            // get elevator type from characteristic interface (Input):

            String elevatorType = args.get_value("ELEVATOR_TYPE");

 

            // get capacity from characteristic interface (Input):

            int capacity = Integer.parseInt(args.get_value("MAX_LOAD"));

 

            // get elevator options with read method (scelib) from
            // configuration:

            String[] elevatorOptions = scelib.get_values(
                        inst, "ELEVATOR_OPTIONS");

 

            // calculate the cabin label

            StringBuffer cabinLabel = new StringBuffer();

            cabinLabel.append(elevatorType);

               if(elevatorOptions.length > 0) {

                  cabinLabel.append("-");

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

                  cabinLabel.append(elevatorOptions[i]);

            }

            cabinLabel.append(" max load: " + capacity);

            if(cabinLabel.length() > 30)

            throw new IllegalArgumentException(

                        "Z_CABIN_LABEL: maximum length exceeded: "

                        + cabinLabel);

 

            // set value of cabin label in interface (Output)

            args.set_value("CABIN_LABEL", cabinLabel.toString());

 

            // NOTE: if you have a multi-valued output parameter or

            // an unknown number of output parameters you can set the
            // result values directly in the configuration via
            // scelib.set_value:
            // EXAMPLE: scelib.set_value(inst, "CABIN_LABEL",
            // cabinLabel.toString());

 

            return true;

      }

 

   }