Expertenmodus

1

Der „Expertenmodus“ ist für Anwender mit Java(grund)kenntnissen gedacht um außerhalb der „grafischen Editoren“ weitere Regeln/Fachlogik zu definieren. Jeder grafische Regeleditor beinhaltet einen Expertenmodus. Dieser kann über die Schaltfläche „Expertenmodus“ geöffnet werden. Bei jeder Regel, die über den grafischen Regeleditor definiert wird, wird automatisch im Expertenmodus einen Code erzeugt. Dieser Code kann nach Bedarf im Expertenmodus angepasst/erweitert/neu erstellt werden.

2

3

![[Ansicht des Expertenmodus|@Regelbau-Expertenregel-Package.jpg]]

4

5

Jede Expertenregel ([[Aktivierungsregeln|Main.05_Assistenten.04_Assistentenbauoberfläche.07_Regelbau.03_Klickregeln.01_Aktivierungsregeln]] und [[Berechnungsregeln|Main.05_Assistenten.04_Assistentenbauoberfläche.07_Regelbau.03_Klickregeln.02_Berechnungsregeln]]) verfügt über eine „Standardstruktur“, welche aus folgendem Pseudocode abgeleitet werden kann:

```javascript

rule "<Eindeutige Bezeichnung für die Regel>"

when

<Bedingung(en)>

then

end

```

> {{icon name="far fa-info-circle" size="3"/}} _**Hinweis:**_

19

20

1. Alle durch Größer-/Kleinerzeichen kenntlich gemachte Bereiche müssen ersetzen werden.

21

1. Die Einrückungen sowie Leerzeichen spielen keinerlei Rolle im Code und sind nur zur besseren Übersicht so dargestellt.

22

23

Nachfolgend wird die Standardstruktur, sowie zusätzliche Features, im Einzelnen erläutert:

24

25

* Basis-Paket/Importierungen & Regelnamen

26

* When-Teil

27

* Then-Teil

28

* Zusätzliche Features

---

## Basis-Paket/Importierungen & Regelnamen

### Basis-Paket

In jedem Bereich der Expertenregeln (Panel-/Komponentenregel) müssen bei einer Definition jeweils folgende Einträge **einmalig** vorgenommen werden.

37

38

```javascript

39

package de.formsolutions.metaform

40

import de.formsolutions.metaform.model.*

41

```

42

43

Werden beispielsweise mehrere Panelregeln auf demselben Panel definiert, muss die obige Definition nur einmalig vorgenommen werden. Jedoch werden eine Panel- und Komponentenregel definiert, müssen beide dieser Bereiche über das Paket und Importierungen verfügen.

### Importierungen

Folgende Importierungen können beispielsweise bei **Bedarf** hinzugefügt werden:

48

49

Diese Importierungen müssen in folgender Form dargestellt werden.

50

51

```javascript

52

import function de.formsolutions.metaform.rules.util.<Utilname>Util.<Funktionsname>

53

```

54

55

Die in der nachfolgenden Tabelle genannten Bezeichnungen wie beispielsweise „$Anzahl“ sind Variablen, die im Vorfeld benannt werden müssen.

#### MathUtil

| Funktionsname | Beschreibung | Beispiel |

60

| ------------- | -------------------------------------------------------------------------------------------------- | ------------------------------------------------------ |

61

| `apply` | Dem im ersten Parameter angegeben Objekt wird der im zweiten Parameter angegebene Wert zugewiesen. | `apply($Gesamt, add($Preis1, $Preis2))` |

62

| `add` | Alle gültigen Parameter werden aufsummiert | `apply($Gesamtanzahl, add($Anzahl, 1, 3))` |

63

| `subtract` | Der zweite Parameter wird vom ersten subtrahiert. | `apply($GesamtGebuehr, subtract($Gebuehr, $Rabatt))` |

64

| `multiply` | Alle gültigen Parameter werden multipliziert. | `apply($Gesamtpreis, multiply($Anzahl, $Einzelpreis))` |

65

| `divide` | Der erste Parameter wird durch den zweiten dividiert. | `apply($Gesamtpreis, divide($Gesamtpreis, $Anzahl))` |

66

| `min` | Die kleinste Zahl wird zurückgeliefert. | `apply($Gesamtpegel, min($Pegel1, $Pegel2))` |

67

| `max` | Die größte Zahl wird zurückgeliefert. | `apply($Gesamtpegel, max($Pegel1, $Pegel2))` |

68

| `fallback` | Sollte der erste Wert leer sein, wird der zweite zurückgeliefert. | `apply($Gesamtsteuer, fallback($MWSt, 0.19))` |

69

| `round` | Runde den ersten Wert auf so viele Stellen, wie im zweiten Parameter angegeben. | `apply($Gesamt, round($Gesamtpreis, 2))` |

#### DateUtil

Diese Importierung muss vorangestellt werden:

74

75

```javascript

76

import function de.formsolutions.metaform.rules.util.DateUtil.<Funktionsname>

77

import org.joda.time.LocalDate

78

```

79

80

| Funktionsname | Beschreibung | Beispiel |

81

| ---------------------- | --------------------------------------------------------------- | ------------------------------------------------------------------------------------------- |

82

| `isAfter` | Wert wird geprüft, ob dieser nach einem anderen Wert liegt. | `isAfter(new Date(), $VARIABLENNAME0)` |

83

| `isBefore` | Wert wird geprüft, ob dieser vor einem anderen Wert liegt. | `isBefore(new Date(), $VARIABLENNAME0)` |

84

| `isEqual` | Wert wird geprüft, ob dieser gleich ist mit einem anderen Wert. | `isEqual($VARIABLENNAME0, $VARIABLENNAME1)` |

85

| `isBetween` | Wert muss zwischen zwei anderen Werten liegen. | `isBetween($VARIABLENNAME, new LocalDate().minusYears(64), new LocalDate().minusYears(18))` |

86

| `computeDaysBetween` | Prüft die Länge zwischen zwei angegebenen Werten in Tagen. | `computeDaysBetween($VARIABLENNAME0, new Date())` |

87

| `computeWeeksBetween` | Prüft die Länge zwischen zwei angegebenen Werten in Wochen. | `computeWeeksBetween($VARIABLENNAME0, new Date())` |

88

| `computeMonthsBetween` | Prüft die Länge zwischen zwei angegebenen Werten in Monaten. | `computeMonthsBetween($VARIABLENNAME0, new Date())` |

89

| `computeYearsBetween` | Prüft die Länge zwischen zwei angegebenen Werten in Jahren. | `computeYearsBetween($VARIABLENNAME0, new Date())` |

90

| `isPersonOlderThan` | Wert wird geprüft, ob er höher ist als ein anderer Wert | `isPersonOlderThan($VARIABLENNAME0, ALTERSVARIABLE)` |

91

| `isMonday` | Prüft, ob der Wert ein Montag ist. | `if(isMonday($VARIABLENNAME0))` |

92

| `isTuesday` | Prüft, ob der Wert ein Dienstag ist. | `if(isTuesday($VARIABLENNAME0))` |

93

| `isWednesday` | Prüft, ob der Wert ein Mittwoch ist. | `if(isWednesday($VARIABLENNAME0))` |

94

| `isThursday` | Prüft, ob der Wert ein Donnerstag ist. | `if(isThursday($VARIABLENNAME0))` |

95

| `isFriday` | Prüft, ob der Wert ein Freitag ist. | `if(isFriday($VARIABLENNAME0))` |

96

| `isSaturday` | Prüft, ob der Wert ein Samstag ist. | `if(isSaturday($VARIABLENNAME0))` |

97

| `isSunday` | Prüft, ob der Wert ein Sonntag ist. | `if(isSunday($VARIABLENNAME0))` |

98

| `isTimeBefore` | Wert wird geprüft, ob dieser vor einem anderen Wert liegt. | `isTimeBefore(new Date(), $VARIABLENNAME0)` |

99

| `isTimeAfter` | Wert wird geprüft, ob dieser nach einem anderen Wert liegt. | `isTimeAfter(new Date(), $VARIABLENNAME0)` |

100

101

#### Sonstige Imports

102

103

Diese Importierung muss vorangestellt werden:

104

105

```javascript

106

import java.util.LinkedList;

107

import java.util.List;

108

import de.formsolutions.metaform.enums.<Funktionsname>

109

```

110

111

| Funktionsname | Beschreibung | Beispiel |

112

| -------------------- | ----------------------------------------------------------- | ---------------------------------------------------------- |

113

| `setPdfRenderOption` | Wert wird geprüft, ob dieser nach einem anderen Wert liegt. | `textoutput.setPdfRenderOption(PdfRenderOption.RENDERED);` |

114

115

> {{icon name="far fa-info-circle" size="3"/}} _**Hinweis:**_

116

117

1. Die Performance kann durch die Importierungen beeinflusst werden. Daher wird dazu geraten immer nur die Importierungen einzufügen, die auch wirklich benötigt werden.

118

1. Die Funktion "DateUtil" funktioniert nur mit Datumsfeldern.

### Regelname

Nun findet die eigentliche Definition der Regel statt. Hierzu ist es relevant, einen Regelnamen zu definieren. Dieser wird im Kontext der Expertenregel mit dem Stichwort `rule` eingeleitet. Der Regelname selbst muss von doppelten Anführungszeichen umgeben sein.

123

124

```javascript

125

package de.formsolutions.metaform

126

import de.formsolutions.metaform.model.*

127

128

rule "Beispiel-Regel"

when

<Bedingung(en)>

then

end

```

> {{icon name="far fa-info-circle" size="3"/}} _**Hinweis:**_

137

138

1. Alle durch Größer-/Kleinerzeichen kenntlich gemachte Bereiche müssen ersetzt werden.

139

1. Weiterhin darf ein Regelname nur einmalig vergeben werden.

---

## When-Teil

Der nächste relevante Schritt einer Expertenregel bezieht sich auf den sogenannten When-Teil, welcher gleichzeitig einer Bedingung entspricht. Erst wenn die definierte Bedingung zutreffend ist, wird eine weitere Ausführung der Regel vorgenommen. Dieser Teil wird durch das Stichwort `when` in der Expertenregel eingeleitet.

### Paneldefinition

Eine Paneldefinition ist dann relevant, wenn eine Referenz zu einem entfernten Panel aufgebaut werden soll. Beispiel: Es wird eine Panelregel auf „Panel B“ erstellt und es wird auf eine Komponente von „Panel A“ zugegriffen. Hierfür ist es relevant „Panel A“ eindeutig zu referenzieren.

150

151

Die Definition besteht aus zwei Funktionsweisen.

152

153

1. Es wird eine Variable definiert, auf welche im weiteren Verlauf der Regel zugegriffen wird. Diese impliziert die hinterlegte Komponente.

154

1. Beschreibt dieser Bereich eine Bedingung. Erst wenn diese als erfüllt gilt, wird der Then-Teil ausgelöst.`Panel(identifier == "<PANELNAME>", $<VARIABLENNAME>:getInputComponent ("<BEZEICHNUNG TECHNISCH>"), $<VARIABLENNAME> !=null)`

155

156

Auch in diesem Fall müssen jeweils alle Bereiche, die durch Größer-/Kleinerzeichen gekennzeichnet sind, ersetzt werden.

157

158

* < PANELNAME > bezieht sich auf das zu referenzierende Panel. Die Bezeichnung muss identisch wie der hinterlegte Panelname sein.

159

* < VARIABLENNAME > ist ein beliebig wählbarer Wert, welcher im weiteren Verlauf als Bezeichnung für die gewünschte Komponente hinterlegt wird (Keine Umlaute zulässig!). Somit muss im weiteren Verlauf bei beispielsweise einer Berechnung nicht wieder die volle „Bezeichnung technisch“ einer Komponente angegeben werden.

160

* < BEZEICHNUNG TECHNISCH > beschreibt die „Bezeichnung technisch“ einer Komponente. (Komponente bearbeiten -> „Bezeichnung technisch“)

161

* < VARIABLENNAME > entspricht der zuvor definierten Variable. Beide Werte sind in diesem Szenario identisch!

162

163

![[Exportwert in der Komponentenkonfiguration|@Regelbau-Expertenregel-Elementwert.jpg]]

164

165

> {{icon name="far fa-info-circle" size="3"/}} _**Hinweis:**_

166

167

1. Bei der Benennung spielen Leerzeichen sowie Objektgruppen auch eine Rolle. So muss beispielsweise der Objektgruppenname vor den Komponentennamen mittels eines Punkts getrennt werden.

168

1. Weiterhin ist drauf zu achten, dass die im Expertenmodus definierten Regeln nicht automatisch bei einer Änderung der Panel-/Komponentenbenennung geändert werden.

169

1. Auch werden die im Expertenmodus definierten Regeln nicht im grafischen Editor abgebildet.

Beispiel:

```javascript

package de.formsolutions.metaform

175

import de.formsolutions.metaform.model.*

176

177

rule "Beispiel-Regel"

178

when

179

Panel(identifier == "Panel A", $formsolutions:getInputComponent ("Komponente xy"), $formsolutions !=null)

then

end

```

### Verknüpfungen und Definitionen

186

187

Komponenten- und Paneldefinitionen sind beliebig verknüpfbar. Folgende Möglichkeiten sind gegeben:

188

189

1. Panel(...) and Panel(...) and ...

190

1. Panel(...) or Panel(...) and ...

191

1. (Panel(...) and Panel(...)) or ...

192

1. ...

193

194

> {{icon name="far fa-info-circle" size="3"/}} _**Hinweis:**_*

195

>

196

> Der Aufruf der Paneldefinition (s. o. Panel (. . . )) lässt sich auch durch die Komponentendefinition ersetzen.

197

198

### Komponentendefinition

199

200

Anders als bei Panelregeln, bei welchen die hinterlegten Regeln bei Aufruf eines Panels einmalig angestoßen werden, werden bei Komponentenregeln bei Änderungen der entsprechenden Panels/Komponenten jederzeit die Daten neu aufgerufen. Somit werden die Daten jederzeit „live“ aufgerufen.

201

202

Die Definition besteht aus zwei Funktionsweisen.

203

204

1. Es wird eine Variable definiert, auf welche im weiteren Verlauf der Regel zugegriffen wird. Diese impliziert die hinterlegte Komponente.

205

1. Beschreibt dieser Bereich eine Bedingung. Erst wenn diese als erfüllt gilt, wird der Dann-Teil ausgelöst.`Component ($<VARIABLENNAME>:searchInputComponent("<KOMPONENTENNAME>"), $<VARIABLENNAME> !=null)`Bei einer Paneldefinition ändert sich der Bereich `searchInputComponent` in `getInputComponent`.

206

207

* < VARIABLENNAME > ist ein beliebig wählbarer Wert, welcher im weiteren Verlauf als Bezeichnung für die gewünschte Komponente hinterlegt wird. (Keine Umlaute zulässig!)

208

* < KOMPONENTENNAME > beschreibt die „Bezeichnung technisch“ einer Komponente. (Komponente bearbeiten -> „Bezeichnung technisch“)

209

* < VARIABLENNAME > entspricht der zuvor definierten Variable. Beide Werte sind in diesem Szenario identisch!

210

211

Eine Hinterlegung des Panels ist nicht mehr relevant! Ist es wünschenswert Panelübergreifend tätig zu werden ist dies mittels „and/or“ einer Paneldefinition möglich.

212

213

> {{icon name="far fa-info-circle" size="3"/}} _**Hinweis:**_

214

>

215

> Bei der Benennung spielen Leerzeichen sowie Objektgruppen auch eine Rolle. So muss beispielsweise der Objektgruppenname vor den Komponentennamen und einem Punkt getrennt werden.

Beispiel:

```javascript

package de.formsolutions.metaform

221

import de.formsolutions.metaform.model.*

222

223

rule "Beispiel-Regel"

224

when

225

Component($form:searchInputComponent ("Komponente xy"), $form !=null) and Panel(identifier == "Panel A",

226

$solutions:getInputComponent("Komponente z"), $solutions !=null)

then

end

```

### Ermittlung eines Feldwertes

233

234

Um im When-Teil zu überprüfen, ob der Benutzer eine Eingabe getätigt hat, kann folgendes Schema verwendet werden:

235

236

```javascript

237

$<VARIABLENNAME>.getStringValue() == "formsolutions"

238

```

239

240

**== entspricht ist gleich**

241

Der Variablenname bezieht sich in diesem Fall auf die vorab definierte Komponente. Der vom Benutzer hier eingetragene Wert wird extrahiert und mit "formsolutions" verglichen. Sofern der Abgleich zutreffend ist, gilt die Bedingung als erfüllt.

Beispiel:

```javascript

package de.formsolutions.metaform

247

import de.formsolutions.metaform.model.*

248

249

rule "Beispiel-Regel"

250

when

251

Component($form:searchInputComponent ("Komponente xy"), $form !=null), $form.getStringValue() == "formsolutions" and

252

Panel(identifier == "Panel A", $solutions:getInputComponent("Komponente z"), $solutions !=null)

then

end

```

**!= entspricht ungleich**

259

260

```javascript

261

$<VARIABLENNAME>.getStringValue() != "formsolutions"

262

```

263

264

Obiges trifft nur dann zu, wenn der Nutzer ein anderes Wort wie „formsolutions“ einträgt.

---

## Then-Teil

Der Then-Teil entspricht der Konsequenz, also das, was ausgeführt wird, sofern alle zuvor definierten Bedingungen zutreffend sind. Eingeleitet wird dieser durch das Stichwort `then`. Abgeschlossen durch das Stichwort `end`.

271

272

### Panelfeld mit einem Wert vor befüllen

273

274

Um ein Feld eines Panels zu befüllen kommt folgende Methode zum Einsatz:

275

276

```javascript

277

$<VARIABLENNAME>.setStringValue("beliebiger Text");

278

```

279

280

Der Variablenname entspricht der im When-Teil definierten Variable. Der Bereich, welcher mit „beliebiger Text“ gekennzeichnet ist, kann beliebig ausgetauscht werden. Dies entspricht dem Wert, mit welchem das Feld vor befüllt werden soll.

Beispiel:

```javascript

package de.formsolutions.metaform

286

import de.formsolutions.metaform.model.*

287

288

rule "Beispiel-Regel"

289

when

290

Panel(identifier == "Panel A", $solutions:getInputComponent ("Komponente xy"), $solutions !=null)

291

then

292

$solutions.setStringValue("beliebiger Text");

end

```

> {{icon name="far fa-info-circle" size="3"/}} _**Hinweis:**_

297

>

298

> Eine Panelregel wird nur zum Aufruf der Seite ausgeführt. Das heißt, es ist in diesem Szenario nur möglich, ein Feld zum Start eines Panels zu befüllen. Um einen sofortigen Austausch zu ermöglichen, ist eine Komponentenregel relevant!

299

300

### Komponenten mit einem neuen Wert laden

301

302

Um ein Feld eines Panels in Abhängigkeiten des Benutzers zu befüllen, ist folgende Definition relevant, die an der Komponente hinterlegt wird, bei welcher sich der Wert verändert:

303

304

```javascript

305

String oldValue=$<VARIABLENNAME>.getStringValue();

306

307

if(!$<VARIABLENNAME>.getStringValue().equals(oldValue)){

308

$<VARIABLENNAME>.setNeededValueHasChanged(true);

}

```

Die Variablennamen beziehen sich auf die Komponente, bei welcher der Inhalt neu gesetzt werden soll. Die wird mit der Tätigkeit ersetzt, welche ausgeführt werden soll. Also beispielsweise das Befüllen des Feldes mit einem spezifischen Wert.

Beispiel:

```javascript

package de.formsolutions.metaform

318

import de.formsolutions.metaform.model.*

319

320

rule "Beispiel-Regel"

321

when

322

Component($solutions:searchInputcomponent("Komponente xy"), $solutions != null), $solutions.getStringValue() == "test")

323

and Component($form:searchInputcomponent("Komponente zz"), $form != null)

324

then

325

String oldValue=$form.getStringValue();

326

$form.setStringValue("formsolutions");

327

if(!$form.getStringValue().equals(oldValue)){

328

$form.setNeededValueHasChanged(true);

}

end

```

In obigem Beispiel wird überprüft, ob der Benutzer in der Komponente „Komponente xy“ den Wert „test“ eingetragen hat. Wenn ja, dann wird der Wert der Komponente „Komponente z“ auf "formsolutions" gesetzt.

---

## Zusätzliche Features

### no-loop

Beim Definieren von Regel kann durch falsch definierte Regeln „Regel-Schleifen“ erzeugt werden. Eine solche Regel-Schleife verursacht, dass die Regel immer und immer wieder ausgeführt wird. Mit der Hilfe des Ausdrucks `no-loop` kann einer solchen Regel-Schleife vorgebeugt werden. Eine solche Regel-Schleife erkennt man dran, wenn ein Fehler erscheint, mit dem Hinweis „zu viele Regelausführungen“ oder der Assistent nach dem Einbau der Regel der Ausfüllprozess extrem langsam wird.

Beispiel:

```javascript

package de.formsolutions.metaform

347

import de.formsolutions.metaform.model.*

348

349

rule " Beispiel-Regel"

no-loop

when

<Bedingung(en)>

then

end

```

#### Salience Wert

Über den `Salience Wert` kann die Ausführung der Regel „Prioritätsstufe“ definiert werden. Eine Erteilung/Änderung der Prioritätsstufe wäre beispielsweise nötig, wenn das Resultat von „Regel A“ für die „Regel B“ weiter benötigt wird. „Regel A“ muss also „bevorzugt ausgeführt“ werden und muss daher einen höheren Salience Wert erhalten. Beispielsweise sollte dann „Regel A“ einen Salience Wert von -1 und „Regel B“ einen Salience Wert von -2 erhalten.

Beispiel:

```javascript

package de.formsolutions.metaform

366

import de.formsolutions.metaform.model.*

367

368

rule "Beispiel-Regel"

salience -2

when

<Bedingung(en)>

then

end

```

---

## Regelvorlagen

Jeder Expertenmodus (Validierungsregelbereich, Panelregelbereich, Komponentenregelbereich) enthält eine Sidebar die sogenannte "Regelvorlagen" für den Assistentenersteller bereithält. Über die Schaltfläche mit dem Pfeil öffnet sich die Sidebar. In den jeweiligen Rubriken sind thematisch Regelvorlagen eingepflegt.

382

383

Folgende Rubriken beinhalten die Regelvorlage:

384

385

* **Datum**

386

Hier sind Regelvorlagen rund um das Thema Datumsberechnung und Datumsvalidierung enthalten. Der Inhalt ändert sich je nach Expertenmodusbereich. Wird angezeigt bei Validierungsregelexpertenmodus, Panelregelexpertenmodus und Komponentenregelexpertenmodus.

387

* **Vorbefüllung**

388

Hier sind Regelvorlagen rund um das Thema Vorbefüllung enthalten. Der Inhalt ändert sich je nach Expertenmodusbereich. Wird angezeigt bei Panelregelexpertenmodus und Komponentenregelexpertenmodus.

389

* **Verwendungszweck**

390

Hier sind Regelvorlagen rund um das Thema Verwendungszweck enthalten. Der Inhalt ändert sich je nach Expertenmodusbereich. Wird angezeigt bei Panelregelexpertenmodus und Komponentenregelexpertenmodus.

391

* **Berechnung**

392

Hier sind Regelvorlagen rund um das Thema Berechnungen enthalten. Der Inhalt ändert sich je nach Expertenmodusbereich. Wird angezeigt bei Panelregelexpertenmodus und Komponentenregelexpertenmodus.

393

* **Sonstiges**

394

Hier sind Regelvorlagen rund um das Thema sonstiges enthalten. Der Inhalt ändert sich je nach Expertenmodusbereich. Wird angezeigt bei Validierungsregelexpertenmodus, Panelregelexpertenmodus und Komponentenregelexpertenmodus.

395

* **Multipanel**

396

Hier sind Regelvorlagen rund um das Thema Multipanel enthalten. Der Inhalt ändert sich je nach Expertenmodusbereich. Wird angezeigt bei Panelregelexpertenmodus und Komponentenregelexpertenmodus.

397

* **Dateiformat**

398

Hier sind Regelvorlagen rund um das Thema Dateiformatseinschränkungen enthalten. Wird angezeigt bei Validierungsregelexpertenmodus.

399

* **Regelvorschläge**

400

Dieser Bereich enthält eine Verknüpfung zu dem MACH formsolutions Support-Assistenten. Über diesen können Verbesserungsvorschläge sowie Regelvorlagenvorschläge an MACH ProForms GmbH versendet werden. Wird angezeigt bei Validierungsregelexpertenmodus, Panelregelexpertenmodus und Komponentenregelexpertenmodus.

401

402

![[Ansicht der Sidebar der Regelvorlagen im Expertenmodus|@Regelbau-Expertenregel-Regelvorlagen.jpg]]

403

404

Über einen "Linksklick" auf eine Regelvorlage kann diese in den Expertenmodus eingefügt werden. Hierbei ordnet sich die Regelvorlage bei bereits bestehenden Code an die entsprechende Stelle an. Imports werden beispspielsweise an den Anfang des bestehenden Codes hinzugefügt.

405

406

![[Ansicht einer Regelvorlage einfügen in den Expertenmodus|@Regelbau-Expertenregel-Regelvorlagen-Einfügen.jpg]]

407

408

Über einen "Rechtsklick" auf eine Regelvorlage erscheint jeweils ein Kontextmenü, mit dem eine Beschreibung der Regelvorlage sowie eine Vorschau des Codes angezeigt werden kann.

409

410

![[Ansicht der Regelbeschreibung und Regelvorschau der Regelvorlagen|@Regelbau-Expertenregel-Regelvorlagen-Vorschau.jpg]]

---

## Inhaltsassistenzsystem

415

416

Der Expertemodusbereich ist mit einem sogenannten Inhaltsassistenzsystem ausgestattet. Dieser dient zur Erleichterung der manuellen Eingabe eines erzeugten bzw. neu erstellten Codes mit Hilfe integrierten Bausteine in einer Vorschlagsliste mittels eines Klicks einzufügen. Weiterhin werden alle vom Benutzer definierten Bezeichnungen im Assistenten über die Vorschlagsliste angezeigt.

417

418

> {{icon name="far fa-info-circle" size="3"/}} _**Hinweis:**_

419

>

420

> Das Inhaltsassistenzsystem führt nur neue/geänderte Panel- und Komponentenbezeichnungen auf, wenn der Assistent zuvor gespeichert wurden.

421

422

Die Vorschlagsliste des Inhaltsassistenzsystems beinhaltet Bausteine mit folgenden Kategorien:

423

424

* **snippets**

425

Snippets sind kleine einfügbare Code-Schnipsel die für den Grundaufbau einer Regel benötigt werden.

426

* **Datentyp**

427

Die verschiedenen Datentypen die dem Anwender zur Verfügung stehen.

428

* **Funktion**

429

Eine Java-Methode die zum Beispiel zum Verarbeiten von Feldinputs benötigt werden.

430

* **Regelbau**

431

Schlagwörter und Ausdrücke die in fast allen Regeln verwendet werden und zum Grundstock von Drools gehören.

432

* **Drools**

433

Spezielle Drools-Syntax

434

* **Komponente im Assistent**

435

Zeigt alle Komponenten die Assistenten verbaut sind.

436

* **Komponente aktuelles Panel**

437

Zeigt auf, dass die Komponenten im aktuellen Panel sich befindet.

438

* **Panel im Assistenten**

439

Zeigt alle Panels auf die im Assistenten verbaut sind.

440

* **dieses Panel**

441

Zeigt auf, dass das Panel im aktuellen Panel sich befindet.

442

* **Casting**

443

Umwandlung eines Datentyps in einen anderen.

444

445

![[Expertenmodus mit der Vorschlagsliste des Inhaltsassistenzsystems|@RegelbauInhaltsassistentsystem.jpg]]

446

447

### Suche und Ersetzen

448

449

Mittels der Tastenkombination `Strg + F` wird im Expertenmodus die sogenannte „Suche und Ersetzen-Funktion“ eingeblendet. Über die Felder „Search for“ können nach bestimmten Wörtern im Code gesucht und mittels dem Feld „Replace with“ ersetzt werden.

450

451

![[Expertenmodus mit Suchen und Ersetzenfunktion|@Regelbau-Expertenregel-SucheErsetzen.jpg]]

---

## Berechnungsregel

Bei den Berechnungsregeln wird die Struktur der Aktivierungsregel um weitere Importierungen erweitert bzw. der `then-Teil` wird abgeändert.

458

459

### Panelübergreifende Berechnung

460

461

Um eine Summe auf einem anderen Panel zu berechnen, ist folgende Definition relevant:

462

463

```javascript

464

apply($<VARIABLENNAME DES ERGEBNISFELD>,<VARIABLENNAME DER FUNKTION>($<VARIABLENNAME>, $<VARIABLENNAME>));

465

```

466

467

Nehmen wir beispielsweise eine einfache Berechnung bei der auf „Panel A“ die Komponenten „Komponente A“ und „Komponente B“ addiert werden sollen. Das Ergebnis soll auf einem separaten Panel „Panel B“ in die „Komponente C“ geschrieben werden.

Beispiel:

```javascript

package de.formsolutions.metaform

473

import de.formsolutions.metaform.model.*

474

import function de.formsolutions.metaform.rules.util.MathUtil.add

475

import function de.formsolutions.metaform.rules.util.MathUtil.apply

476

477

rule "Beispiel-Regel"

478

when

479

Panel(identifier == "Panel A", $Betrag1:getInputComponent("Komponente A"), $Betrag1 !=null) and

480

Panel(identifier == "Panel A", $Betrag2:getInputComponent("Komponente B"), $Betrag2 !=null) and

481

Panel(identifier == "Panel B", $Summe:getInputComponent("Komponente C"), $Summe !=null)

482

then

483

apply($Summe,add($Betrag1, $Betrag2));

end

```

![[04_1_Regelbau-Expertenregel-PanelübergreifendeBerechnung.jpg|04_1_Regelbau-Expertenregel-PanelübergreifendeBerechnung.jpg]]

488

489

### Komponenten Berechnung in einem Panel

490

491

Um eine Summe auf einem Panel zu berechnen, ist folgende Definition relevant:

492

493

```javascript

494

String oldValue=$<VARIABLENNAME>.getStringValue();

495

apply($<VARIABLENNAME DES ERGEBNISFELD>,<VARIABLENNAME DER FUNKTION>($<VARIABLENNAME>,$<VARIABLENNAME>));

496

if(!$<VARIABLENNAME DES ERGEBNISFELD>.getStringValue().equals(oldValue)) {

497

$<VARIABLENNAME DES ERGEBNISFELD>.setNeededValueHasChanged(true); }

498

```

499

500

Nehmen wir beispielsweise eine einfache Berechnung, bei der auf „Panel A“ die Komponenten „Komponente A“ und „Komponente B“ addiert werden sollen. Das Ergebnis soll auf „Panel A“ in der „Komponente C“ geschrieben werden.

Beispiel:

```javascript

package de.formsolutions.metaform

506

import de.formsolutions.metaform.model.*

507

import function de.formsolutions.metaform.rules.util.MathUtil.add

508

import function de.formsolutions.metaform.rules.util.MathUtil.apply

509

510

rule "Beispiel-Regel"

511

when

512

Component($Betrag1:searchInputComponent("Komponente A"), $Betrag1 !=null) and

513

Component($Betrag2:searchInputComponent("Komponente B"), $Betrag2 !=null) and

514

Component($Summe:searchInputComponent("Komponente C"), $Summe !=null)

515

then

516

String oldValue=$Summe.getStringValue();

517

apply($Summe,add($Betrag2, $Betrag2));

518

if(!$Summe.getStringValue().equals(oldValue)) {

519

$Summe.setNeededValueHasChanged(true);

}

end

```

### Rundungen der Dezimalzahlen

525

526

Weiterhin können Regeln so definiert werden, dass ab einer bestimmten Nachkommastelle das Ergebnis auf-/abgerundet wird.

527

528

Um eine Rundung zu definieren, ist folgende Definition relevant:

529

530

```javascript

531

apply($<VARIABLENNAME DES ERGEBNISFELD>,round(<VARIABLENAME DER FUNKTION>($<VARIABLENNAME>,$<VARIABLENNAME>),<ANZAHL DER NACHKOMMASTELLEN));

532

```

533

534

Nehmen wir beispielsweise einer einfachen Berechnung, bei der auf „Panel A“ die Komponenten „Komponente A“ und „Komponente B“ addiert werden sollen. Das Ergebnis soll auf „Panel B“ in der „Komponente C“ geschrieben werden und die zweite Nachkommastelle gerundet werden.

Beispiel:

```javascript

package de.formsolutions.metaform

540

import de.formsolutions.metaform.model.*

541

import function de.formsolutions.metaform.rules.util.MathUtil.add

542

import function de.formsolutions.metaform.rules.util.MathUtil.apply

543

import function de.formsolutions.metaform.rules.util.MathUtil.round

544

545

rule "Beispiel-Regel"

546

when

547

Panel(identifier == "Panel A", $Betrag1:getInputComponent("Komponente A"), $Betrag1 !=null) and

548

Panel(identifier == "Panel A", $Betrag2:getInputComponent("Komponente B"), $Summe !=null) and

549

Panel(identifier == "Panel B", $Summe:getInputComponent("Komponente C"), $Summe !=null)

550

then

551

apply($Summe,round(add($Betrag1,$Betrag2),2));

end

```

![[Dezimalzahl in der Komponentenkonfiguration|@Regelbau-Expertenregel-Runden.jpg]]

556

557

## Multipanelberechnung

558

559

Die Berechnung von Multipanels ist aktuell noch nicht über den grafischen Berechnungsregeleditor konfigurierbar. Standardmäßig werden im grafischen Berechnungsregeleditor die Werte aufsummiert.

560

561

Um eine Multipanel zu definieren, ist folgende Definition relevant:

562

563

```javascript

564

$<VARIABLENNAME>: MultiPanelMaster(identifier == "PANELNAME")

565

$<VARIABLENNAME>: Panel(identifier == "PANELNAME",

566

$<ALTERNATIVER_VARIABLENNAME>:getInputComponent("KOMPONENTE"))

567

then

568

BigDecimal sum = BigDecimal.ZERO;

569

java.util.List<Panel> zeilen = $multipanel.getPanelEntities();

570

for (Panel zeile: zeilen) {

571

sum = add(sum, zeile.getInputComponent("KOMPONENTENNAME"));

572

}

573

apply($summe, divide(sum, 2));

update($ergebnis);

end

```

Ein Multipanel „Panel A“ enthält die Komponente „Betrag A“. Der Betrag soll nun je, nachdem wie oft das Multipanel ausgefüllt worden ist, addiert werden. Das Ergebnis wird in das Panel „Panel B“ in der Komponente „Betrag C“ eingetragen.

Beispiel:

```javascript

package de.formsolutions.metaform

584

import de.formsolutions.metaform.model.*

585

import java.math.BigDecimal

586

import function de.formsolutions.metaform.rules.util.MathUtil.divide

587

import function de.formsolutions.metaform.rules.util.MathUtil.apply

588

import function de.formsolutions.metaform.rules.util.MathUtil.add

589

590

rule "Beispiel-Regel"

591

when

592

$Multi: MultiPanelMaster(identifier == "Panel A")

593

Panel(identifier == "Panel B", $Summebetrag:getInputComponent("Betrag C"), $Summebetrag !=null)

594

then

595

BigDecimal multi = BigDecimal.ZERO;

596

java.util.List<Panel> multiRows = $Multi.getPanelEntities();

597

for(Panel multiRow: multiRows){

598

multi = add(multi, multiRow.getInputComponent("Betrag A"));

599

}

600

apply($Summebetrag,multi);

end

```

> {{icon name="far fa-info-circle" size="3"/}} _**Hinweis:**_

605

>

606

> Es muss für das Multipanel der Name des Panelnamens in dem Code verwendet werden.

607

608

![[Panelname in der Multipanelkonfiguration|@Regelbau-Expertenregel-Multipanel.jpg]]

609

610

## Referenz der Expertenregeln im Anwenderforum

611

612

[https://forum.machproforms.de/index.php?thread/309-methoden-in-den-expertenregeln-eine-%C3%BCbersicht/](https://forum.machproforms.de/index.php?thread/309-methoden-in-den-expertenregeln-eine-%C3%BCbersicht/)

Wiki-Quellcode von Expertenmodus

Navigation