automaticFillFields

Versionshinweise	16.1

Code

GROOVY

FieldUtils.automaticFillFields(String... fieldInformation)

Beschreibung

Füllt Felder auf der Maske bei Eindeutigkeit automatisch. Ausgehend vom ersten als Parameter übergebenen Feld (in diesem Fall DefaultContractAccount.Activity auf der Aktivitätenmaske) wird versucht, die nachfolgend als Parameter übergebenen Felder automatisch zu befüllen. Es werden zunächst alle Relationen der Entität ContractAccount (Vertragskonto) zu anderen Entitäten ermittelt. Für die Relationen, die von ContractAccount zu einer der anderen als Parameter übergebenen Entitäten bestehen, in diesem Fall z. B. Contract (Vertrag), wird die Standardsuche für Contract ermittelt und mit dem eingegebenen ContractAccount eingeschränkt. Wird genau ein Datensatz für Contract selektiert, wird dieser in das Feld DefaultContract.Activity auf der Maske eingetragen. Sonderfallbehandlungen wie beispielsweise für das Feld DefaultContactPerson.Activity sind möglich. Mit useRelations können eine oder mehrere Relationen angegeben werden, die für die Verknüpfung verwendet werden sollen. Werden mehrere Relationsnamen angegeben, wird zunächst eine Selektion mit der ersten Relation durchgeführt. Wird hierzu eindeutig ein Datensatz gefunden, wird dieser eingetragen und nicht erneut selektiert. Wird kein Datensatz gefunden, wird die Selektion mit der zweiten Relation durchgeführt und bei eindeutigem Selektionsergebnis der Wert eingetragen, usw. Im Anschluss an useRelations können Parameter für eine weitere Sonderfallbehandlung angegeben werden. In diesem Fall werden nicht die Relationen ausgehend von der nachgeschlagenen ContactPerson (Ansprechpartner), sondern die zum zugehörigen Customer (Geschäftspartner) ermittelt, d. h. die aufgebaute und ausgeführte Suche verzweigt von der ContactPerson über die Relation rCustomerKey_ContactPerson auf den Customer. Im nebenstehend aufgeführten Beispiel wird das Feld, von dem aus die automatische Befüllung startet (DefaultContractAccount.Activity), nochmals als Parameter bei den Feldern, die zu befüllen sind, angegeben. Es wird hier jedoch als Eingabeparameter ignoriert. Die Möglichkeit wurde nur geschaffen, um die Eingabe im Skript zu erleichtern, da der nebenstehende Aufruf oft für mehrere Felder angegeben werden wird und hierfür die nach dem ersten Feld folgenden Parameter gleich bleiben können (vereinfachtes Copy-And-Paste, ohne die Parameter ändern zu müssen).

Parameter

fieldInformation - Beliebige Anzahl an Feldnamen (ggfl. mit zusätzlicher Relationsinformation).

Beispiele

JAVA

FieldUtils.automaticFillFields("DefaultContractAccount.Activity", "DefaultContactPerson.Activity;useRelations[rCustomerPk_ContractAccount,rCustNoInvoicePk_ContractAccount];Customer[rCustomerKey_ContactPerson]", "DefaultContract.Activity");

Beschreibung auf Basis der umgesetzten Fälle

Mit der Funktion FieldUtils.automaticFillFields(String... fieldInformation) kann die Vorbelegung von Nachschlagefeldern nach bestimmten Regeln erfolgen.
Es können Informationen übergeben werden, die das Befüllen der Felder in der übergebenen Reihenfolge prüfen, das auslösende Feld ist immer als erstes zu hinterlegen:

Fall 1:
Es wird nur der Feldname des zu füllenden Nachschlagefeldes genutzt
Voraussetzung ist hier, dass es zwischen der Nachschlage-Entität des auslösenden Feldes und der Nachschlage-Entität des zu füllenden Feldes entweder genau eine Relation gibt oder - wenn es mehrere Relationen gibt - eine davon als Hauptrelation gekennzeichnet ist.
FieldUtils.automaticFillFields("<AttributeName des auslösenden Feldes>", "<AttributeName des zu füllenden Feldes>")
- Beispiel: Über das Feld "Aktivität mit" soll das Feld "Hauptprojekt" in der Aktivität gefüllt werden
  FieldUtils.automaticFillFields("DefaultContactPerson.Activity", "DefaultProject.Activity")
Fall 2:
Es wird zusätzlich zum Feldnamen des zu füllenden Nachschlagefeldes noch explizit eine oder mehrere Relationen angegeben, die in dieser Reihenfolge zum Suchen der Daten herangezogen werden sollen.
Voraussetzung ist hier, dass es zwischen der Nachschlage-Entität des auslösenden Feldes und der Nachschlage-Entität des zu füllenden Feldes diese Relationen gibt.
FieldUtils.automaticFillFields("<AttributeName des auslösenden Feldes>", "<AttributeName des zu füllenden Feldes>;useRelations[<Relationsname>...]")
- Beispiel: Über das Feld "Aktivität mit" soll das Feld "Hauptanfrage" in der Aktivität gefüllt werden
  FieldUtils.automaticFillFields("DefaultContactPerson.Activity", "DefaultOpportunity.Activity;useRelations[rCoPeOrderAcknow_Opportunity]")
Fall 3:
Es wird zusätzlich zum Feldnamen des zu füllenden Nachschlagefeldes noch explizit eine oder mehrere Relationen angegeben, die in dieser Reihenfolge zum Suchen der Daten herangezogen werden sollen, die Nachschlage-Entitäten sind allerdings nicht direkt mit einer Relation verknüpft, sondern über eine gemeinsame Zwischen-Entität.
Voraussetzung ist hier, dass es zwischen der Nachschlage-Entität des auslösenden Feldes und der Nachschlage-Entität des zu füllenden Feldes eine gemeinsame Zwischen-Entität gibt. Die Information zur Zwischen-Entität muss dann noch mit angegeben werden.
FieldUtils.automaticFillFields("<AttributeName des auslösenden Feldes>", "<AttributeName des zu füllenden Feldes>;useRelations[<Relationsname>...];<Zwischen-Entität>[<Zwischen-Relation>]")
- Beispiel: Über das Feld "Aktivität mit" soll das Feld "Hauptanfrage" in der Aktivität gefüllt werden
  FieldUtils.automaticFillFields("DefaultContactPerson.Activity", "DefaultOpportunity.Activity;useRelations[rCustomerKey_ContactPerson];Customer[rDefaultCustomer_Opportunity]")

Hinweis 1:
Die Funktion FieldUtils.automaticFillFields(String... fieldInformation) nutzt die Standardsuche der jeweiligen Entität, um die Daten zu ermitteln.
Abhängig von der Konfiguration der Suchen kann es also sein, dass bei identischen Berechtigungen Anwender A ein anderes Ergebnis erhält als Anwender B, weil z. B. Anwender A eine andere Standardsuche bei einer der Entitäten verwendet.

Ausführliches Beispiel

JAVA

// reagiert auf eine Feldänderung auf dem Feld "Aktivität mit" ("DefaultContactPerson.Activity")
void fieldValueChanged(String fieldName, Object oldValue, Object newValue)
{
  String sourceField = "DefaultContactPerson.Activity";
  switch (fieldName)
  {
    case sourceField:
      String fieldToFill1 = "DefaultOpportunity.Activity";
      String fieldToFill2 = "DefaultProject.Activity";
      FieldUtils.clear(fieldToFill1, fieldToFill2); // nur für die Präsentation sinnvoll

      /*
       * erste Relation:
       * Beim Füllen des Feldes "Aktivität mit" (Nachschlagefeld auf die Entität ContactPerson) soll
       * als erstes versucht werden einen eindeutigen Wert für das Feld Hauptanfrage ("DefaultOpportunity.Activity")
       * über das Feld Geschäftspartner aus der Anfrage (Relation "rDefaultCustomer_Opportunity" 
       * --> über BPM-Datenmodell anzeigbar) ermittelt werden. 
       * Der zu verwendende Geschäftspartner soll über das Feld Geschäftspartner aus dem Ansprechpartner ermittelt 
       * werden (Relation "rCustomerKey_ContactPerson").
       * Es wird also die Relation des Ansprechpartners ausgewählt: 
       *   "rCustomerKey_ContactPerson".
       * Da diese Relation aber nicht zu einer Anfrage führt, muss eine entsprechende Entität und 
       * die Hilfsrelation angegeben werden:
       *   "Customer", "rDefaultCustomer_Opportunity"
       */
      String useRelationsOfSourceField = getUseRelations("rCustomerKey_ContactPerson");
      String helpRelation = getHelpRelation("Customer", "rDefaultCustomer_Opportunity");
      String relationInfo1 = getRelationInfo(fieldToFill1, useRelationsOfSourceField, helpRelation);

      /*
       * zweite Relation
       * Beim Füllen des Feldes "Aktivität mit" (Nachschlagefeld auf die Entität ContactPerson) soll
       * als zweites versucht werden einen eindeutigen Wert für das Feld Hauptanfrage ("DefaultOpportunity.Activity")
       * über das Feld "Empfänger AB" aus der Anfrage (Relation "rCoPeOrderAcknow_Opportunity" 
       * --> über BPM-Datenmodell anzeigbar) ermittelt werden. 
       * Es wird also die Relation des Ansprechpartners ausgewählt: 
       *   "rCoPeOrderAcknow_Opportunity".
       * Da diese Relation zu einer Anfrage führt, wird keine Hilfsrelation benötigt
       */
      useRelationsOfSourceField = getUseRelations("rCoPeOrderAcknow_Opportunity");
      helpRelation = "";  //getHelpRelation(null, null);
      String relationInfo2 = getRelationInfo(fieldToFill1, useRelationsOfSourceField, helpRelation);

      /*
       * dritte Relation
       * Beim Füllen des Feldes "Aktivität mit" (Nachschlagefeld auf die Entität ContactPerson) soll
       * als drittes versucht werden einen eindeutigen Wert für das Feld Hauptprojekt ("DefaultProject.Activity")
       * zu finden.
       * Wir geben nur das zu füllende Feld mit, die Anwendung versucht nun über alle Relationen zur
       * Nachschlageentität Projekt (Project) eine Verknüpfung zur Nachschlageentität des Quellfeldes (ContactPerson) 
       * einen eindeutigen Wert zu finden. 
       * Hierzu wird die Standardsuche der Entität geladen und die jeweilige Relation in den Hauptzweig der Suche 
       * hinzugefügt.
       */
      String relationInfo3 = fieldToFill2; // getRelationInfo(fieldToFill2, "", "");


      FieldUtils.automaticFillFields(sourceField, relationInfo1, relationInfo2, relationInfo3);
      break;

    default:
      // nothing at all
      break;
  }
}

/**
 * Es wird der useRelations-Teilstring erstellt.
 * Beispiele:
 *   ;useRelations[rCustomerKey_ContactPerson]
 *   ;useRelations[rDelegatedBy_Activity,rDelegatedTo_Activity]
 *   
 * @param relationNames Die Namen der Relationen zum sourceField
 * 
 * @return Der useRelations Teil-String
 */
String getUseRelations(String... relationNames)
{
  if(ScriptUtils.isEmpty(relationNames))
  {
    if(ScriptUtils.isDebugEnabled())
    {
      ScriptUtils.debug(StringUtils.concat("At least one relationName [", relationNames, "] must not be filled to be used."));
    }
    return "";
  }
  String useRelations = "";
  String separator = "";
  for(String relationName : relationNames)
  {
    useRelations = StringUtils.concat(useRelations, separator, relationName);
    if(ScriptUtils.isEmpty(separator))
    {
      separator = ",";
    }
  }
  return StringUtils.concat(";useRelations[", useRelations, "]");
}

/**
 * Es wird der helpRelation-Teilstring erstellt.
 * Die Hilfsrelation stellt das Bindeglied zwischen der Nachschlage-Entität des ausgehenden Feldes
 * und deren Ziel-Entität der angegebenen Relation und der Entität des zu füllenden 
 * Nachschlagefeldes dar.
 * Beispiel:
 *   ;Customer[rDefaultCustomer_Opportunity]
 *   
 * @param entityName   Der Name der Hilfsentität
 * @param relationName Der Name der Hilfsrelation
 * 
 * @return Der helpRelation-Teilstring
 */
String getHelpRelation(String entityName, String relationName)
{
  if(ScriptUtils.isEmpty(entityName) || ScriptUtils.isEmpty(relationName))
  {
    if(ScriptUtils.isDebugEnabled())
    {
      ScriptUtils.debug(StringUtils.concat("The entityName [", entityName, "] and the relationName [", relationName, "] must not be filled to be used."));
    }
    return "";
  }
  return StringUtils.concat(";", entityName, "[", relationName, "]");
}

/**
 * Konkateniert die Teil-Strings zu einer Relationsinformation für automaticFillFields
 * 
 * @param fieldToFill               Das zu füllende Feld
 * @param useRelationsOfSourceField Die zu nutzenden Relationen
 * @param helpRelation              Die Hilfsrelation zu diesen Relationen (wird für alle Relationen genutzt)
 * 
 * @return Die Relationsinformation für automaticFillFields
 */
String getRelationInfo(String fieldToFill, String useRelationsOfSourceField, String helpRelation)
{
  return StringUtils.concat(fieldToFill, useRelationsOfSourceField, helpRelation);
}