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.

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

26

27

* Basis-Paket/Importierungen & Regelnamen

28

* When-Teil

29

* Then-Teil

30

* 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.

39

40

```javascript

41

package de.formsolutions.metaform

42

import de.formsolutions.metaform.model.*

43

```

44

45

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:

50

51

Diese Importierungen müssen in folgender Form dargestellt werden.

52

53

```javascript

54

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

55

```

56

57

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

#### MathUtil

| Funktionsname | Beschreibung | Beispiel |

62

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

63

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

64

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

65

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

66

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

67

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

68

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

69

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

70

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

71

| `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:

76

77

```javascript

78

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

79

import org.joda.time.LocalDate

80

```

81

82

| Funktionsname | Beschreibung | Beispiel |

83

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

84

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

85

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

86

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

87

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

88

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

89

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

90

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

91

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

92

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

93

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

94

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

95

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

96

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

97

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

98

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

99

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

100

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

101

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

102

103

#### Sonstige Imports

104

105

Diese Importierung muss vorangestellt werden:

106

107

```javascript

108

import java.util.LinkedList;

109

import java.util.List;

110

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

111

```

112

113

| Funktionsname | Beschreibung | Beispiel |

114

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

115

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

116

117

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

118

119

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.

120

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.

127

128

```javascript

129

package de.formsolutions.metaform

130

import de.formsolutions.metaform.model.*

131

132

rule "Form-Solutions Beispiel-Regel"

when

<Bedingung(en)>

then

end

```

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

141

142

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

143

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.

156

157

Die Definition besteht aus zwei Funktionsweisen.

158

159

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

160

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)`

161

162

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

163

164

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

165

* < 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.

166

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

167

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

168

169

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

170

171

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

172

173

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

174

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

175

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

Beispiel:

```javascript

package de.formsolutions.metaform

183

import de.formsolutions.metaform.model.*

184

185

rule "Form-Solutions Beispiel-Regel"

186

when

187

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

then

end

```

### Verknüpfungen und Definitionen

194

195

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

196

197

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

198

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

199

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

200

1. ...

201

202

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

203

>

204

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

205

206

### Komponentendefinition

207

208

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.

209

210

Die Definition besteht aus zwei Funktionsweisen.

211

212

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

213

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`.

214

215

* < 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!)

216

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

217

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

218

219

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.

220

221

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

222

>

223

> 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

229

import de.formsolutions.metaform.model.*

230

231

rule "Form-Solutions Beispiel-Regel"

232

when

233

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

234

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

then

end

```

### Ermittlung eines Feldwertes

241

242

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

243

244

```javascript

245

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

246

```

247

248

**== entspricht ist gleich**

249

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

255

import de.formsolutions.metaform.model.*

256

257

rule "Form-Solutions Beispiel-Regel"

258

when

259

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

260

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

then

end

```

**!= entspricht ungleich**

267

268

```javascript

269

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

270

```

271

272

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`.

279

280

### Panelfeld mit einem Wert vor befüllen

281

282

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

283

284

```javascript

285

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

286

```

287

288

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

294

import de.formsolutions.metaform.model.*

295

296

rule "Form-Solutions Beispiel-Regel"

297

when

298

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

299

then

300

$solutions.setStringValue("beliebiger Text");

end

```

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

305

>

306

> 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!

307

308

### Komponenten mit einem neuen Wert laden

309

310

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:

311

312

```javascript

313

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

314

315

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

316

$<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

326

import de.formsolutions.metaform.model.*

327

328

rule "Form-Solutions Beispiel-Regel"

329

when

330

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

331

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

332

then

333

String oldValue=$form.getStringValue();

334

$form.setStringValue("formsolutions");

335

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

336

$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

355

import de.formsolutions.metaform.model.*

356

357

rule "Form-Solutions 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

374

import de.formsolutions.metaform.model.*

375

376

rule "Form-Solutions 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.

390

391

Folgende Rubriken beinhalten die Regelvorlage:

392

393

* **Datum**

394

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.

395

396

* **Vorbefüllung**

397

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

398

399

* **Verwendungszweck**

400

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

401

402

* **Berechnung**

403

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

404

405

* **Sonstiges**

406

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

407

408

* **Multipanel**

409

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

410

411

* **Dateiformat**

412

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

413

414

* **Regelvorschläge**

415

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

416

417

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

418

419

Ü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.

420

421

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

422

423

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

424

425

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

---

## Inhaltsassistenzsystem

430

431

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.

432

433

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

434

>

435

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

436

437

Die Vorschlagsliste des Inhaltsassistenzsystems beinhaltet Bausteine mit folgenden Kategorien:

438

439

* **snippets**

440

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

441

442

* **Datentyp**

443

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

444

445

* **Funktion**

446

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

447

448

* **Regelbau**

449

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

450

451

* **Drools**

452

Spezielle Drools-Syntax

453

454

* **Komponente im Assistent**

455

Zeigt alle Komponenten die Assistenten verbaut sind.

456

457

* **Komponente aktuelles Panel**

458

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

459

460

* **Panel im Assistenten**

461

Zeigt alle Panels auf die im Assistenten verbaut sind.

462

463

* **dieses Panel**

464

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

465

466

* **Casting**

467

Umwandlung eines Datentyps in einen anderen.

468

469

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

470

471

### Suche und Ersetzen

472

473

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.

474

475

![[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.

482

483

### Panelübergreifende Berechnung

484

485

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

486

487

```javascript

488

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

489

```

490

491

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

497

import de.formsolutions.metaform.model.*

498

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

499

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

500

501

rule "Form-Solutions Beispiel-Regel"

502

when

503

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

504

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

505

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

506

then

507

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

end

```

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

512

513

### Komponenten Berechnung in einem Panel

514

515

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

516

517

```javascript

518

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

519

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

520

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

521

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

522

```

523

524

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

530

import de.formsolutions.metaform.model.*

531

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

532

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

533

534

rule "Form-Solutions Beispiel-Regel"

535

when

536

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

537

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

538

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

539

then

540

String oldValue=$Summe.getStringValue();

541

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

542

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

543

$Summe.setNeededValueHasChanged(true);

}

end

```

### Rundungen der Dezimalzahlen

549

550

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

551

552

Um eine Rundung zu definieren, ist folgende Definition relevant:

553

554

```javascript

555

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

556

```

557

558

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

564

import de.formsolutions.metaform.model.*

565

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

566

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

567

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

568

569

rule "Form-Solutions Beispiel-Regel"

570

when

571

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

572

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

573

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

574

then

575

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

end

```

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

580

581

## Multipanelberechnung

582

583

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

584

585

Um eine Multipanel zu definieren, ist folgende Definition relevant:

586

587

```javascript

588

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

589

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

590

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

591

then

592

BigDecimal sum = BigDecimal.ZERO;

593

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

594

for (Panel zeile: zeilen) {

595

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

596

}

597

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

608

import de.formsolutions.metaform.model.*

609

import java.math.BigDecimal