Bump version

Change description and arguments depending on selected features
Merge pull request #23 from CCC-MF/issue_22
2023-11-10 17:12:56 +01:00 · 2023-11-10 16:41:54 +01:00 · 2023-11-10 12:38:39 +01:00 · 2023-11-10 12:36:53 +01:00 · 2023-11-10 12:36:04 +01:00 · 2023-11-09 13:15:18 +01:00
28 changed files with 3549 additions and 157 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,5 @@
 .idea/*
 /target
+/completion

 *.iml
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,15 +1,37 @@
 [package]
 name = "osc-variant"
-version = "0.1.0"
+version = "0.7.0"
 edition = "2021"
+authors = ["Paul-Christian Volkmer <volkmer_p@ukw.de>"]
+description = "Anwendung zum Anpassen einer OSC-Datei an einen Standort"
+license = "MIT"
+readme = "README.md"
+
+build = "build.rs"
+
+[workspace]
+members = ["libs/deob"]

 [dependencies]
-clap = { version = "4.3", features = ["std", "help", "usage", "derive", "error-context" ], default-features = false }
+clap = { version = "4.4", features = ["std", "help", "usage", "derive", "error-context"], default-features = false }
 serde = { version = "1.0", features = ["derive"] }
 serde_yaml = "0.9"
-quick-xml = { version = "0.28", features = ["escape-html", "serialize"], default-features=false }
-xml-rs = "0.8"
+quick-xml = { version = "0.31", features = ["escape-html", "serialize"], default-features = false }
 console = "0.15"
+sha256 = "1.4"
+dialoguer = "0.11"
+indicatif = "0.17"
+
+deob = { path = "./libs/deob", optional = true }
+zip = { version = "0.6", optional = true }
+
+[features]
+# Requires env var OSB_KEY to be present at build time
+unzip-osb = ["dep:deob", "dep:zip"]
+
+[build-dependencies]
+clap = { version = "4.4", features = ["std", "help", "usage", "derive", "error-context"], default-features = false }
+clap_complete = "4.4"

 [profile.release]
 opt-level = "s"
@@ -17,3 +39,17 @@ codegen-units = 1
 lto = "thin"
 strip = true
 panic = "abort"
+
+[package.metadata.deb]
+copyright = "Copyright (c) 2023 Comprehensive Cancer Center Mainfranken"
+extended-description = "Anwendung zum Anpassen einer OSC-Datei an einen Standort."
+assets = [
+    ["target/release/osc-variant", "usr/bin/", "755"],
+    ["completion/osc-variant.bash", "etc/bash_completion.d/", "644"]
+]
+
+[package.metadata.generate-rpm]
+assets = [
+    { source = "target/release/osc-variant", dest = "/usr/bin/", mode = "755" },
+    { source = "completion/osc-variant.bash", dest = "/etc/bash_completion.d/", mode = "644" }
+]
--- a/12
+++ b/12
@@ -32,15 +32,19 @@ binary-all: win-binary-x86_64 linux-binary-x86_64

 .PHONY: win-binary-x86_64
 win-binary-x86_64:
-	cargo build --release --target=x86_64-pc-windows-gnu
+	cargo build --release --target=x86_64-pc-windows-gnu --features unzip-osb

 .PHONY: linux-binary-x86_64
 linux-binary-x86_64:
-	cargo build --release --target=x86_64-unknown-linux-gnu
+	cargo build --release --target=x86_64-unknown-linux-gnu --features unzip-osb

-.PHONE: clean
+.PHONY: install
+install:
+	cargo install --path .
+
+.PHONY: clean
 clean:
 	cargo clean
 	rm -rf osc-variant 2>/dev/null || true
 	rm *_win64.zip 2>/dev/null || true
-	rm *_linux.tar.gz 2>/dev/null || true
+	rm *_linux.tar.gz 2>/dev/null || true
--- a/README.md
+++ b/README.md
@@ -16,12 +16,67 @@ unvollständigen Ausgabedateien zu erzeugen.

 ### Beispiele

+Die folgenden Unterbefehle sind verfügbar
+
+#### Unterbefehl `sha256sum`
+
+Das Berechnen der SHA256 Prüfsumme ist mit dem Unterbefehl `sha256sum` auch unter Windows einfach möglich
+und erzeugt eine Ausgabe analog dem Befehl auf Linux-Systemen:
+
+```
+osc-variant sha256sum meine-beispieldatei.osc
+```
+
+#### Unterbefehl `list`
+
 Zum Auflisten der Inhalte einer Datei wird folgender Befehl verwendet:

 ```
 osc-variant list meine-beispieldatei.osc
 ```

+Mit der Option `--filter` kann die Ausgabe eingeschränkt werden. 
+
+#### Unterbefehl `tree`
+
+Zum Auflisten der Inhalte mit allen Abhängigkeiten, z.B. Daten- und Merkmalskataloge und bei Formularen wird der Befehl
+`tree` verwendet:
+
+```
+osc-variant tree meine-beispieldatei.osc
+```
+
+Abhängigkeiten werden je nach Art gekennzeichnet:
+
+* `+`: Datenkatalog
+* `-`: Merkmalskatalog
+* `>`: Formularverweis
+* `*`: Unterformular
+
+Für Formularverweise und Unterformulare werden dabei die verwendeten Datenkataloge nicht erneut ausgegeben.
+
+Achtung! Dies erzeugt eine sehr umfangreiche Ausgabe.
+
+Mit der Option `--filter` kann auch hier die Ausgabe eingeschränkt werden.
+
+#### Unterbefehl `diff`
+
+Zum Vergleich zweier OSC-Dateien wird der Unterbefehl `diff` verwendet.
+Der optionale Parameter `--strict` vergleicht auch den Inhalt der OSC-Datei.
+Ohne diesen wird nur das Vorhandensein von Inhalten und die Revision verglichen. 
+
+```
+osc-variant diff meine-beispieldatei.osc andere-beispieldatei.osc
+```
+
+bzw.
+
+```
+osc-variant diff meine-beispieldatei.osc andere-beispieldatei.osc --strict
+```
+
+#### Unterbefehl `modify`
+
 Zum Anpassen des Inhalts einer Datei:

 ```
@@ -29,21 +84,71 @@ osc-variant modify meine-beispieldatei.osc --profile ukw-profil.yml --output ukw
 ```

 Die Parameter `--profile` und `--output` sind optional.
+Mit dem ebenfalls optionalen Parameter `--interactve` oder `-i` können die Parameter zur kompakten Ausgabe, zum Sortieren
+und dem Entfernen von Inhalten der Systembibliothek interaktiv gesetzt werden.

 Ohne Profildatei wird die Datei lediglich eingelesen, Leerzeichen am Ende eines XML-Tags entfernt und wieder ausgegeben.

 Ohne eine Angabe der Ausgabedatei wird auf die Standardausgabe ausgegeben.

+##### Enthaltene Profile
+
+Die im Ordner [`examples/`](/examples) enthaltenen Profile für Standorte sind in der ausführbaren Anwendung enthalten 
+und die Dateien müssen nicht explizit als Datei vorliegen:
+
+* `--profile examples/dnpm-ukm.yml` => `--profile UKM`
+* `--profile examples/dnpm-ukw.yml` => `--profile UKW`
+* `--profile examples/dnpm-umg.yml` => `--profile UMG`
+
+#### Unterbefehl `unzip-osb`
+
+Ab Version 0.6.0 ist die Anwendung zudem in der Lage, die für eine Aktualisierung der OS-Bibliothek genutzten OSB-Dateien zu entpacken:
+
+```
+osc-variant unzip-osb OSBIB-6.10.osb
+```
+
+Dieser Befehl kennt die beiden optionalen Parameter
+
+* `-d`: Optionale Angabe des Zielverzeichnisses. Wenn keine Angabe vorhanden ist, wird das aktuelle Verzeichnis verwendet.
+* `-p`/`--password`: Optionale Angabe des Passworts zum Entpacken der OSB-Datei.
+
+#### Unterbefehl `check`
+
+Der Unterbefehl `check` prüft eine OSC-Datei auf bekannte Probleme und gibt eine Liste mit erkannten Problemen aus.
+
+Eine Liste mit bekannten Problemen wird mit `check --list` ausgegeben.
+
 #### Kompakte Ausgabe

 OSC-Dateien sind XML-Dateien. Diese Anwendung ermöglicht optional die Ausgabe als kompaktere XML-Datei ohne Zeilenumbrüche.
 Hierzu ist die Option `--compact` vorgesehen. Es können, je nach Datei, bis zu 30% eingespart werden.

+#### Filter
+
+Bei der Auflistung von Inhalten ist es möglich, die Anzeige für die Unterbefehle `list` und `tree` anhand des Namens zu filtern.
+Hierzu ist die Option `--filter=` vorgesehen.
+Wird diese angewendet, werden nur Inhalte angezeigt, deren Name die angegebene Zeichenkette beinhalten.
+
 #### Sortierung

 Bei der Auflistung der Inhalte, kann die Option `--sorted` dazu verwendet werden, die angezeigten Einträge alphabetisch zu sortieren.
 Die Sortierung erfolgt dabei nach Namen des Katalogs oder des Formulars.

+Beim Modifizieren der Inhalte kann ebenfalls die Option `--sorted` dazu verwendet werden, die Einträge im Anschluss an die Modifikation
+nach Namen und für Formulare der Abhängigkeit von Formularverweisen und Unterformularen zu sortieren.
+
+Formulare, die von anderen Formularen in einem Formularverweis oder als Unterformular verwendet werden, werden dabei weiter oben angeordnet,
+da Onkostar einen Formularimport sequenziell, ohne Berücksichtigung von Abhängigkeiten, durchführt.
+
+Dies erlaubt eine konsistente Reihenfolge der Einträge, wodurch ein direkter Vergleich mit Vorversionen ermöglicht wird.
+
+##### Entfernen von Inhalten der Systembibliothek bei Modifikation
+
+Mit der die experimentelle Option `--strip` ist es möglich, die in der OSC-Datei enthaltenen und beim Import nicht genutzten Inhalte aus der Systembibliothek zu entfernen.
+
+Hierbei werden alle Inhalte entfernt, die im Ordner "ONKOSTAR Bibliothek" enthalten sind, beim Import jedoch ignoriert werden.
+
 ## Profile

 Zum Erstellen von Varianten einer OSC-Datei wird eine Profildatei im YAML-Format verwendet.
@@ -53,6 +158,9 @@ In ihr sind die durchzuführenden Änderungen definiert. Eine Profildatei hat di
 ```
 forms:
  - name: "ExampleForm"
+    form_field:
+      - name: "formularfeld"
+        hide: true
    form_references:
      - name: "ref_first_mtb"
        referenced_data_form: "Formularverweis.Variante"
@@ -79,6 +187,12 @@ und dabei die vorhandenen Angaben für den Formularverweis zu ersetzen.
 Die Angaben für `referenced_data_form`, `anzeige_auswahl`, `anzeige` und `scripts_code` sind optional.
 Wird keine Angabe gemacht, wird der bestehende Wert beibehalten.

+Zudem wird im Formular "ExampleForm" das Formularfeld "formularfeld" ausgeblendet, indem der Filter auf "false" gesetzt wird.
+Dadurch wird das Formularfeld nie angezeigt.
+Ein zuvor bestehender Filter wird ersetzt.
+Weiterhin wird die Eigenschaft "Speichern" des Formularfelds auf "Immer speichern" gesetzt um sicherzustellen, dass zuvor
+enthaltene Daten weiterhin gespeichert bleiben und werden, auch wenn das Formularfeld nicht sichtbar ist.
+
 **Achtung!** Diese Anwendung überprüft keine Scripts und verwendet angegebene Scripts als "valid" im resultierenden OSC-File.

 Zudem kann die Menükategorie angepasst werden.
@@ -88,4 +202,4 @@ Wird sie angeben, sind die Felder `name`, `position` und `column` verpflichtend.
 Es können beliebig viele Formulare mit beliebig vielen Änderungen zu Formularverweisen in einer Profildatei
 hinterlegt werden, jedoch ist mindestens eine Angabe zu einem Formularfeld erforderlich.

-Beispiele für eine Profildatei sind unter [`examples/`](examples/) zu finden.
+Beispiele für eine Profildatei sind unter [`examples/`](/examples) zu finden.
--- a/build.rs
+++ b/build.rs
@@ -0,0 +1,44 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2023 Comprehensive Cancer Center Mainfranken
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+use std::fs;
+use std::io::Error;
+
+use clap_complete::generate_to;
+use clap_complete::Shell::Bash;
+
+include!("src/cli.rs");
+
+fn main() -> Result<(), Error> {
+    let mut cmd = build_cli();
+
+    let package_name = std::env::var("CARGO_CRATE_NAME").unwrap_or("osc-variant".to_string());
+
+    fs::remove_dir_all("completion").unwrap_or_default();
+    fs::create_dir("completion")?;
+
+    generate_to(Bash, &mut cmd, package_name.as_str(), "completion")?;
+
+    Ok(())
+}
--- a/examples/dnpm-master.yml
+++ b/examples/dnpm-master.yml
@@ -0,0 +1,27 @@
+forms:
+  - name: 'DNPM Klinik/Anamnese'
+    form_references:
+      - name: MTB
+        referenced_data_form: 'OS.Tumorkonferenz'
+        anzeige_auswahl: 'MTB vom {Datum}'
+  - name: 'DNPM Therapieplan'
+    form_references:
+      - name: referstemtb
+        referenced_data_form: 'OS.Tumorkonferenz'
+        anzeige_auswahl: 'MTB vom {Datum}'
+      - name: reftkhumangenber
+        referenced_data_form: 'OS.Tumorkonferenz'
+        anzeige_auswahl: 'MTB vom {Datum}'
+      - name: reftkreevaluation
+        referenced_data_form: 'OS.Tumorkonferenz'
+        anzeige_auswahl: 'MTB vom {Datum}'
+  - name: 'DNPM UF Einzelempfehlung'
+    form_references:
+      - name: mtb
+        referenced_data_form: 'OS.Tumorkonferenz'
+        anzeige_auswahl: 'MTB vom {Datum}'
+  - name: 'DNPM UF Rebiopsie'
+    form_references:
+      - name: reftumorkonferenz
+        referenced_data_form: 'OS.Tumorkonferenz'
+        anzeige_auswahl: 'MTB vom {Datum}'
--- a/examples/dnpm-ukm.yml
+++ b/examples/dnpm-ukm.yml
@@ -3,4 +3,29 @@ forms:
    form_references:
      - name: MTB
        referenced_data_form: 'MR.MTB_Anmeldung'
-        anzeige_auswahl: 'MTB Anmeldung vom {Anmeldedatum}'
+        anzeige_auswahl: 'MTB Anmeldung vom {Anmeldedatum}'
+        scripts_code: |
+          setFieldValue('AnmeldedatumMTB', getFieldValue('MTB').MTBTermin);
+          setFieldValue('WHOGrad', getFieldValue('MTB').WHOGrad);
+          setFieldValue('Leitlinienstatus', getFieldValue('MTB').Leitlinienstatus);
+  - name: 'DNPM Therapieplan'
+    form_references:
+      - name: referstemtb
+        referenced_data_form: 'MR.MTB_Empfehlung'
+        anzeige_auswahl: 'MTB vom {Datum}'
+      - name: reftkhumangenber
+        referenced_data_form: 'MR.MTB_Empfehlung'
+        anzeige_auswahl: 'MTB vom {Datum}'
+      - name: reftkreevaluation
+        referenced_data_form: 'MR.MTB_Empfehlung'
+        anzeige_auswahl: 'MTB vom {Datum}'
+  - name: 'DNPM UF Einzelempfehlung'
+    form_references:
+      - name: mtb
+        referenced_data_form: 'MR.MTB_Empfehlung'
+        anzeige_auswahl: 'MTB vom {Datum}'
+  - name: 'DNPM UF Rebiopsie'
+    form_references:
+      - name: reftumorkonferenz
+        referenced_data_form: 'MR.MTB_Empfehlung'
+        anzeige_auswahl: 'MTB vom {Datum}'
--- a/libs/deob/Cargo.toml
+++ b/libs/deob/Cargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "deob"
+version = "0.1.0"
+edition = "2021"
+
+[build-dependencies]
+cc = "1.0"
--- a/libs/deob/build.rs
+++ b/libs/deob/build.rs
@@ -0,0 +1,32 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2023 Comprehensive Cancer Center Mainfranken
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+use std::io::Error;
+
+fn main() -> Result<(), Error> {
+    cc::Build::new().file("src/deob.c").compile("deob");
+    println!("cargo:rerun-if-changed=src/deob.c");
+    println!("cargo:rerun-if-changed=src/deob.h");
+    Ok(())
+}
--- a/libs/deob/src/deob.c
+++ b/libs/deob/src/deob.c
@@ -0,0 +1,37 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2023 Comprehensive Cancer Center Mainfranken
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include "deob.h"
+
+void deob(char * in) {
+    const long long s[2] = { S0, S1 };
+    char d[] = "OSTAR.password$OSB";
+    for (size_t i = 0; i < DL; i++) d[i] = (CS)[i];
+    size_t l = strlen(in) / 2;
+    for (size_t i = 0; i < l; i++) {
+        for (size_t j = 0; j < DL; j++) { DLT(0); DLT(1); }
+        DLS(i);
+    }
+    INZ(l);
+}
--- a/libs/deob/src/deob.h
+++ b/libs/deob/src/deob.h
@@ -0,0 +1,43 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2023 Comprehensive Cancer Center Mainfranken
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef OSC_VARIANT_DEOB_H
+#define OSC_VARIANT_DEOB_H
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#define S0 8373972096940928081
+#define S1 7378413942531504450
+#define CS (char*)&s
+#define DL sizeof(d) / sizeof(d[0]) - 2
+#define I2 i*2
+#define INZ(var) in[var] = 0
+#define DLS(idx) in[idx] = (d[DL+1]<<4)|d[DL]
+#define DLT(idx) d[DL+idx] = (in[I2+idx] == d[j]) ? (char)j : d[DL+idx]
+
+void deob(char * in);
+
+#endif //OSC_VARIANT_DEOB_H
--- a/libs/deob/src/lib.rs
+++ b/libs/deob/src/lib.rs
@@ -0,0 +1,38 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2023 Comprehensive Cancer Center Mainfranken
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+use std::ffi::{c_char, CStr, CString};
+
+#[link(name = "deob")]
+extern "C" {
+    fn deob(key: *const c_char);
+}
+
+pub fn deobfuscate(s: &str) -> String {
+    let key = CString::new(s).unwrap_or_default().into_raw();
+    unsafe {
+        deob(key);
+        String::from_utf8_lossy(CStr::from_ptr(key).to_bytes()).to_string()
+    }
+}
--- a/osc-variant.wxs
+++ b/osc-variant.wxs
@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Wix xmlns="http://schemas.microsoft.com/wix/2006/wi">
+  <Product Id="*"
+           Language="1033"
+           Manufacturer="CCC Mainfranken"
+           Name="OSC-Variant"
+           UpgradeCode="{83088581-5db3-49a2-8932-27da356818c7}"
+           Version="0.6.0">
+
+    <Package InstallScope="perMachine" Compressed="yes" />
+
+    <MediaTemplate EmbedCab="yes" />
+
+    <Directory Id="TARGETDIR" Name="SourceDir">
+      <Directory Id="ProgramFiles64Folder">
+        <Directory Id="INSTALLFOLDER" Name="osc-variant">
+          <Component Id="MainExecutable" Guid="*">
+            <File Id="OscVariantExe" Name="osc-variant.exe" KeyPath="yes" Source="target/x86_64-pc-windows-gnu/release/osc-variant.exe" />
+            <File Id="LicenseTxt" Name="LICENSE.txt" Source="LICENSE.txt" />
+          </Component>
+        </Directory>
+      </Directory>
+    </Directory>
+    
+    <Feature Id="Complete">
+      <ComponentRef Id="MainExecutable" />
+    </Feature>
+
+  </Product>
+</Wix>
--- a/src/checks/mod.rs
+++ b/src/checks/mod.rs
@@ -0,0 +1,245 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2023 Comprehensive Cancer Center Mainfranken
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+use std::fmt::{Display, Formatter};
+use std::path::Path;
+
+use console::style;
+
+#[cfg(feature = "unzip-osb")]
+pub mod osb;
+pub mod osc;
+
+#[allow(dead_code)]
+pub enum CheckNotice {
+    /// This will result in Error if importing file and has a support code
+    ErrorWithCode {
+        code: String,
+        description: String,
+        line: Option<usize>,
+        example: Option<String>,
+    },
+    /// This will result in Error if importing file
+    Error {
+        description: String,
+        line: Option<usize>,
+    },
+    /// Other known issues
+    Warning {
+        description: String,
+        line: Option<usize>,
+    },
+    /// Other known issues
+    Info {
+        description: String,
+        line: Option<usize>,
+    },
+    /// Ok
+    Ok(String),
+}
+
+impl Display for CheckNotice {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            CheckNotice::ErrorWithCode {
+                code,
+                description,
+                line,
+                example,
+            } => match line {
+                Some(line) => write!(
+                    f,
+                    "{: <7} ({}) at Line {}: {}{}",
+                    style("ERROR").red().bold(),
+                    code,
+                    line,
+                    description,
+                    match example {
+                        Some(example) => format!("\n        🔥 '{}'", style(example).dim()),
+                        _ => String::new(),
+                    }
+                ),
+                None => write!(
+                    f,
+                    "{: <7} ({}): {}{}",
+                    style("ERROR").red().bold(),
+                    code,
+                    description,
+                    match example {
+                        Some(example) => format!("\n        🔥 '{}'", style(example).dim()),
+                        _ => String::new(),
+                    }
+                ),
+            },
+            CheckNotice::Error { description, line } => match line {
+                Some(line) => write!(
+                    f,
+                    "{: <7} at Line {}: {}",
+                    style("ERROR").red().bold(),
+                    line,
+                    description
+                ),
+                None => write!(f, "{: <7} {}", style("ERROR").red().bold(), description),
+            },
+            CheckNotice::Warning { description, line } => match line {
+                Some(line) => write!(
+                    f,
+                    "{: <7} at Line {}: {}",
+                    style("WARNING").yellow().bold(),
+                    line,
+                    description
+                ),
+                None => write!(
+                    f,
+                    "{: <7} {}",
+                    style("WARNING").yellow().bold(),
+                    description
+                ),
+            },
+            CheckNotice::Info { description, line } => match line {
+                Some(line) => write!(
+                    f,
+                    "{: <7} at Line {}: {}",
+                    style("INFO").blue().bold(),
+                    line,
+                    description
+                ),
+                None => write!(f, "{: <7} {}", style("INFO").blue().bold(), description),
+            },
+            CheckNotice::Ok(msg) => write!(f, "{: <7} {}", style("OK").green(), msg),
+        }
+    }
+}
+
+pub trait Checkable {
+    fn check(&self) -> Vec<CheckNotice>;
+}
+
+pub trait Fixable {
+    fn fix(&mut self) -> bool;
+}
+
+#[allow(unused_variables)]
+pub fn check_file(file: &Path, password: Option<String>) -> Result<Vec<CheckNotice>, CheckNotice> {
+    match file.extension() {
+        Some(ex) => match ex.to_str() {
+            #[cfg(feature = "unzip-osb")]
+            Some("osb") => match password {
+                Some(password) => osb::check_file(file, password.as_str()),
+                None => {
+                    use deob::deobfuscate;
+                    osb::check_file(file, deobfuscate(env!("OSB_KEY").trim()).as_str())
+                }
+            },
+            Some("osc") => osc::check_file(file),
+            _ => Err(CheckNotice::Error {
+                description: "Keine prüfbare Datei".to_string(),
+                line: None,
+            }),
+        },
+        _ => Err(CheckNotice::Error {
+            description: "Keine prüfbare Datei".to_string(),
+            line: None,
+        }),
+    }
+}
+
+pub fn print_checks() {
+    println!(
+        "{}",
+        style("Die folgenden Probleme sind bekannt\n")
+            .yellow()
+            .bold()
+    );
+
+    struct Problem<'a> {
+        code: &'a str,
+        name: &'a str,
+        description: &'a str,
+        fixable: bool,
+    }
+
+    impl<'a> Display for Problem<'a> {
+        fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+            write!(
+                f,
+                "{} {} {}\n\n{}",
+                style(self.code).bold(),
+                style(self.name).underlined(),
+                match self.fixable {
+                    true => style("(Behebbar)").green(),
+                    false => style("(Nicht behebbar)").red(),
+                },
+                self.description
+            )
+        }
+    }
+
+    vec![
+        Problem {
+            code: "2023-0001",
+            name: "Unterformular mit Markierung 'hat Unterformulare'",
+            description: "  Aktuell gibt es keine Unterformulare in Unterformularen, daher\n  \
+            sollte dies nicht vorkommen.\n\n  \
+            Eine mögliche Ursache ist die Speicherung eines Unterformulars als Formular.",
+            fixable: false,
+        },
+        Problem {
+            code: "2023-0002",
+            name: "Formular hat keine Angabe zum Prozedurdatum",
+            description: "  Formulare benötigen die Angabe des Prozedurdatums, anderenfalls\n  \
+            führt dies zu Problemen in Onkostar.\n\n  \
+            Unterformulare können ein Prozedurdatum haben, müssen es aber nicht.\n\n  \
+            Eine mögliche Ursache ist die Speicherung eines Formulars als Unterformular.",
+            fixable: false,
+        },
+        Problem {
+            code: "2023-0003",
+            name: "Leerzeichen am Ende der Plausibilitätsregel-Bezeichnung (OSTARSUPP-13334)",
+            description:
+                "  Treten Leerzeichen am Ende der Plausibilitätsregel-Bezeichnung auf,\n  \
+            führt dies zu Fehlern beim Import der OSC-Datei.\n\n  \
+            Das Problem wird beim Verwenden des Unterbefehls 'modify' automatisch\n  \
+            behoben und Leerzeichen entfernt. 
+            ",
+            fixable: true,
+        },
+        Problem {
+            code: "2023-0004",
+            name: "Verweis auf noch nicht definiertes Formular (OSTARSUPP-13212)",
+            description: "  Wenn ein Formular einen Verweis auf ein anderes Formular enthält,\n  \
+            das nicht vor diesem Formular in der OSC-Datei definiert ist, wird der\n  \
+            Formularverweis beim Import der OSC-Datei nicht übernommen.\n\n  \
+            Dies kann bei wechselseitiger Abhängigkeit zwischen zwei (Unter-)Formularen\n  \
+            auftreten.\n\n  \
+            In diesem Fall kann ein erneuter/zweiter Import helfen, da das Onkostar in\n  \
+            diesem Fall alle Formulare importiert hat und der Formularverweis dann \n  \
+            gespeichert werden kann. 
+            ",
+            fixable: false,
+        },
+    ]
+    .iter()
+    .for_each(|problem| println!("{}\n", problem))
+}
--- a/src/checks/osb.rs
+++ b/src/checks/osb.rs
@@ -0,0 +1,108 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2023 Comprehensive Cancer Center Mainfranken
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+use std::fs;
+use std::io::Read;
+use std::path::Path;
+
+use indicatif::ProgressBar;
+
+use crate::checks::{osc, CheckNotice};
+
+#[cfg(feature = "unzip-osb")]
+pub fn check_file(file: &Path, password: &str) -> Result<Vec<CheckNotice>, CheckNotice> {
+    let file = match fs::File::open(file) {
+        Ok(file) => file,
+        Err(err) => {
+            return Err(CheckNotice::Error {
+                description: format!("Kann Datei nicht lesen: {}", err),
+                line: None,
+            });
+        }
+    };
+
+    let mut archive = match zip::ZipArchive::new(file) {
+        Ok(file) => file,
+        Err(err) => {
+            return Err(CheckNotice::Error {
+                description: format!("Kann Datei nicht lesen: {}", err),
+                line: None,
+            });
+        }
+    };
+
+    let mut result = vec![];
+
+    let progress_bar = ProgressBar::new(archive.len() as u64);
+
+    for i in 0..archive.len() {
+        progress_bar.inc(1);
+        if let Ok(Ok(mut zip_file)) = archive.by_index_decrypt(i, password.as_bytes()) {
+            if zip_file.is_file() && zip_file.name().ends_with(".osc") {
+                let mut buf = String::new();
+                let _ = zip_file.read_to_string(&mut buf);
+                match osc::check(buf) {
+                    Ok(ref mut check_result) => {
+                        result.push(CheckNotice::Info {
+                            description: format!("Prüfe Eintrag '{}'", zip_file.name()),
+                            line: None,
+                        });
+                        if check_result.is_empty() {
+                            result.push(CheckNotice::Ok(format!(
+                                "Keine Probleme in '{}' erkannt",
+                                zip_file.name()
+                            )))
+                        }
+                        result.append(check_result)
+                    }
+                    Err(_) => result.push(CheckNotice::Warning {
+                        description: format!(
+                            "Überspringe Eintrag '{}': Inhalt kann nicht geprüft werden",
+                            zip_file.name(),
+                        ),
+                        line: None,
+                    }),
+                };
+                continue;
+            }
+            if zip_file.is_file() {
+                result.push(CheckNotice::Warning {
+                    description: format!(
+                        "Überspringe Eintrag '{}': Keine OSC-Datei",
+                        zip_file.name()
+                    ),
+                    line: None,
+                })
+            }
+        } else {
+            return Err(CheckNotice::Error {
+                description: format!("Kann Datei nicht lesen"),
+                line: None,
+            });
+        }
+    }
+    progress_bar.finish_and_clear();
+
+    Ok(result)
+}
--- a/src/checks/osc.rs
+++ b/src/checks/osc.rs
@@ -0,0 +1,78 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2023 Comprehensive Cancer Center Mainfranken
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+use std::fs;
+use std::path::Path;
+use std::str::FromStr;
+
+use crate::checks::{CheckNotice, Checkable};
+use crate::model::onkostar_editor::OnkostarEditor;
+
+pub fn check_file(file: &Path) -> Result<Vec<CheckNotice>, CheckNotice> {
+    match fs::read_to_string(file) {
+        Ok(content) => check(content),
+        _ => Err(CheckNotice::Error {
+            description: "Kann Datei nicht lesen".to_string(),
+            line: None,
+        }),
+    }
+}
+
+pub fn check(content: String) -> Result<Vec<CheckNotice>, CheckNotice> {
+    let mut result = content
+        .lines()
+        .enumerate()
+        .flat_map(|(line, content)| check_line(line, content.to_string()))
+        .collect::<Vec<_>>();
+
+    let inner_checks = &mut match OnkostarEditor::from_str(content.as_str()) {
+        Ok(data) => data.check(),
+        Err(err) => {
+            return Err(CheckNotice::Error {
+                description: format!("Interner Fehler: {}", err),
+                line: None,
+            })
+        }
+    };
+    result.append(inner_checks);
+
+    Ok(result)
+}
+
+fn check_line(line: usize, content: String) -> Vec<CheckNotice> {
+    let mut result = vec![];
+
+    if content.contains(" </Bezeichnung>") {
+        result.append(&mut vec![CheckNotice::ErrorWithCode {
+            code: "2023-0003".to_string(),
+            description:
+                "Leerzeichen am Ende der Plausibilitätsregel-Bezeichnung (OSTARSUPP-13334)"
+                    .to_string(),
+            line: Some(line),
+            example: Some(content.trim().to_string()),
+        }])
+    }
+
+    result
+}
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -22,18 +22,28 @@
 * SOFTWARE.
 */

-use clap::{Parser, Subcommand};
+use clap::{Command, CommandFactory, Parser, Subcommand};
+
+#[allow(dead_code)]
+fn build_cli() -> Command {
+    Cli::command()
+}

 #[derive(Parser)]
 #[command(author, version, about, long_about = None)]
 #[command(propagate_version = true, arg_required_else_help(true))]
 pub struct Cli {
    #[command(subcommand)]
-    pub command: Command,
+    pub cmd: SubCommand,
 }

 #[derive(Subcommand)]
-pub enum Command {
+pub enum SubCommand {
+    #[command(
+        name = "sha256sum",
+        about = "Berechne SHA256 Prüfsumme für die angegebene Datei"
+    )]
+    Sha256Sum { inputfile: String },
    #[command(about = "Zeigt alle enthaltenen Kataloge und Formulare mit Revision an.")]
    List {
        inputfile: String,
@@ -42,6 +52,19 @@ pub enum Command {
            help = "Sortiere Kataloge und Formulare nach Name (Optional)"
        )]
        sorted: bool,
+        #[arg(long = "filter", help = "Filtere Ausgabe nach Name (Optional)")]
+        filter: Option<String>,
+    },
+    #[command(about = "Zeigt Kataloge und Formulare mit Revision und Abhängigkeiten an.")]
+    Tree {
+        inputfile: String,
+        #[arg(
+            long = "sorted",
+            help = "Sortiere Kataloge und Formulare nach Name (Optional)"
+        )]
+        sorted: bool,
+        #[arg(long = "filter", help = "Filtere Ausgabe nach Name (Optional)")]
+        filter: Option<String>,
    },
    #[command(about = "Modifiziert die angegebene Datei anhand der Profildatei")]
    Modify {
@@ -52,5 +75,67 @@ pub enum Command {
        outputfile: Option<String>,
        #[arg(long = "compact", help = "Kompakte Ausgabe, ohne Einrücken (Optional)")]
        compact: bool,
+        #[arg(
+            long = "sorted",
+            alias = "x-sorted",
+            help = "Sortiere Kataloge und Formulare nach Name und Abhängigkeiten (Optional)."
+        )]
+        sorted: bool,
+        #[arg(
+            long = "strip",
+            alias = "x-strip",
+            help = "Entferne Einträge aus der Systembibliothek die nicht importiert werden (Optional)."
+        )]
+        strip: bool,
+        #[arg(
+            short = 'i',
+            long = "interactive",
+            help = "Starte interaktiven Dialog zum Modifizieren von OSC-Dateien"
+        )]
+        interactive: bool,
+        #[arg(
+            long = "fix",
+            help = "Erweiterte Problembehandlung und Reparatur der OSC-Datei"
+        )]
+        fix: bool,
+    },
+    #[command(about = "Vergleiche zwei Dateien anhand der Revision der enthaltenen Inhalte")]
+    Diff {
+        inputfile_a: String,
+        inputfile_b: String,
+        #[arg(long = "strict", help = "Strikter Vergleich des Inhalts")]
+        strict: bool,
+    },
+    #[command(about = if cfg!(feature = "unzip-osb") { "Prüfe eine OSB- oder OSC-Datei auf bekannte Problemen" } else { "Prüfe eine OSC-Datei auf bekannte Problemen" })]
+    Check {
+        #[arg(help = "Die zu prüfende Datei", group = "check-file", required = true)]
+        file: Option<String>,
+        #[arg(
+            short = 'p',
+            long = "password",
+            help = "Passwort der OSB-Datei (Optional - für OSB-Dateien)",
+            requires = "check-file",
+            hide = !cfg!(feature = "unzip-osb")
+        )]
+        password: Option<String>,
+        #[arg(
+            long = "list",
+            help = "Prüfe nicht und zeige Liste mit Checks auf bekannte Problemen",
+            conflicts_with = "check-file"
+        )]
+        list: bool,
+    },
+    #[cfg(feature = "unzip-osb")]
+    #[command(about = "Entpackt eine OSB-Datei")]
+    UnzipOsb {
+        file: String,
+        #[arg(
+            short = 'p',
+            long = "password",
+            help = "Passwort der OSB-Datei (Optional)"
+        )]
+        password: Option<String>,
+        #[arg(short = 'd', help = "Zielverzeichnis (Optional)")]
+        dir: Option<String>,
    },
 }
--- a/src/main.rs
+++ b/src/main.rs
@@ -28,19 +28,27 @@ use std::fs;
 use std::fs::OpenOptions;
 use std::io::Write;
 use std::ops::Add;
+use std::path::{Path, PathBuf};
 use std::str::FromStr;

+use crate::checks::{check_file, print_checks, CheckNotice};
 use clap::Parser;
+use console::style;
+use dialoguer::Confirm;
 use quick_xml::se::Serializer;
 use serde::Serialize;
+use sha256::digest;

-use crate::cli::{Cli, Command};
+use crate::cli::{Cli, SubCommand};
 use crate::model::onkostar_editor::OnkostarEditor;
 use crate::profile::Profile;

+mod checks;
 mod cli;
 mod model;
 mod profile;
+#[cfg(feature = "unzip-osb")]
+mod unzip_osb;

 enum FileError {
    Reading(String, String),
@@ -108,29 +116,99 @@ fn read_profile(filename: String) -> Result<Profile, FileError> {
 fn main() -> Result<(), Box<dyn Error>> {
    let cli = Cli::parse();

-    match cli.command {
-        Command::List { inputfile, sorted } => {
+    match cli.cmd {
+        SubCommand::List {
+            inputfile,
+            sorted,
+            filter,
+        } => {
            let mut data = read_inputfile(inputfile)?;
            if sorted {
                data.sorted()
            }
+            if let Some(name) = filter {
+                OnkostarEditor::print_list_filtered(&mut data, name.as_str());
+                return Ok(());
+            }
            data.print_list();
        }
-        Command::Modify {
+        SubCommand::Tree {
+            inputfile,
+            sorted,
+            filter,
+        } => {
+            let mut data = read_inputfile(inputfile)?;
+            if sorted {
+                data.sorted()
+            }
+            if let Some(name) = filter {
+                OnkostarEditor::print_tree_filtered(&mut data, name.as_str());
+                return Ok(());
+            }
+            OnkostarEditor::print_tree(&data);
+        }
+        SubCommand::Modify {
            inputfile,
            profile,
            outputfile,
            compact,
+            sorted,
+            strip,
+            interactive,
+            fix,
        } => {
            let data = &mut read_inputfile(inputfile)?;

            if let Some(profile) = profile {
-                let profile = read_profile(profile.clone()).map_err(|_| {
-                    FileError::Reading(profile, "Kann Profildatei nicht lesen!".into())
-                })?;
+                let profile = if profile.contains(".") {
+                    read_profile(profile.clone()).map_err(|_| {
+                        FileError::Reading(profile, "Kann Profildatei nicht lesen!".into())
+                    })?
+                } else {
+                    Profile::embedded_profile(profile.as_str())?
+                };
+
                data.apply_profile(&profile);
            }

+            let mut compact = compact;
+            let mut sorted = sorted;
+            let mut strip = strip;
+
+            if interactive {
+                compact = Confirm::new()
+                    .with_prompt("Kompakte Ausgabe, ohne Einrücken?")
+                    .default(compact)
+                    .interact()
+                    .unwrap();
+
+                sorted = Confirm::new()
+                    .with_prompt("Sortiere Kataloge und Formulare nach Name und Abhängigkeiten?")
+                    .default(sorted)
+                    .interact()
+                    .unwrap();
+
+                strip = Confirm::new()
+                    .with_prompt(
+                        "Entferne Einträge aus der Systembibliothek die nicht importiert werden?",
+                    )
+                    .default(strip)
+                    .interact()
+                    .unwrap();
+            }
+
+            if fix {
+                // No operation as of now
+            }
+
+            if sorted {
+                data.sorted();
+            }
+
+            if strip {
+                data.strip_system_library_content();
+            }
+
            let mut buf = String::new();

            let mut serializer = Serializer::new(&mut buf);
@@ -157,6 +235,87 @@ fn main() -> Result<(), Box<dyn Error>> {
                }
            }
        }
+        SubCommand::Diff {
+            inputfile_a,
+            inputfile_b,
+            strict,
+        } => {
+            println!(
+                "Vergleiche Datei A ({}) mit Datei B ({})",
+                style(&inputfile_a).yellow(),
+                style(&inputfile_b).yellow()
+            );
+
+            let data_a = &mut read_inputfile(inputfile_a)?;
+            let data_b = &mut read_inputfile(inputfile_b)?;
+
+            data_a.print_diff(data_b, strict);
+        }
+        SubCommand::Sha256Sum { inputfile } => {
+            match fs::read_to_string(inputfile.clone()) {
+                Ok(content) => {
+                    println!(
+                        "{}  {}",
+                        digest(content).as_str(),
+                        PathBuf::from(inputfile.clone())
+                            .canonicalize()
+                            .unwrap_or_default()
+                            .to_str()
+                            .unwrap_or_default()
+                    )
+                }
+                Err(err) => {
+                    eprintln!("{}", FileError::Reading(inputfile, err.to_string()));
+                }
+            };
+        }
+        SubCommand::Check {
+            file,
+            list,
+            password,
+        } => {
+            if list {
+                print_checks();
+            } else {
+                match check_file(Path::new(file.unwrap_or_default().as_str()), password) {
+                    Ok(notices) => {
+                        println!(
+                            "Es wurden {} Probleme gefunden\n",
+                            notices
+                                .iter()
+                                .filter(|notice| match notice {
+                                    CheckNotice::ErrorWithCode { .. }
+                                    | CheckNotice::Error { .. } => true,
+                                    _ => false,
+                                })
+                                .count()
+                        );
+                        notices
+                            .iter()
+                            .for_each(|check_notice| println!("{}", check_notice));
+                    }
+                    Err(err) => {
+                        println!("{}", err)
+                    }
+                }
+            }
+        }
+        #[cfg(feature = "unzip-osb")]
+        SubCommand::UnzipOsb {
+            file,
+            password,
+            dir,
+        } => {
+            use crate::unzip_osb::{unzip_osb, unzip_osb_using_password};
+            match password {
+                Some(password) => unzip_osb_using_password(
+                    file.as_str(),
+                    dir.unwrap_or_default().as_str(),
+                    password.as_str(),
+                ),
+                None => unzip_osb(file.as_str(), dir.unwrap_or_default().as_str()),
+            }
+        }
    };

    Ok(())
--- a/src/model/data_catalogue.rs
+++ b/src/model/data_catalogue.rs
@@ -22,10 +22,14 @@
 * SOFTWARE.
 */

+use std::collections::HashSet;
+
 use console::style;
 use serde::{Deserialize, Serialize};

-use crate::model::{Listable, Ordner, Sortable};
+use crate::model::onkostar_editor::OnkostarEditor;
+use crate::model::requirements::{Requirement, Requires};
+use crate::model::{Ansichten, Comparable, FolderContent, Listable, Ordner, Sortable};

 #[derive(Serialize, Deserialize, Debug)]
 #[serde(deny_unknown_fields)]
@@ -54,12 +58,19 @@ pub struct DataCatalogue {
    entries: Entries,
    #[serde(rename = "Ordner")]
    ordner: Ordner,
+    #[serde(rename = "Ansichten", default)]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    ansichten: Option<Ansichten>,
 }

 impl Listable for DataCatalogue {
    fn to_listed_string(&self) -> String {
        format!(
-            "Datenkatalog '{}' in Revision '{}'",
+            "Datenkatalog ({}) '{}' in Revision '{}'",
+            match self.is_system_library_content() {
+                true => style("S").yellow(),
+                _ => style("u"),
+            },
            style(&self.name).yellow(),
            style(&self.revision).yellow()
        )
@@ -70,6 +81,78 @@ impl Sortable for DataCatalogue {
    fn sorting_key(&self) -> String {
        self.name.clone()
    }
+
+    fn sorted(&mut self) -> &Self {
+        self.entries
+            .entry
+            .sort_unstable_by_key(|item| item.sorting_key());
+        self.entries.entry.iter_mut().for_each(|item| {
+            item.sorted();
+        });
+        self
+    }
+}
+
+impl Comparable for DataCatalogue {
+    fn get_name(&self) -> String {
+        self.name.clone()
+    }
+
+    fn get_revision(&self) -> u16 {
+        self.revision
+    }
+}
+
+impl Requires for DataCatalogue {
+    fn get_required_entries<'a>(&'a self, all: &'a OnkostarEditor) -> Vec<Requirement> {
+        let mut result = self
+            .entries
+            .entry
+            .iter()
+            .filter(|&entry| entry.property_catalogue.is_some())
+            .map(|entry| match &entry.property_catalogue {
+                Some(entry) => entry.to_string(),
+                _ => String::new(),
+            })
+            .collect::<HashSet<_>>()
+            .into_iter()
+            .map(|entry| match all.find_property_catalogue(entry.as_str()) {
+                Some(contained) => Requirement::PropertyCatalogue(contained),
+                None => Requirement::ExternalPropertyCatalogue(entry),
+            })
+            .collect::<Vec<_>>();
+        result.sort_unstable_by_key(|item| item.sorting_key());
+
+        result
+    }
+
+    fn to_requirement_string<'a>(&'a self, all: &'a OnkostarEditor) -> String {
+        format!(
+            "{}\n{}",
+            self.to_listed_string(),
+            self.get_required_entries(all)
+                .iter()
+                .map(|entry| match entry {
+                    Requirement::PropertyCatalogue(_) => {
+                        Some(format!("  - {}\n", entry.to_string()))
+                    }
+                    Requirement::ExternalPropertyCatalogue(_) => {
+                        Some(format!("  - {}\n", entry.to_string()))
+                    }
+                    _ => None,
+                })
+                .filter(Option::is_some)
+                .flatten()
+                .collect::<Vec<_>>()
+                .join("")
+        )
+    }
+}
+
+impl FolderContent for DataCatalogue {
+    fn get_library_folder(&self) -> String {
+        self.ordner.bibliothek.name.to_string()
+    }
 }

 #[derive(Serialize, Deserialize, Debug)]
@@ -141,6 +224,23 @@ pub struct Entry {
    revision: u16,
 }

+impl Sortable for Entry {
+    fn sorting_key(&self) -> String {
+        self.name.clone()
+    }
+
+    fn sorted(&mut self) -> &Self
+    where
+        Self: Sized,
+    {
+        if let Some(ref mut use_) = self.use_ {
+            use_.program_module
+                .sort_unstable_by_key(|item| item.sorting_key())
+        }
+        self
+    }
+}
+
 #[derive(Serialize, Deserialize, Debug)]
 #[serde(deny_unknown_fields)]
 pub struct Use {
@@ -156,3 +256,9 @@ pub struct ProgramModule {
    #[serde(rename = "@name")]
    name: String,
 }
+
+impl Sortable for ProgramModule {
+    fn sorting_key(&self) -> String {
+        format!("{}-{}", self.program, self.name)
+    }
+}
--- a/src/model/data_form.rs
+++ b/src/model/data_form.rs
@@ -22,12 +22,20 @@
 * SOFTWARE.
 */

+use std::cmp::Ordering;
+use std::collections::HashSet;
+
 use console::style;
 use serde::{Deserialize, Serialize};

+use crate::checks::CheckNotice::ErrorWithCode;
+use crate::checks::{CheckNotice, Checkable};
+use crate::model::onkostar_editor::OnkostarEditor;
+use crate::model::requirements::{Requirement, Requires};
 use crate::model::{
-    apply_profile_to_form_entry, Ansichten, Entries, Filter, FormEntry, FormEntryContainer,
-    Listable, MenuCategory, PlausibilityRules, Script, Sortable,
+    apply_profile_to_form_entry, apply_profile_to_form_field, Ansichten, Comparable, Entries,
+    Filter, FolderContent, FormEntry, FormEntryContainer, Kennzahlen, Listable, MenuCategory,
+    PlausibilityRules, PunkteKategorien, RefEntries, Script, Sortable,
 };
 use crate::model::{Haeufigkeiten, Ordner};
 use crate::profile::Profile;
@@ -74,18 +82,26 @@ pub struct DataForm {
    #[serde(rename = "EmailTemplate")]
    #[serde(skip_serializing_if = "Option::is_none")]
    mail_template: Option<String>,
-    #[serde(rename = "ErkrankungText")]
-    erkrankung_text: String,
+    #[serde(rename = "ErkrankungText", default)]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    erkrankung_text: Option<String>,
    #[serde(rename = "ErkrankungTextLong")]
-    erkrankung_text_long: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    erkrankung_text_long: Option<String>,
    #[serde(rename = "ErkrankungProzedurText")]
-    erkrankung_prozedur_text: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    erkrankung_prozedur_text: Option<String>,
    #[serde(rename = "ErkrankungSummary")]
-    erkrankung_summary: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    erkrankung_summary: Option<String>,
    #[serde(rename = "ErkrankungBigSummary")]
-    erkrankung_big_summary: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    erkrankung_big_summary: Option<String>,
    #[serde(rename = "Kontext")]
    kontext: String,
+    #[serde(rename = "Datenart")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    datenart: Option<String>,
    #[serde(rename = "TudokReadonly")]
    tudok_readonly: bool,
    #[serde(rename = "VitalstatusRelevant")]
@@ -132,6 +148,9 @@ pub struct DataForm {
    guid: String,
    #[serde(rename = "Revision")]
    revision: u16,
+    #[serde(rename = "VerknuepftGUID")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    verknuepft_guid: Option<String>,
    #[serde(rename = "SeitenzahlSichtbar")]
    #[serde(skip_serializing_if = "Option::is_none")]
    seitenanzahl_sichtbar: Option<bool>,
@@ -142,12 +161,15 @@ pub struct DataForm {
    #[serde(rename = "Haeufigkeiten")]
    haeufigkeiten: Haeufigkeiten,
    #[serde(rename = "Kennzahlen")]
-    kennzahlen: String,
+    kennzahlen: Kennzahlen,
    #[serde(rename = "Ordner")]
    ordner: Ordner,
    #[serde(rename = "MenuCategory")]
    #[serde(skip_serializing_if = "Option::is_none")]
    menu_category: Option<MenuCategory>,
+    #[serde(rename = "PunkteKategorien")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    punkte_kategorien: Option<PunkteKategorien>,
    #[serde(rename = "Ansichten")]
    #[serde(skip_serializing_if = "Option::is_none")]
    ansichten: Option<Ansichten>,
@@ -165,6 +187,12 @@ impl FormEntryContainer for DataForm {
                            apply_profile_to_form_entry(entry, form_reference)
                        });

+                    // Hide form field using filter set to "false" if requested
+                    profile_form
+                        .form_fields
+                        .iter()
+                        .for_each(|form_field| apply_profile_to_form_field(entry, form_field));
+
                    if let Some(menu_category) = &profile_form.menu_category {
                        self.menu_category = Some(MenuCategory {
                            name: menu_category.name.clone(),
@@ -181,9 +209,25 @@ impl FormEntryContainer for DataForm {
 impl Listable for DataForm {
    fn to_listed_string(&self) -> String {
        format!(
-            "Formular '{}' in Revision '{}'",
+            "Formular ({}) '{}' in Revision '{}' {}",
+            match self.is_system_library_content() {
+                true => style("S").yellow(),
+                _ => style("u"),
+            },
            style(&self.name).yellow(),
-            style(&self.revision).yellow()
+            style(&self.revision).yellow(),
+            if self
+                .entries
+                .entry
+                .iter()
+                .filter(|entry| entry.procedure_date_status != "none")
+                .count()
+                == 0
+            {
+                style("Formular hat keine Angabe zum Prozedurdatum!").red()
+            } else {
+                style("")
+            }
        )
    }
 }
@@ -192,6 +236,177 @@ impl Sortable for DataForm {
    fn sorting_key(&self) -> String {
        self.name.clone()
    }
+
+    fn sorted(&mut self) -> &Self {
+        self.data_catalogues.data_catalogue.sort_unstable();
+
+        self.entries
+            .entry
+            .sort_unstable_by_key(|item| item.sorting_key());
+
+        self.entries.entry.iter_mut().for_each(|item| {
+            item.sorted();
+        });
+
+        if let Some(ref mut plausibility_rule) = self.plausibility_rules.plausibility_rule {
+            plausibility_rule.sort_unstable_by_key(|item| item.bezeichnung.clone());
+
+            plausibility_rule.iter_mut().for_each(|item| {
+                if let Some(ref mut data_form_entry_names) = item.data_form_entries.entry_name {
+                    data_form_entry_names.sort_unstable();
+                }
+            });
+        }
+        self
+    }
+}
+
+impl Comparable for DataForm {
+    fn get_name(&self) -> String {
+        self.name.clone()
+    }
+
+    fn get_revision(&self) -> u16 {
+        self.revision
+    }
+
+    fn compare_by_requirement(a: &Self, b: &Self) -> Ordering {
+        if a.get_name() == b.get_name()
+            || a.is_system_library_content()
+            || b.is_system_library_content()
+        {
+            return Ordering::Equal;
+        }
+
+        if a.requires_form_reference(&b.get_name()) || a.requires_subform(&b.get_name()) {
+            return Ordering::Greater;
+        }
+
+        Ordering::Less
+    }
+}
+
+impl Requires for DataForm {
+    fn requires_form_reference(&self, name: &str) -> bool {
+        self.entries
+            .entry
+            .iter()
+            .map(|item| {
+                item.type_ == "formReference"
+                    && match item.referenced_data_form.as_ref() {
+                        Some(refname) => refname == name,
+                        _ => false,
+                    }
+            })
+            .filter(|&it| it)
+            .last()
+            .unwrap_or_default()
+    }
+    fn requires_subform(&self, name: &str) -> bool {
+        self.entries
+            .entry
+            .iter()
+            .map(|item| {
+                item.type_ == "subform"
+                    && match item.referenced_data_form.as_ref() {
+                        Some(refname) => refname == name,
+                        _ => false,
+                    }
+            })
+            .filter(|&it| it)
+            .last()
+            .unwrap_or_default()
+    }
+    fn get_required_entries<'a>(&'a self, all: &'a OnkostarEditor) -> Vec<Requirement> {
+        let mut result = self
+            .data_catalogues
+            .data_catalogue
+            .iter()
+            .collect::<HashSet<_>>()
+            .into_iter()
+            .map(|entry| match all.find_data_catalogue(entry.as_str()) {
+                Some(contained) => Requirement::DataCatalogue(contained),
+                None => Requirement::ExternalDataCatalogue(entry.to_string()),
+            })
+            .collect::<Vec<_>>();
+        result.sort_unstable_by_key(|item| item.sorting_key());
+
+        let referenced_forms = &mut self
+            .entries
+            .entry
+            .iter()
+            .filter(|&entry| entry.get_type() == "formReference")
+            .filter_map(|entry| match &entry.referenced_data_form {
+                Some(name) => Some(name),
+                None => None,
+            })
+            .collect::<HashSet<_>>()
+            .into_iter()
+            .map(|entry| match all.find_data_form(entry.as_str()) {
+                Some(contained) => Requirement::DataFormReference(contained),
+                None => match all.find_unterformular(entry.as_str()) {
+                    Some(contained) => Requirement::UnterformularReference(contained),
+                    None => Requirement::ExternalUnterformularReference(entry.to_string()),
+                },
+            })
+            .collect::<Vec<_>>();
+        referenced_forms.sort_unstable_by_key(|item| item.sorting_key());
+        result.append(referenced_forms);
+
+        let sub_forms = &mut self
+            .entries
+            .entry
+            .iter()
+            .filter(|&entry| entry.get_type() == "subform")
+            .filter_map(|entry| match &entry.referenced_data_form {
+                Some(name) => Some(name),
+                None => None,
+            })
+            .collect::<HashSet<_>>()
+            .into_iter()
+            .map(|entry| match all.find_data_form(entry.as_str()) {
+                Some(contained) => Requirement::DataFormSubform(contained),
+                None => match all.find_unterformular(entry.as_str()) {
+                    Some(contained) => Requirement::UnterformularSubform(contained),
+                    None => Requirement::ExternalUnterformularSubform(entry.to_string()),
+                },
+            })
+            .collect::<Vec<_>>();
+        sub_forms.sort_unstable_by_key(|item| item.sorting_key());
+        result.append(sub_forms);
+
+        result
+    }
+}
+
+impl FolderContent for DataForm {
+    fn get_library_folder(&self) -> String {
+        self.ordner.bibliothek.name.to_string()
+    }
+}
+
+impl Checkable for DataForm {
+    fn check(&self) -> Vec<CheckNotice> {
+        if self
+            .entries
+            .entry
+            .iter()
+            .filter(|entry| entry.procedure_date_status != "none")
+            .count()
+            == 0
+        {
+            return vec![ErrorWithCode {
+                code: "2023-0002".to_string(),
+                description: format!(
+                    "Formular '{}' hat keine Angabe zum Prozedurdatum",
+                    self.name
+                ),
+                line: None,
+                example: None,
+            }];
+        }
+        vec![]
+    }
 }

 #[derive(Serialize, Deserialize, Debug)]
@@ -262,6 +477,9 @@ pub struct Entry {
    grafik_ausrichtung: Option<String>,
    #[serde(rename = "Mandatory")]
    mandatory: String,
+    #[serde(rename = "Datenart", default)]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    datenart: Option<String>,
    #[serde(rename = "Filter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    filter: Option<Filter>,
@@ -281,6 +499,9 @@ pub struct Entry {
    #[serde(rename = "AnzeigeAuswahl")]
    #[serde(skip_serializing_if = "Option::is_none")]
    anzeige_auswahl: Option<String>,
+    #[serde(rename = "Druckvorlage")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    druckvorlage: Option<String>,
    #[serde(rename = "VersionFrom")]
    #[serde(skip_serializing_if = "Option::is_none")]
    version_from: Option<String>,
@@ -288,6 +509,9 @@ pub struct Entry {
    speichern: String,
    #[serde(rename = "LeerAusblenden")]
    leer_ausblenden: bool,
+    #[serde(rename = "Inhalt")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    inhalt: Option<String>,
    #[serde(rename = "GeschlossenAnzeigen")]
    geschlossen_anzeigen: bool,
    #[serde(rename = "Min")]
@@ -297,7 +521,8 @@ pub struct Entry {
    #[serde(rename = "InUebersichtAnzeigen")]
    in_uebersicht_anzeigen: bool,
    #[serde(rename = "Hinweis")]
-    hinweis: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    hinweis: Option<String>,
    #[serde(rename = "Vorschlagskategorie")]
    #[serde(skip_serializing_if = "Option::is_none")]
    vorschlagskategorie: Option<String>,
@@ -369,12 +594,21 @@ pub struct Entry {
    in_auswertung: bool,
    #[serde(rename = "InAuswertungGraph")]
    in_auswertung_graph: bool,
+    #[serde(rename = "FragebogenItemNummer")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    fragebogen_item_nummer: Option<u8>,
+    #[serde(rename = "Score")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    score: Option<String>,
    #[serde(rename = "AlignmentPatModul")]
    alignment_pat_modul: String,
    #[serde(rename = "DirectionPatModul")]
    direction_pat_modul: String,
    #[serde(rename = "SeitenumbruchPatModul")]
    seitenumbruch_pat_modul: bool,
+    #[serde(rename = "Kontaktliste")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    kontaktliste: Option<String>,
    #[serde(rename = "MarkierungIgnorieren")]
    markierung_ignorieren: bool,
    #[serde(rename = "SucheArt")]
@@ -421,6 +655,35 @@ impl FormEntry for Entry {
            valid: true,
        });
    }
+
+    fn hide(&mut self) {
+        self.filter = Some(Filter {
+            condition: "false".into(),
+            valid: true,
+            ref_entries: Some(RefEntries { ref_entry: None }),
+        });
+        self.speichern = "0".into()
+    }
+}
+
+impl Sortable for Entry {
+    fn sorting_key(&self) -> String {
+        self.name.clone()
+    }
+
+    fn sorted(&mut self) -> &Self
+    where
+        Self: Sized,
+    {
+        if let Some(ref mut filter) = self.filter {
+            if let Some(ref mut ref_entries) = filter.ref_entries {
+                if let Some(ref mut ref_entry) = ref_entries.ref_entry {
+                    ref_entry.sort_unstable()
+                }
+            }
+        }
+        self
+    }
 }

 #[derive(Serialize, Deserialize, Debug)]
--- a/src/model/mod.rs
+++ b/src/model/mod.rs
@@ -22,13 +22,21 @@
 * SOFTWARE.
 */

-use crate::profile::{FormReference, Profile};
+use std::cmp::Ordering;
+use std::collections::hash_map::DefaultHasher;
+use std::fmt::Debug;
+use std::hash::{Hash, Hasher};
+
 use serde::{Deserialize, Serialize};

+use crate::model::requirements::Requires;
+use crate::profile::{FormField, FormReference, Profile};
+
 pub mod data_catalogue;
 pub mod data_form;
 pub mod onkostar_editor;
 pub mod property_catalogue;
+pub mod requirements;
 pub mod unterformular;

 #[derive(Serialize, Deserialize, Debug)]
@@ -88,11 +96,15 @@ pub struct Ansicht {
    #[serde(rename = "Konfiguration")]
    konfiguration: String,
    #[serde(rename = "DataForm")]
-    data_form: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    data_form: Option<String>,
    #[serde(rename = "DataCatalogue")]
    data_catalogue: String,
    #[serde(rename = "TypAuswahl")]
    typ_auswahl: String,
+    #[serde(rename = "PersonenstammKontext", default)]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    personenstamm_kontext: Option<String>,
    #[serde(rename = "Suche")]
    suche: bool,
    #[serde(rename = "SID")]
@@ -123,6 +135,66 @@ pub struct MenuCategory {
    column: String,
 }

+#[derive(Serialize, Deserialize, Debug)]
+#[serde(deny_unknown_fields)]
+pub struct PunkteKategorien {
+    #[serde(rename = "PunkteKategorie", default)]
+    punkte_kategorie: Vec<PunkteKategorie>,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(deny_unknown_fields)]
+pub struct PunkteKategorie {
+    #[serde(rename = "Name")]
+    name: String,
+    #[serde(rename = "Beschreibung")]
+    beschreibung: String,
+    #[serde(rename = "MaxLeerwerte")]
+    max_leerwerte: u16,
+    #[serde(rename = "Berechnung")]
+    berechnung: String,
+    #[serde(rename = "Felder")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    felder: Option<Felder>,
+    #[serde(rename = "Vergleichswerttabellen")]
+    vergleichswerttabellen: String,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(deny_unknown_fields)]
+pub struct Felder {
+    #[serde(rename = "Feld", default)]
+    feld: Vec<Feld>,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(deny_unknown_fields)]
+pub struct Feld {
+    #[serde(rename = "DataFormEntryName")]
+    data_form_entry_name: String,
+    #[serde(rename = "ManuellePunkte")]
+    manuelle_punkte: bool,
+    #[serde(rename = "Werte")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    werte: Option<FeldWerte>,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(deny_unknown_fields)]
+pub struct FeldWerte {
+    #[serde(rename = "Wert", default)]
+    wert: Vec<FeldWert>,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(deny_unknown_fields)]
+pub struct FeldWert {
+    #[serde(rename = "Wert")]
+    wert: String,
+    #[serde(rename = "Punkte")]
+    punkte: String,
+}
+
 #[derive(Serialize, Deserialize, Debug)]
 #[serde(deny_unknown_fields)]
 pub struct Filter {
@@ -181,8 +253,12 @@ pub struct Haeufigkeit {
    taeglich_aktualisieren: bool,
    #[serde(rename = "Typ")]
    typ: String,
+    #[serde(rename = "NichtBerechnen")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    nicht_berechnen: Option<String>,
    #[serde(rename = "TabellenName")]
-    tabellen_name: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    tabellen_name: Option<String>,
 }

 #[derive(Serialize, Deserialize, Debug)]
@@ -206,6 +282,32 @@ pub struct Ordner {
    parent_order: Option<Box<Ordner>>,
 }

+#[derive(Serialize, Deserialize, Debug)]
+#[serde(deny_unknown_fields)]
+pub struct Kennzahlen {
+    #[serde(rename = "Kennzahl", default)]
+    kennzahl: Vec<Kennzahl>,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(deny_unknown_fields)]
+pub struct Kennzahl {
+    #[serde(rename = "Name")]
+    name: String,
+    #[serde(rename = "Nummer")]
+    nummer: String,
+    #[serde(rename = "Beschreibung")]
+    beschreibung: String,
+    #[serde(rename = "Notiz")]
+    notiz: String,
+    #[serde(rename = "Vorgabe")]
+    vorgabe: String,
+    #[serde(rename = "Haeufigkeitenzaehler")]
+    haeufigkeitenzaehler: String,
+    #[serde(rename = "Haeufigkeitennenner")]
+    haeufigkeitennenner: String,
+}
+
 fn apply_profile_to_form_entry<E>(entry: &mut E, form_reference: &FormReference)
 where
    E: FormEntry,
@@ -226,6 +328,15 @@ where
    }
 }

+fn apply_profile_to_form_field<E>(entry: &mut E, form_field: &FormField)
+where
+    E: FormEntry,
+{
+    if entry.get_name() == form_field.name && form_field.hide {
+        entry.hide()
+    }
+}
+
 pub trait FormEntryContainer {
    fn apply_profile(&mut self, profile: &Profile);
 }
@@ -236,6 +347,29 @@ pub trait Listable {

 pub trait Sortable {
    fn sorting_key(&self) -> String;
+
+    fn sorted(&mut self) -> &Self
+    where
+        Self: Sized,
+    {
+        self
+    }
+}
+
+pub trait Comparable: Debug {
+    fn get_name(&self) -> String;
+    fn get_revision(&self) -> u16;
+    fn get_hash(&self) -> String {
+        let mut h = DefaultHasher::new();
+        format!("{:?}", self).hash(&mut h);
+        h.finish().to_string()
+    }
+    fn compare_by_requirement(_: &Self, _: &Self) -> Ordering
+    where
+        Self: Requires,
+    {
+        Ordering::Equal
+    }
 }

 pub trait FormEntry {
@@ -245,4 +379,13 @@ pub trait FormEntry {
    fn update_anzeige(&mut self, value: String);
    fn update_anzeige_auswahl(&mut self, value: String);
    fn update_scripts_code(&mut self, value: String);
+    fn hide(&mut self);
+}
+
+pub trait FolderContent {
+    fn get_library_folder(&self) -> String;
+
+    fn is_system_library_content(&self) -> bool {
+        "ONKOSTAR Bibliothek" == self.get_library_folder()
+    }
 }
--- a/src/model/onkostar_editor.rs
+++ b/src/model/onkostar_editor.rs
@@ -1,7 +1,7 @@
 /*
 * MIT License
 *
- * 2023 Comprehensive Cancer Center Mainfranken
+ * Copyright (c) 2023 Comprehensive Cancer Center Mainfranken
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
@@ -22,16 +22,21 @@
 * SOFTWARE.
 */

+use std::cmp::Ordering;
+use std::fmt::Debug;
+use std::str::FromStr;
+
 use console::style;
 use quick_xml::de::from_str;
 use serde::{Deserialize, Serialize};
-use std::str::FromStr;

+use crate::checks::{CheckNotice, Checkable};
 use crate::model::data_catalogue::DataCatalogue;
 use crate::model::data_form::DataForm;
 use crate::model::property_catalogue::PropertyCatalogue;
+use crate::model::requirements::{Requirement, Requires};
 use crate::model::unterformular::Unterformular;
-use crate::model::{FormEntryContainer, Listable, Sortable};
+use crate::model::{Comparable, FolderContent, FormEntryContainer, Listable, Sortable};
 use crate::profile::Profile;

 #[derive(Serialize, Deserialize, Debug)]
@@ -44,13 +49,73 @@ pub struct OnkostarEditor {
 }

 impl OnkostarEditor {
+    pub fn find_property_catalogue<'a>(&'a self, name: &str) -> Option<&'a PropertyCatalogue> {
+        match self
+            .editor
+            .property_catalogue
+            .iter()
+            .filter(|&item| item.get_name().eq_ignore_ascii_case(name))
+            .nth(0)
+        {
+            Some(x) => Some(x),
+            _ => None,
+        }
+    }
+
+    pub fn find_data_catalogue<'a>(&'a self, name: &str) -> Option<&'a DataCatalogue> {
+        match self
+            .editor
+            .data_catalogue
+            .iter()
+            .filter(|&item| item.get_name().eq_ignore_ascii_case(name))
+            .nth(0)
+        {
+            Some(x) => Some(x),
+            _ => None,
+        }
+    }
+
+    pub fn find_data_form<'a>(&'a self, name: &str) -> Option<&'a DataForm> {
+        match self
+            .editor
+            .data_form
+            .iter()
+            .filter(|&item| item.get_name().eq_ignore_ascii_case(name))
+            .nth(0)
+        {
+            Some(x) => Some(x),
+            _ => None,
+        }
+    }
+
+    pub fn find_unterformular<'a>(&'a self, name: &str) -> Option<&'a Unterformular> {
+        match self
+            .editor
+            .unterformular
+            .iter()
+            .filter(|&item| item.get_name().eq_ignore_ascii_case(name))
+            .nth(0)
+        {
+            Some(x) => Some(x),
+            _ => None,
+        }
+    }
+
    pub fn apply_profile(&mut self, profile: &Profile) {
-        self.editor.data_form.iter_mut().for_each(|data_form| {
-            data_form.apply_profile(profile);
-        });
-        self.editor.unterformular.iter_mut().for_each(|data_form| {
-            data_form.apply_profile(profile);
-        })
+        self.editor
+            .data_form
+            .iter_mut()
+            .filter(|data_form| !data_form.is_system_library_content())
+            .for_each(|data_form| {
+                data_form.apply_profile(profile);
+            });
+        self.editor
+            .unterformular
+            .iter_mut()
+            .filter(|data_form| !data_form.is_system_library_content())
+            .for_each(|data_form| {
+                data_form.apply_profile(profile);
+            });
    }

    pub fn print_list(&self) {
@@ -66,28 +131,271 @@ impl OnkostarEditor {
        Self::print_items("Unterformulare", &self.editor.unterformular);
    }

+    fn filter_by_name_contains(&mut self, name: &str) {
+        self.editor
+            .property_catalogue
+            .retain(|e| e.get_name().contains(name));
+        self.editor
+            .data_catalogue
+            .retain(|e| e.get_name().contains(name));
+        self.editor
+            .data_form
+            .retain(|e| e.get_name().contains(name));
+        self.editor
+            .unterformular
+            .retain(|e| e.get_name().contains(name));
+    }
+    pub fn print_list_filtered(&mut self, name: &str) {
+        println!(
+            "Die Datei wurde am {} mit {} in Version {} erstellt.\n\nFolgende Inhalte für '{}' sind gespeichert",
+            style(&self.info_xml.datum_xml).yellow(),
+            style(&self.info_xml.name).yellow(),
+            style(&self.info_xml.version).yellow(),
+            name
+        );
+
+        self.filter_by_name_contains(name);
+
+        Self::print_items("Merkmalskataloge", &self.editor.property_catalogue);
+        Self::print_items("Datenkataloge", &self.editor.data_catalogue);
+        Self::print_items("Formulare", &self.editor.data_form);
+        Self::print_items("Unterformulare", &self.editor.unterformular);
+    }
+
    fn print_items(title: &str, list: &[impl Listable]) {
-        println!("\n{} {}", list.len(), style(title).underlined());
+        print!("\n{} {}", list.len(), style(title).underlined());
+        println!(
+            " - Inhalte der Systembibliothek sind mit ({}), der Benutzerbibliothek mit (u) markiert",
+            style("S").yellow()
+        );
        list.iter()
            .for_each(|entry| println!("{}", entry.to_listed_string()));
    }

+    pub fn print_tree(&self) {
+        println!(
+            "Die Datei wurde am {} mit {} in Version {} erstellt.\n\nFolgende Inhalte sind gespeichert",
+            style(&self.info_xml.datum_xml).yellow(),
+            style(&self.info_xml.name).yellow(),
+            style(&self.info_xml.version).yellow()
+        );
+
+        Self::print_items("Merkmalskataloge", &self.editor.property_catalogue);
+        self.print_items_tree("Datenkataloge", &self.editor.data_catalogue);
+        self.print_items_tree("Formulare", &self.editor.data_form);
+        self.print_items_tree("Unterformulare", &self.editor.unterformular);
+    }
+
+    pub fn print_tree_filtered(&mut self, name: &str) {
+        println!(
+            "Die Datei wurde am {} mit {} in Version {} erstellt.\n\nFolgende Inhalte für '{}' sind gespeichert",
+            style(&self.info_xml.datum_xml).yellow(),
+            style(&self.info_xml.name).yellow(),
+            style(&self.info_xml.version).yellow(),
+            name
+        );
+
+        self.filter_by_name_contains(name);
+
+        Self::print_items("Merkmalskataloge", &self.editor.property_catalogue);
+        self.print_items_tree("Datenkataloge", &self.editor.data_catalogue);
+        self.print_items_tree("Formulare", &self.editor.data_form);
+        self.print_items_tree("Unterformulare", &self.editor.unterformular);
+    }
+
+    fn print_items_tree(&self, title: &str, list: &[impl Requires]) {
+        print!("\n{} {}", list.len(), style(title).underlined());
+        println!(
+            " - Inhalte der Systembibliothek sind mit ({}), der Benutzerbibliothek mit (u) markiert",
+            style("S").yellow()
+        );
+        list.iter()
+            .for_each(|entry| println!("{}", entry.to_requirement_string(self)));
+    }
+
    pub fn sorted(&mut self) {
        self.editor
            .property_catalogue
            .sort_unstable_by_key(|e| e.sorting_key());

+        self.editor.property_catalogue.iter_mut().for_each(|item| {
+            item.sorted();
+        });
+
        self.editor
            .data_catalogue
            .sort_unstable_by_key(|e| e.sorting_key());

+        self.editor.data_catalogue.iter_mut().for_each(|item| {
+            item.sorted();
+        });
+
+        /*self.editor
+        .data_form
+        .sort_unstable_by_key(|e| e.sorting_key());*/
+
        self.editor
            .data_form
-            .sort_unstable_by_key(|e| e.sorting_key());
+            .sort_unstable_by(DataForm::compare_by_requirement);
+
+        self.editor.data_form.iter_mut().for_each(|item| {
+            item.sorted();
+        });
+
+        /*self.editor
+        .unterformular
+        .sort_unstable_by_key(|e| e.sorting_key());*/

        self.editor
            .unterformular
-            .sort_unstable_by_key(|e| e.sorting_key());
+            .sort_unstable_by(Unterformular::compare_by_requirement);
+
+        self.editor.unterformular.iter_mut().for_each(|item| {
+            item.sorted();
+        });
+    }
+
+    pub fn strip_system_library_content(&mut self) {
+        self.editor
+            .property_catalogue
+            .retain(|e| !e.is_system_library_content());
+
+        self.editor
+            .data_catalogue
+            .retain(|e| !e.is_system_library_content());
+
+        self.editor
+            .data_form
+            .retain(|e| !e.is_system_library_content());
+
+        self.editor
+            .unterformular
+            .retain(|e| !e.is_system_library_content());
+    }
+
+    pub fn print_diff(&mut self, other: &mut Self, strict: bool) {
+        println!();
+
+        println!(
+            "Datei A wurde am {} mit {} in Version {} erstellt.",
+            style(&self.info_xml.datum_xml).yellow(),
+            style(&self.info_xml.name).yellow(),
+            style(&self.info_xml.version).yellow()
+        );
+
+        println!(
+            "Datei B wurde am {} mit {} in Version {} erstellt.",
+            style(&other.info_xml.datum_xml).yellow(),
+            style(&other.info_xml.name).yellow(),
+            style(&other.info_xml.version).yellow()
+        );
+
+        self.sorted();
+        other.sorted();
+
+        Self::print_item_diff(
+            "Merkmalskataloge",
+            &self.editor.property_catalogue,
+            &other.editor.property_catalogue,
+            strict,
+        );
+        Self::print_item_diff(
+            "Datenkataloge",
+            &self.editor.data_catalogue,
+            &other.editor.data_catalogue,
+            strict,
+        );
+        Self::print_item_diff(
+            "Formulare",
+            &self.editor.data_form,
+            &other.editor.data_form,
+            strict,
+        );
+        Self::print_item_diff(
+            "Unterformulare",
+            &self.editor.unterformular,
+            &other.editor.unterformular,
+            strict,
+        );
+    }
+
+    fn print_item_diff(
+        title: &str,
+        list_a: &[impl Comparable],
+        list_b: &[impl Comparable],
+        strict: bool,
+    ) {
+        println!("\n{}", style(title).underlined());
+
+        let mut has_diff = false;
+
+        let names_a = list_a
+            .iter()
+            .map(|entry| entry.get_name())
+            .collect::<Vec<_>>();
+        let names_b = list_b
+            .iter()
+            .map(|entry| entry.get_name())
+            .collect::<Vec<_>>();
+
+        names_b.iter().for_each(|entry| {
+            if !names_a.contains(entry) {
+                println!("{}: {}", entry, style("Nicht in Datei A enthalten!").red());
+                has_diff = true;
+            }
+        });
+
+        names_a.iter().for_each(|entry| {
+            if !names_b.contains(entry) {
+                println!("{}: {}", entry, style("Nicht in Datei B enthalten!").red());
+                has_diff = true;
+            }
+        });
+
+        list_a.iter().for_each(|entry_a| {
+            list_b.iter().for_each(|entry_b| {
+                if entry_a.get_name() == entry_b.get_name() {
+                    match entry_a.get_revision().cmp(&entry_b.get_revision()) {
+                        Ordering::Less => {
+                            println!(
+                                "{}: {} (Revision {} < Revision {})",
+                                entry_a.get_name(),
+                                style("Neuer in Datei B").yellow(),
+                                style(entry_a.get_revision()).blue(),
+                                style(entry_b.get_revision()).green()
+                            );
+                            has_diff = true;
+                        }
+                        Ordering::Greater => {
+                            println!(
+                                "{}: {} (Revision {} > Revision {})",
+                                entry_a.get_name(),
+                                style("Neuer in Datei A").yellow(),
+                                style(entry_a.get_revision()).green(),
+                                style(entry_b.get_revision()).blue()
+                            );
+                            has_diff = true;
+                        }
+                        _ => {
+                            if strict && entry_a.get_hash() != entry_b.get_hash() {
+                                println!(
+                                    "{}: {} (z.B. GUID oder Reihenfolge von Unterelementen)",
+                                    entry_a.get_name(),
+                                    style("Inhaltlich verschieden").yellow()
+                                );
+                                has_diff = true;
+                            } else if strict {
+                                println!("{}: {}", entry_a.get_name(), style("Identisch").green())
+                            }
+                        }
+                    }
+                }
+            });
+        });
+
+        if !has_diff {
+            println!("Keine Unterschiede")
+        }
    }
 }

@@ -102,6 +410,89 @@ impl FromStr for OnkostarEditor {
    }
 }

+impl Checkable for OnkostarEditor {
+    fn check(&self) -> Vec<CheckNotice> {
+        // Inner form checks
+
+        let mut result = self
+            .editor
+            .data_form
+            .iter()
+            .flat_map(|entity| entity.check())
+            .collect::<Vec<_>>();
+
+        let other = &mut self
+            .editor
+            .unterformular
+            .iter()
+            .flat_map(|entity| entity.check())
+            .collect::<Vec<_>>();
+
+        result.append(other);
+
+        // Check requirements
+
+        let mut requirement_checked_forms = vec![];
+
+        fn requirement_error(
+            form: &impl Comparable,
+            item: &impl Comparable,
+            t: &str,
+        ) -> CheckNotice {
+            CheckNotice::ErrorWithCode {
+                code: "2023-0004".to_string(),
+                description: format!(
+                    "'{}' hat einen Verweis auf zuvor nicht definiertes {t} '{}' (OSTARSUPP-13212)",
+                    form.get_name(),
+                    item.get_name()
+                ),
+                line: None,
+                example: None,
+            }
+        }
+
+        self.editor.unterformular.iter().for_each(|form| {
+            requirement_checked_forms.push(form.get_name());
+            form.get_required_entries(self)
+                .iter()
+                .for_each(|entry| match entry {
+                    Requirement::DataFormReference(&ref item) => {
+                        if !requirement_checked_forms.contains(&item.get_name()) {
+                            result.push(requirement_error(form, item, "Formular"))
+                        }
+                    }
+                    Requirement::UnterformularReference(&ref item) => {
+                        if !requirement_checked_forms.contains(&item.get_name()) {
+                            result.push(requirement_error(form, item, "Unterformular"))
+                        }
+                    }
+                    _ => {}
+                });
+        });
+
+        self.editor.data_form.iter().for_each(|form| {
+            requirement_checked_forms.push(form.get_name());
+            form.get_required_entries(self)
+                .iter()
+                .for_each(|entry| match entry {
+                    Requirement::DataFormReference(&ref item) => {
+                        if !requirement_checked_forms.contains(&item.get_name()) {
+                            result.push(requirement_error(form, item, "Formular"))
+                        }
+                    }
+                    Requirement::UnterformularReference(&ref item) => {
+                        if !requirement_checked_forms.contains(&item.get_name()) {
+                            result.push(requirement_error(form, item, "Unterformular"))
+                        }
+                    }
+                    _ => {}
+                });
+        });
+
+        result
+    }
+}
+
 #[derive(Serialize, Deserialize, Debug)]
 #[serde(deny_unknown_fields)]
 pub struct InfoXML {
@@ -116,12 +507,12 @@ pub struct InfoXML {
 #[derive(Serialize, Deserialize, Debug)]
 #[serde(deny_unknown_fields)]
 struct Editor {
-    #[serde(rename = "PropertyCatalogue")]
+    #[serde(rename = "PropertyCatalogue", default)]
    property_catalogue: Vec<PropertyCatalogue>,
-    #[serde(rename = "DataCatalogue")]
+    #[serde(rename = "DataCatalogue", default)]
    data_catalogue: Vec<DataCatalogue>,
-    #[serde(rename = "Unterformular")]
+    #[serde(rename = "Unterformular", default)]
    unterformular: Vec<Unterformular>,
-    #[serde(rename = "DataForm")]
+    #[serde(rename = "DataForm", default)]
    data_form: Vec<DataForm>,
 }
--- a/src/model/property_catalogue.rs
+++ b/src/model/property_catalogue.rs
@@ -25,7 +25,7 @@
 use console::style;
 use serde::{Deserialize, Serialize};

-use crate::model::{Listable, Ordner, Sortable};
+use crate::model::{Comparable, FolderContent, Listable, Ordner, Sortable};

 #[derive(Serialize, Deserialize, Debug)]
 #[serde(deny_unknown_fields)]
@@ -56,7 +56,11 @@ pub struct PropertyCatalogue {
 impl Listable for PropertyCatalogue {
    fn to_listed_string(&self) -> String {
        format!(
-            "Merkmalskatalog '{}' in Revision '{}'",
+            "Merkmalskatalog ({}) '{}' in Revision '{}'",
+            match self.is_system_library_content() {
+                true => style("S").yellow(),
+                _ => style("u"),
+            },
            style(&self.name).yellow(),
            style(&self.revision).yellow()
        )
@@ -67,6 +71,32 @@ impl Sortable for PropertyCatalogue {
    fn sorting_key(&self) -> String {
        self.name.clone()
    }
+
+    fn sorted(&mut self) -> &Self {
+        if let Some(ref mut versions) = self.versions.entry {
+            versions.sort_unstable_by_key(|item| item.version_number);
+            versions.iter_mut().for_each(|version| {
+                version.sorted();
+            });
+        }
+        self
+    }
+}
+
+impl Comparable for PropertyCatalogue {
+    fn get_name(&self) -> String {
+        self.name.clone()
+    }
+
+    fn get_revision(&self) -> u16 {
+        self.revision
+    }
+}
+
+impl FolderContent for PropertyCatalogue {
+    fn get_library_folder(&self) -> String {
+        self.ordner.bibliothek.name.to_string()
+    }
 }

 #[derive(Serialize, Deserialize, Debug)]
@@ -97,12 +127,50 @@ pub struct Version {
    #[serde(rename = "Revision")]
    revision: u16,
    #[serde(rename = "Entries")]
-    entries: VersionEntries,
+    entries: Option<VersionEntries>,
    #[serde(rename = "Abbildung")]
    #[serde(skip_serializing_if = "Option::is_none")]
    abbildung: Option<Vec<Abbildung>>,
    #[serde(rename = "Categories")]
-    categories: Categories,
+    categories: Option<Categories>,
+}
+
+impl Sortable for Version {
+    fn sorting_key(&self) -> String {
+        self.oid.clone()
+    }
+
+    fn sorted(&mut self) -> &Self
+    where
+        Self: Sized,
+    {
+        if let Some(ref mut abbildung) = self.abbildung {
+            abbildung.sort_unstable_by_key(|item| item.sorting_key());
+            abbildung.iter_mut().for_each(|item| {
+                item.sorted();
+            });
+        }
+
+        if let Some(ref mut entries) = self.entries {
+            entries
+                .content
+                .sort_unstable_by_key(|item| item.sorting_key());
+            entries.content.iter_mut().for_each(|item| {
+                item.sorted();
+            });
+        }
+
+        if let Some(ref mut categories) = self.categories {
+            categories
+                .content
+                .sort_unstable_by_key(|item| item.sorting_key());
+            categories.content.iter_mut().for_each(|item| {
+                item.sorted();
+            });
+        }
+
+        self
+    }
 }

 #[derive(Serialize, Deserialize, Debug)]
@@ -120,17 +188,26 @@ pub struct VersionEntry {
    #[serde(rename = "ShortDescription")]
    short_description: String,
    #[serde(rename = "Description")]
-    description: String,
+    description: Option<String>,
    #[serde(rename = "Synonyms", default)]
    #[serde(skip_serializing_if = "Option::is_none")]
    synonyms: Option<String>,
    #[serde(rename = "Note", default)]
    #[serde(skip_serializing_if = "Option::is_none")]
    note: Option<String>,
+    #[serde(rename = "Type", default)]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    type_: Option<String>,
    #[serde(rename = "Position")]
    position: String,
 }

+impl Sortable for VersionEntry {
+    fn sorting_key(&self) -> String {
+        self.code.clone()
+    }
+}
+
 #[derive(Serialize, Deserialize, Debug)]
 #[serde(deny_unknown_fields)]
 pub struct Categories {
@@ -155,6 +232,26 @@ pub struct Category {
    category_entries: CategoryEntries,
 }

+impl Sortable for Category {
+    fn sorting_key(&self) -> String {
+        self.name.clone()
+    }
+
+    fn sorted(&mut self) -> &Self
+    where
+        Self: Sized,
+    {
+        self.category_entries
+            .content
+            .sort_unstable_by_key(|item| item.sorting_key());
+        self.category_entries.content.iter_mut().for_each(|item| {
+            item.sorted();
+        });
+
+        self
+    }
+}
+
 #[derive(Serialize, Deserialize, Debug)]
 #[serde(deny_unknown_fields)]
 pub struct CategoryEntries {
@@ -181,6 +278,12 @@ pub struct CategoryEntry {
    note: Option<String>,
 }

+impl Sortable for CategoryEntry {
+    fn sorting_key(&self) -> String {
+        self.code.clone()
+    }
+}
+
 #[derive(Serialize, Deserialize, Debug)]
 #[serde(deny_unknown_fields)]
 pub struct Abbildung {
@@ -190,6 +293,24 @@ pub struct Abbildung {
    content: Vec<AbbildungEintrag>,
 }

+impl Sortable for Abbildung {
+    fn sorting_key(&self) -> String {
+        self.ziel_mk_version_oid.clone()
+    }
+
+    fn sorted(&mut self) -> &Self
+    where
+        Self: Sized,
+    {
+        self.content.sort_unstable_by_key(|item| item.sorting_key());
+        self.content.iter_mut().for_each(|item| {
+            item.sorted();
+        });
+
+        self
+    }
+}
+
 #[derive(Serialize, Deserialize, Debug)]
 #[serde(deny_unknown_fields)]
 pub struct AbbildungEintrag {
@@ -199,6 +320,12 @@ pub struct AbbildungEintrag {
    entry_to: AbbildungEntry,
 }

+impl Sortable for AbbildungEintrag {
+    fn sorting_key(&self) -> String {
+        format!("{}-{}", self.entry_from.code, self.entry_to.code)
+    }
+}
+
 #[derive(Serialize, Deserialize, Debug)]
 #[serde(deny_unknown_fields)]
 pub struct AbbildungEntry {
@@ -211,8 +338,9 @@ pub struct AbbildungEntry {
    #[serde(rename = "Synonyms")]
    #[serde(skip_serializing_if = "Option::is_none")]
    synonyms: Option<String>,
-    #[serde(rename = "Note")]
-    note: String,
+    #[serde(rename = "Note", default)]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    note: Option<String>,
    #[serde(rename = "Position")]
    position: String,
 }
--- a/src/model/requirements.rs
+++ b/src/model/requirements.rs
@@ -0,0 +1,163 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2023 Comprehensive Cancer Center Mainfranken
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+use crate::model::data_catalogue::DataCatalogue;
+use crate::model::data_form::DataForm;
+use crate::model::onkostar_editor::OnkostarEditor;
+use crate::model::property_catalogue::PropertyCatalogue;
+use crate::model::unterformular::Unterformular;
+use crate::model::{Comparable, Listable, Sortable};
+
+#[allow(clippy::enum_variant_names)]
+pub enum Requirement<'a> {
+    PropertyCatalogue(&'a PropertyCatalogue),
+    DataCatalogue(&'a DataCatalogue),
+    ExternalPropertyCatalogue(String),
+    ExternalDataCatalogue(String),
+    DataFormReference(&'a DataForm),
+    UnterformularReference(&'a Unterformular),
+    #[allow(dead_code)]
+    ExternalDataFormReference(String),
+    ExternalUnterformularReference(String),
+
+    DataFormSubform(&'a DataForm),
+    UnterformularSubform(&'a Unterformular),
+    #[allow(dead_code)]
+    ExternalDataFormSubform(String),
+    ExternalUnterformularSubform(String),
+}
+
+impl Sortable for Requirement<'_> {
+    fn sorting_key(&self) -> String {
+        match self {
+            Requirement::PropertyCatalogue(item) => item.get_name(),
+            Requirement::DataCatalogue(item) => item.get_name(),
+            Requirement::DataFormReference(item) => item.get_name(),
+            Requirement::UnterformularReference(item) => item.get_name(),
+            Requirement::DataFormSubform(item) => item.get_name(),
+            Requirement::UnterformularSubform(item) => item.get_name(),
+            Requirement::ExternalPropertyCatalogue(name)
+            | Requirement::ExternalDataCatalogue(name)
+            | Requirement::ExternalDataFormReference(name)
+            | Requirement::ExternalDataFormSubform(name)
+            | Requirement::ExternalUnterformularReference(name)
+            | Requirement::ExternalUnterformularSubform(name) => name.to_string(),
+        }
+    }
+}
+
+impl ToString for Requirement<'_> {
+    fn to_string(&self) -> String {
+        match self {
+            Requirement::PropertyCatalogue(item) => item.to_listed_string(),
+            Requirement::DataCatalogue(item) => item.to_listed_string(),
+            Requirement::DataFormReference(item) => item.to_listed_string(),
+            Requirement::UnterformularReference(item) => item.to_listed_string(),
+            Requirement::DataFormSubform(item) => item.to_listed_string(),
+            Requirement::UnterformularSubform(item) => item.to_listed_string(),
+            Requirement::ExternalPropertyCatalogue(name) => {
+                format!("Merkmalskatalog (-) '{}' - hier nicht enthalten", name)
+            }
+            Requirement::ExternalDataCatalogue(name) => {
+                format!("Datenkatalog (-) '{}' - hier nicht enthalten", name)
+            }
+            Requirement::ExternalDataFormReference(name)
+            | Requirement::ExternalDataFormSubform(name) => {
+                format!("Formular (-) '{}' - hier nicht enthalten", name)
+            }
+            Requirement::ExternalUnterformularReference(name)
+            | Requirement::ExternalUnterformularSubform(name) => {
+                format!("Unterformular (-) '{}' - hier nicht enthalten", name)
+            }
+        }
+    }
+}
+
+pub trait Requires
+where
+    Self: Listable,
+{
+    fn requires_form_reference(&self, _: &str) -> bool {
+        false
+    }
+
+    fn requires_subform(&self, _: &str) -> bool {
+        false
+    }
+
+    fn get_required_entries<'a>(&'a self, all: &'a OnkostarEditor) -> Vec<Requirement>;
+
+    fn to_requirement_string<'a>(&'a self, all: &'a OnkostarEditor) -> String {
+        format!(
+            "{}\n{}",
+            self.to_listed_string(),
+            self.get_required_entries(all)
+                .iter()
+                .map(|entry| match entry {
+                    Requirement::DataCatalogue(x) => {
+                        let inner = x
+                            .get_required_entries(all)
+                            .iter()
+                            .map(|inner_entry| match inner_entry {
+                                Requirement::PropertyCatalogue(_) => Some(inner_entry.to_string()),
+                                Requirement::ExternalPropertyCatalogue(_) => {
+                                    Some(inner_entry.to_string())
+                                }
+                                _ => None,
+                            })
+                            .filter(Option::is_some)
+                            .map(|item| format!("    - {}\n", item.unwrap()))
+                            .collect::<Vec<_>>()
+                            .join("");
+
+                        if inner.is_empty() {
+                            Some(format!("  + {}\n", x.to_listed_string()))
+                        } else {
+                            Some(format!("  + {}\n{}", x.to_listed_string(), inner))
+                        }
+                    }
+                    Requirement::ExternalDataCatalogue(_) => {
+                        Some(format!("  + {}\n", entry.to_string()))
+                    }
+                    Requirement::DataFormReference(_)
+                    | Requirement::ExternalDataFormReference(_)
+                    | Requirement::UnterformularReference(_)
+                    | Requirement::ExternalUnterformularReference(_) => {
+                        Some(format!("  > {}\n", entry.to_string()))
+                    }
+                    Requirement::DataFormSubform(_)
+                    | Requirement::ExternalDataFormSubform(_)
+                    | Requirement::UnterformularSubform(_)
+                    | Requirement::ExternalUnterformularSubform(_) => {
+                        Some(format!("  * {}\n", entry.to_string()))
+                    }
+                    _ => None,
+                })
+                .filter(Option::is_some)
+                .flatten()
+                .collect::<Vec<_>>()
+                .join("")
+        )
+    }
+}
--- a/src/model/unterformular.rs
+++ b/src/model/unterformular.rs
@@ -22,12 +22,20 @@
 * SOFTWARE.
 */

+use std::cmp::Ordering;
+use std::collections::HashSet;
+
+use crate::checks::CheckNotice::ErrorWithCode;
+use crate::checks::{CheckNotice, Checkable};
 use console::style;
 use serde::{Deserialize, Serialize};

+use crate::model::onkostar_editor::OnkostarEditor;
+use crate::model::requirements::{Requirement, Requires};
 use crate::model::{
-    apply_profile_to_form_entry, Ansichten, Entries, Filter, FormEntry, FormEntryContainer,
-    Listable, MenuCategory, PlausibilityRules, Script, Sortable,
+    apply_profile_to_form_entry, apply_profile_to_form_field, Ansichten, Comparable, Entries,
+    Filter, FolderContent, FormEntry, FormEntryContainer, Kennzahlen, Listable, MenuCategory,
+    PlausibilityRules, PunkteKategorien, RefEntries, Script, Sortable,
 };
 use crate::model::{Haeufigkeiten, Ordner};
 use crate::profile::Profile;
@@ -74,7 +82,7 @@ pub struct Unterformular {
    #[serde(rename = "EmailTemplate")]
    #[serde(skip_serializing_if = "Option::is_none")]
    mail_template: Option<String>,
-    #[serde(rename = "ErkrankungText")]
+    #[serde(rename = "ErkrankungText", default)]
    #[serde(skip_serializing_if = "Option::is_none")]
    erkrankung_text: Option<String>,
    #[serde(rename = "ErkrankungTextLong")]
@@ -91,6 +99,9 @@ pub struct Unterformular {
    erkrankung_big_summary: Option<String>,
    #[serde(rename = "Kontext")]
    kontext: String,
+    #[serde(rename = "Datenart")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    datenart: Option<String>,
    #[serde(rename = "TudokReadonly")]
    tudok_readonly: bool,
    #[serde(rename = "VitalstatusRelevant")]
@@ -153,12 +164,15 @@ pub struct Unterformular {
    #[serde(rename = "Haeufigkeiten")]
    haeufigkeiten: Haeufigkeiten,
    #[serde(rename = "Kennzahlen")]
-    kennzahlen: String,
+    kennzahlen: Kennzahlen,
    #[serde(rename = "Ordner")]
    ordner: Ordner,
    #[serde(rename = "MenuCategory")]
    #[serde(skip_serializing_if = "Option::is_none")]
    menu_category: Option<MenuCategory>,
+    #[serde(rename = "PunkteKategorien")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    punkte_kategorien: Option<PunkteKategorien>,
    #[serde(rename = "Ansichten")]
    #[serde(skip_serializing_if = "Option::is_none")]
    ansichten: Option<Ansichten>,
@@ -176,6 +190,12 @@ impl FormEntryContainer for Unterformular {
                            apply_profile_to_form_entry(entry, form_reference)
                        });

+                    // Hide form field using filter set to "false" if requested
+                    profile_form
+                        .form_fields
+                        .iter()
+                        .for_each(|form_field| apply_profile_to_form_field(entry, form_field));
+
                    if let Some(menu_category) = &profile_form.menu_category {
                        self.menu_category = Some(MenuCategory {
                            name: menu_category.name.clone(),
@@ -191,18 +211,19 @@ impl FormEntryContainer for Unterformular {

 impl Listable for Unterformular {
    fn to_listed_string(&self) -> String {
-        if self.hat_unterformulare {
-            return format!(
-                "Unterformular '{}' in Revision '{}' {}",
-                style(&self.name).yellow(),
-                style(&self.revision).yellow(),
-                style("Unterformular mit Markierung 'hat Unterformulare'!").red()
-            );
-        }
        format!(
-            "Unterformular '{}' in Revision '{}'",
+            "Unterformular ({}) '{}' in Revision '{}' {}",
+            match self.is_system_library_content() {
+                true => style("S").yellow(),
+                _ => style("u"),
+            },
            style(&self.name).yellow(),
-            style(&self.revision).yellow()
+            style(&self.revision).yellow(),
+            if self.hat_unterformulare {
+                style("Unterformular mit Markierung 'hat Unterformulare'!").red()
+            } else {
+                style("")
+            }
        )
    }
 }
@@ -211,6 +232,172 @@ impl Sortable for Unterformular {
    fn sorting_key(&self) -> String {
        self.name.clone()
    }
+
+    fn sorted(&mut self) -> &Self {
+        self.data_catalogues.data_catalogue.sort_unstable();
+
+        self.entries
+            .entry
+            .sort_unstable_by_key(|item| item.sorting_key());
+
+        self.entries.entry.iter_mut().for_each(|item| {
+            item.sorted();
+        });
+
+        if let Some(ref mut plausibility_rule) = self.plausibility_rules.plausibility_rule {
+            plausibility_rule.sort_unstable_by_key(|item| item.bezeichnung.clone());
+
+            plausibility_rule.iter_mut().for_each(|item| {
+                if let Some(ref mut data_form_entry_names) = item.data_form_entries.entry_name {
+                    data_form_entry_names.sort_unstable();
+                }
+            });
+        }
+        self
+    }
+}
+
+impl Comparable for Unterformular {
+    fn get_name(&self) -> String {
+        self.name.clone()
+    }
+
+    fn get_revision(&self) -> u16 {
+        self.revision
+    }
+
+    fn compare_by_requirement(a: &Self, b: &Self) -> Ordering {
+        if a.get_name() == b.get_name()
+            || a.is_system_library_content()
+            || b.is_system_library_content()
+        {
+            return Ordering::Equal;
+        }
+
+        if a.requires_form_reference(&b.get_name()) || a.requires_subform(&b.get_name()) {
+            return Ordering::Greater;
+        }
+
+        Ordering::Less
+    }
+}
+
+impl Requires for Unterformular {
+    fn requires_form_reference(&self, name: &str) -> bool {
+        self.entries
+            .entry
+            .iter()
+            .map(|item| {
+                item.type_ == "formReference"
+                    && match item.referenced_data_form.as_ref() {
+                        Some(refname) => refname == name,
+                        _ => false,
+                    }
+            })
+            .filter(|&it| it)
+            .last()
+            .unwrap_or_default()
+    }
+    fn requires_subform(&self, name: &str) -> bool {
+        self.entries
+            .entry
+            .iter()
+            .map(|item| {
+                item.type_ == "subform"
+                    && match item.referenced_data_form.as_ref() {
+                        Some(refname) => refname == name,
+                        _ => false,
+                    }
+            })
+            .filter(|&it| it)
+            .last()
+            .unwrap_or_default()
+    }
+
+    fn get_required_entries<'a>(&'a self, all: &'a OnkostarEditor) -> Vec<Requirement> {
+        let mut result = self
+            .data_catalogues
+            .data_catalogue
+            .iter()
+            .collect::<HashSet<_>>()
+            .into_iter()
+            .map(|entry| match all.find_data_catalogue(entry.as_str()) {
+                Some(contained) => Requirement::DataCatalogue(contained),
+                None => Requirement::ExternalDataCatalogue(entry.to_string()),
+            })
+            .collect::<Vec<_>>();
+        result.sort_unstable_by_key(|item| item.sorting_key());
+
+        let referenced_forms = &mut self
+            .entries
+            .entry
+            .iter()
+            .filter(|&entry| entry.get_type() == "formReference")
+            .filter_map(|entry| match &entry.referenced_data_form {
+                Some(name) => Some(name),
+                None => None,
+            })
+            .collect::<HashSet<_>>()
+            .into_iter()
+            .map(|entry| match all.find_data_form(entry.as_str()) {
+                Some(contained) => Requirement::DataFormReference(contained),
+                None => match all.find_unterformular(entry.as_str()) {
+                    Some(contained) => Requirement::UnterformularReference(contained),
+                    None => Requirement::ExternalUnterformularReference(entry.to_string()),
+                },
+            })
+            .collect::<Vec<_>>();
+        referenced_forms.sort_unstable_by_key(|item| item.sorting_key());
+        result.append(referenced_forms);
+
+        let sub_forms = &mut self
+            .entries
+            .entry
+            .iter()
+            .filter(|&entry| entry.get_type() == "subform")
+            .filter_map(|entry| match &entry.referenced_data_form {
+                Some(name) => Some(name),
+                None => None,
+            })
+            .collect::<HashSet<_>>()
+            .into_iter()
+            .map(|entry| match all.find_data_form(entry.as_str()) {
+                Some(contained) => Requirement::DataFormSubform(contained),
+                None => match all.find_unterformular(entry.as_str()) {
+                    Some(contained) => Requirement::UnterformularSubform(contained),
+                    None => Requirement::ExternalUnterformularSubform(entry.to_string()),
+                },
+            })
+            .collect::<Vec<_>>();
+        sub_forms.sort_unstable_by_key(|item| item.sorting_key());
+        result.append(sub_forms);
+
+        result
+    }
+}
+
+impl FolderContent for Unterformular {
+    fn get_library_folder(&self) -> String {
+        self.ordner.bibliothek.name.to_string()
+    }
+}
+
+impl Checkable for Unterformular {
+    fn check(&self) -> Vec<CheckNotice> {
+        if self.hat_unterformulare {
+            return vec![ErrorWithCode {
+                code: "2023-0001".to_string(),
+                description: format!(
+                    "Unterformular '{}' mit Markierung 'hat Unterformulare'",
+                    self.name
+                ),
+                line: None,
+                example: None,
+            }];
+        }
+
+        vec![]
+    }
 }

 #[derive(Serialize, Deserialize, Debug)]
@@ -281,6 +468,9 @@ pub struct Entry {
    grafik_ausrichtung: Option<String>,
    #[serde(rename = "Mandatory")]
    mandatory: String,
+    #[serde(rename = "Datenart", default)]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    datenart: Option<String>,
    #[serde(rename = "Filter")]
    #[serde(skip_serializing_if = "Option::is_none")]
    filter: Option<Filter>,
@@ -300,6 +490,9 @@ pub struct Entry {
    #[serde(rename = "AnzeigeAuswahl")]
    #[serde(skip_serializing_if = "Option::is_none")]
    anzeige_auswahl: Option<String>,
+    #[serde(rename = "Druckvorlage")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    druckvorlage: Option<String>,
    #[serde(rename = "VersionFrom")]
    #[serde(skip_serializing_if = "Option::is_none")]
    version_from: Option<String>,
@@ -307,6 +500,9 @@ pub struct Entry {
    speichern: String,
    #[serde(rename = "LeerAusblenden")]
    leer_ausblenden: bool,
+    #[serde(rename = "Inhalt")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    inhalt: Option<String>,
    #[serde(rename = "GeschlossenAnzeigen")]
    geschlossen_anzeigen: bool,
    #[serde(rename = "Min")]
@@ -389,12 +585,21 @@ pub struct Entry {
    in_auswertung: bool,
    #[serde(rename = "InAuswertungGraph")]
    in_auswertung_graph: bool,
+    #[serde(rename = "FragebogenItemNummer")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    fragebogen_item_nummer: Option<u8>,
+    #[serde(rename = "Score")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    score: Option<String>,
    #[serde(rename = "AlignmentPatModul")]
    alignment_pat_modul: String,
    #[serde(rename = "DirectionPatModul")]
    direction_pat_modul: String,
    #[serde(rename = "SeitenumbruchPatModul")]
    seitenumbruch_pat_modul: bool,
+    #[serde(rename = "Kontaktliste")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    kontaktliste: Option<String>,
    #[serde(rename = "MarkierungIgnorieren")]
    markierung_ignorieren: bool,
    #[serde(rename = "SucheArt")]
@@ -441,6 +646,35 @@ impl FormEntry for Entry {
            valid: true,
        });
    }
+
+    fn hide(&mut self) {
+        self.filter = Some(Filter {
+            condition: "false".into(),
+            valid: true,
+            ref_entries: Some(RefEntries { ref_entry: None }),
+        });
+        self.speichern = "0".into()
+    }
+}
+
+impl Sortable for Entry {
+    fn sorting_key(&self) -> String {
+        self.name.clone()
+    }
+
+    fn sorted(&mut self) -> &Self
+    where
+        Self: Sized,
+    {
+        if let Some(ref mut filter) = self.filter {
+            if let Some(ref mut ref_entries) = filter.ref_entries {
+                if let Some(ref mut ref_entry) = ref_entries.ref_entry {
+                    ref_entry.sort_unstable()
+                }
+            }
+        }
+        self
+    }
 }

 #[derive(Serialize, Deserialize, Debug)]
--- a/src/profile.rs
+++ b/src/profile.rs
@@ -34,6 +34,19 @@ pub struct Profile {
    pub forms: Vec<Form>,
 }

+impl Profile {
+    pub fn embedded_profile(name: &str) -> Result<Profile, String> {
+        let s = match name {
+            "UKM" => include_str!("../examples/dnpm-ukm.yml"),
+            "UKW" => include_str!("../examples/dnpm-ukw.yml"),
+            "UMG" => include_str!("../examples/dnpm-umg.yml"),
+            _ => return Err(format!("Not an embedded profile: '{name}'")),
+        };
+
+        Profile::from_str(s)
+    }
+}
+
 impl FromStr for Profile {
    type Err = String;

@@ -50,6 +63,8 @@ pub struct Form {
    pub name: String,
    #[serde(default)]
    pub form_references: Vec<FormReference>,
+    #[serde(default)]
+    pub form_fields: Vec<FormField>,
    pub menu_category: Option<MenuCategory>,
 }

@@ -68,6 +83,13 @@ impl FormReference {
    }
 }

+#[derive(Deserialize)]
+pub struct FormField {
+    pub name: String,
+    #[serde(default)]
+    pub hide: bool,
+}
+
 #[derive(Deserialize)]
 pub struct MenuCategory {
    pub name: String,
@@ -93,6 +115,9 @@ mod tests {
                     referenced_data_form: 'OS.Tumorkonferenz.VarianteUKW'
                     anzeige: 'Datum: {Datum}'
                     anzeige_auswahl: 'TK vom {Datum}'
+                 form_fields:
+                   - name: eingabefeld
+                     hide: true
            ";

        match Profile::from_str(content) {
@@ -101,6 +126,7 @@ mod tests {
                assert_eq!(profile.forms[0].name, "DNPM Therapieplan");
                assert!(profile.forms[0].menu_category.is_some());
                assert_eq!(profile.forms[0].form_references.len(), 1);
+                assert_eq!(profile.forms[0].form_fields.len(), 1)
            }
            Err(e) => panic!("Cannot deserialize profile: {}", e),
        }
@@ -212,4 +238,29 @@ mod tests {
        let actual = Profile::from_str(content);
        assert!(actual.is_err());
    }
+
+    #[test]
+    fn should_deserialize_form_fields() {
+        let content = "forms:
+               - name: 'DNPM Therapieplan'
+                 form_fields:
+                   - name: formularfeld_to_keep
+                     hide: false
+                   - name: formularfeld_to_hide
+                     hide: true
+            ";
+
+        match Profile::from_str(content) {
+            Ok(profile) => {
+                assert_eq!(profile.forms.len(), 1);
+                assert_eq!(profile.forms[0].name, "DNPM Therapieplan");
+                assert_eq!(profile.forms[0].form_fields.len(), 2);
+                assert_eq!(profile.forms[0].form_fields[0].name, "formularfeld_to_keep");
+                assert!(!profile.forms[0].form_fields[0].hide);
+                assert_eq!(profile.forms[0].form_fields[1].name, "formularfeld_to_hide");
+                assert!(profile.forms[0].form_fields[1].hide);
+            }
+            Err(e) => panic!("Cannot deserialize profile: {}", e),
+        }
+    }
 }
--- a/src/unzip_osb.rs
+++ b/src/unzip_osb.rs
@@ -0,0 +1,135 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2023 Comprehensive Cancer Center Mainfranken
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+use console::style;
+use deob::deobfuscate;
+use std::path::Path;
+use std::{fs, io};
+
+macro_rules! started {
+    ( $o:expr ) => {
+        println!("{: <6}{}", style("[..]").cyan(), $o);
+    };
+}
+
+macro_rules! ok {
+    ( $o:expr ) => {
+        use console::Term;
+        let _ = Term::stdout().move_cursor_up(1);
+        println!("{: <6}{}", style("[OK]").green(), $o);
+    };
+}
+
+macro_rules! error {
+    ( $o:expr, $e:expr ) => {
+        use console::Term;
+        let _ = Term::stdout().move_cursor_up(1);
+        println!("{: <6}{} - Error: {}", style("[ERR]").red(), $o, $e);
+    };
+}
+
+pub fn unzip_osb_using_password(path: &str, dir: &str, password: &str) {
+    println!("Entpacke OSB-Datei {}\n", style(path).yellow());
+
+    let file = match fs::File::open(path) {
+        Ok(file) => file,
+        Err(err) => {
+            println!(
+                "{: <6}Abbruch! - Kann Datei nicht entpacken: {}",
+                style("[ERR]").red(),
+                err
+            );
+            return;
+        }
+    };
+
+    let mut archive = match zip::ZipArchive::new(file) {
+        Ok(file) => file,
+        Err(err) => {
+            println!(
+                "{: <6}Abbruch! - Kann Datei nicht entpacken: {}",
+                style("[ERR]").red(),
+                err
+            );
+            return;
+        }
+    };
+
+    for i in 0..archive.len() {
+        let mut file = if let Ok(Ok(file)) = archive.by_index_decrypt(i, password.as_bytes()) {
+            file
+        } else {
+            println!(
+                "{: <6}Abbruch! - Kann Datei nicht entpacken",
+                style("[ERR]").red()
+            );
+            return;
+        };
+
+        let outpath = match file.enclosed_name() {
+            Some(path) => Path::new(dir).join(path.to_owned()),
+            None => continue,
+        };
+
+        started!(outpath.display());
+
+        if !file.is_dir() {
+            if let Some(p) = outpath.parent() {
+                if !p.exists() {
+                    fs::create_dir_all(p).unwrap();
+                }
+            }
+            let mut outfile = match fs::File::create(&outpath) {
+                Ok(file) => file,
+                Err(err) => {
+                    error!(outpath.display(), err);
+                    continue;
+                }
+            };
+            match io::copy(&mut file, &mut outfile) {
+                Ok(_) => {}
+                Err(err) => {
+                    error!(outpath.display(), err);
+                    continue;
+                }
+            }
+            ok!(outpath.display());
+        } else {
+            if !outpath.exists() {
+                match fs::create_dir_all(&outpath) {
+                    Ok(_) => {}
+                    Err(err) => {
+                        error!(outpath.display(), err);
+                        continue;
+                    }
+                }
+            }
+            ok!(outpath.display());
+        }
+    }
+}
+
+pub fn unzip_osb(path: &str, dir: &str) {
+    unzip_osb_using_password(path, dir, deobfuscate(env!("OSB_KEY").trim()).as_str());
+}
Author	SHA1	Message	Date
Paul-Christian Volkmer	f3bbef5d22	Bump version	2023-11-10 17:12:56 +01:00
Paul-Christian Volkmer	ef8f6ab1b5	Change description and arguments depending on selected features	2023-11-10 16:41:54 +01:00
Paul-Christian Volkmer	a1e5133516	Merge pull request #23 from CCC-MF/issue_22 Check form references to previously undefined forms in OSC files	2023-11-10 12:38:39 +01:00
Paul-Christian Volkmer	13bcd74f6c	Issue #22 : Check form references to previously undefined forms in OSC files	2023-11-10 12:36:53 +01:00
Paul-Christian Volkmer	6fdbe06106	Add information about the reason	2023-11-10 12:36:04 +01:00
Paul-Christian Volkmer	31c162e977	Update profile file for UKM	2023-11-09 13:15:18 +01:00
Paul-Christian Volkmer	2413e4b9b8	Improve check output	2023-11-09 13:00:34 +01:00
Paul-Christian Volkmer	c9ecb8e944	Add progress bar to OSB file check	2023-11-09 12:11:13 +01:00
Paul-Christian Volkmer	774b57d78e	Fix required argument conflicts in check sub command	2023-11-09 11:21:24 +01:00
Paul-Christian Volkmer	a52eb9742e	Merge pull request #21 from CCC-MF/issue_14 Issue #14: Embed existing DNPM profile files	2023-11-09 10:58:28 +01:00
Paul-Christian Volkmer	4c76504000	Issue #14 : Embed existing DNPM profile files	2023-11-09 10:53:38 +01:00
Paul-Christian Volkmer	4676a63c69	Fix warnings for disabled features	2023-11-09 10:42:54 +01:00
Paul-Christian Volkmer	e250e330a5	Merge pull request #20 from CCC-MF/issue_19 Check OSC- und OSB-Files for known issues	2023-11-09 09:27:16 +01:00
Paul-Christian Volkmer	349b571e09	Issue #19 : Do not allow check listing in combination with file check	2023-11-08 16:49:23 +01:00
Paul-Christian Volkmer	90423b5b4e	Issue #19 : Check OSC files within OSB file	2023-11-08 14:38:16 +01:00
Paul-Christian Volkmer	d45ded939e	Issue #19 : Extract method to check content of OSC file	2023-11-08 14:38:02 +01:00
Paul-Christian Volkmer	7ab5523f3c	Add more checks shown before in list subcommand	2023-11-08 12:35:58 +01:00
Paul-Christian Volkmer	f02ea9b065	Show issue counts ahead of issue list	2023-11-08 12:10:42 +01:00
Paul-Christian Volkmer	a08abd7688	Make version entries and categories optional in property catalogue	2023-11-08 11:56:07 +01:00
Paul-Christian Volkmer	bf7b8cd9ba	Add 'PunkteKategorie' to model	2023-11-07 12:00:21 +01:00
Paul-Christian Volkmer	821b30e452	Add information about 'check' sub command	2023-11-07 08:13:45 +01:00
Paul-Christian Volkmer	6a0a356120	Update issue code and description	2023-11-07 08:10:50 +01:00
Paul-Christian Volkmer	352f5e23fc	Merge pull request #18 from CCC-MF/issue_15 Checks and fixes for known issues in OSC files	2023-11-06 14:02:32 +01:00
Paul-Christian Volkmer	7b13251d34	Issue #15 : Add flag '--fix' to modify sub command	2023-11-06 14:00:20 +01:00
Paul-Christian Volkmer	6da1c48c28	Issue #15 : Show list of available checks	2023-11-06 13:59:08 +01:00
Paul-Christian Volkmer	e2d5eedd02	Issue #15 : Check OSC files for known issues	2023-11-06 13:31:34 +01:00
Paul-Christian Volkmer	a55db66e57	Issue #15 : Implement check subcommand cli	2023-11-06 11:52:57 +01:00
Paul-Christian Volkmer	dce2a5cdda	Merge pull request #17 from CCC-MF/issue_16 Issue #16: Add missing model entries and add optional declaration	2023-11-06 11:46:34 +01:00
Paul-Christian Volkmer	93981f7709	Issue #16 : Add missing model entries and add optional declaration	2023-11-06 11:44:41 +01:00
Paul-Christian Volkmer	b6694b9e53	Add package metadata to generate rpm packages	2023-11-04 11:45:47 +01:00
Paul-Christian Volkmer	0e690cbb85	Update quick-qml dependency	2023-11-04 11:45:15 +01:00
Paul-Christian Volkmer	0d6525c398	Update dependencies	2023-11-03 21:19:30 +01:00
Paul-Christian Volkmer	df643b5e60	Recompile if c header file changed	2023-11-03 20:59:31 +01:00
Paul-Christian Volkmer	1746026af8	Declare use within feature flag related part	2023-11-03 20:58:51 +01:00
Paul-Christian Volkmer	7cdfe0068f	Add information about optional params for unzip-osb command	2023-11-02 21:02:32 +01:00
Paul-Christian Volkmer	1f5ec80cc6	Add optional destination dir for OSB file extraction	2023-11-02 20:56:57 +01:00
Paul-Christian Volkmer	f851e9c424	Add optional OSB alternative password parameter	2023-11-01 13:29:30 +01:00
Paul-Christian Volkmer	7ef1638b58	Update dependencies	2023-10-31 15:09:03 +01:00
Paul-Christian Volkmer	4745a75f2e	Initial WXS file to build MSI installer package	2023-10-24 12:29:28 +02:00
Paul-Christian Volkmer	f089ad0b32	Update Cargo.lock file	2023-10-24 12:28:53 +02:00
Paul-Christian Volkmer	3948cdd697	Pump version to 0.6.0	2023-10-23 12:49:48 +02:00
Paul-Christian Volkmer	5a04571a16	Merge pull request #13 from CCC-MF/issue_12 Issue 12: Unzip OSB files	2023-10-23 12:47:21 +02:00
Paul-Christian Volkmer	f5dc366488	Issue #12 : Compile with feature unzip-osb in make file	2023-10-23 12:44:40 +02:00
Paul-Christian Volkmer	8c11c6d891	Issue #12 : Added information about subcommand unzip-os	2023-10-23 12:12:38 +02:00
Paul-Christian Volkmer	8a23d5b71b	Issue #12 : Add command to unzip osb files	2023-10-23 12:06:16 +02:00
Paul-Christian Volkmer	5d293555f8	Update dependencies	2023-10-09 22:10:52 +02:00
Paul-Christian Volkmer	f1c8a002fa	Add information for interactive modification	2023-10-06 12:54:46 +02:00
Paul-Christian Volkmer	86894632b6	Merge pull request #11 from CCC-MF/issue_10 Issue #10: Add interactive mode	2023-10-04 11:06:39 +02:00
Paul-Christian Volkmer	afb5a2e17a	Issue #10 : Add interactive mode	2023-10-04 10:14:45 +02:00
Paul-Christian Volkmer	f456e278cb	Update dependencies and bump version	2023-10-02 12:15:52 +02:00
Paul-Christian Volkmer	f28ab1afcd	Do not sort by form name in first place for now	2023-10-02 12:09:54 +02:00
Paul-Christian Volkmer	ae6b8d48e5	Merge pull request #9 from CCC-MF/issue_8 Issue #8: Add sorting by depency for required form references and subforms	2023-09-30 16:27:13 +02:00
Paul-Christian Volkmer	1302963b56	Issue #8 : Use system library content as equal content Since system library content is already present in OS database, it is no dependencies to be imported.	2023-09-30 16:09:36 +02:00
Paul-Christian Volkmer	6be11a8951	Issue #8 : Use field `ReferencedDataForm` instead of `Name`	2023-09-30 15:37:09 +02:00
Paul-Christian Volkmer	416204b30a	Issue #8 : Add initial sorting based on form dependencies	2023-09-30 15:06:24 +02:00
Paul-Christian Volkmer	86e988c50e	Add information about filter option	2023-09-30 13:48:06 +02:00
Paul-Christian Volkmer	76de86b685	Add information about dependency and requirement symbols	2023-09-30 13:34:41 +02:00
Paul-Christian Volkmer	d0de76770f	Sort dependencies and requirements	2023-09-30 13:26:25 +02:00
Paul-Christian Volkmer	8cae6ce706	Cleanup Requirement::to_string()	2023-09-30 13:04:47 +02:00
Paul-Christian Volkmer	81a0c6204b	Move common implementation into Requires trait	2023-09-30 12:11:14 +02:00
Paul-Christian Volkmer	21e31f35d1	Change requirement string mapping to match Unterformular implementation	2023-09-30 12:04:45 +02:00
Paul-Christian Volkmer	108aae329c	Change symbol for subform	2023-09-30 11:58:21 +02:00
Paul-Christian Volkmer	1f51d3e994	Show subform entries in tree subcommand	2023-09-28 17:19:14 +02:00
Paul-Christian Volkmer	c514005182	Update YAML file for UKM	2023-09-28 02:25:26 +02:00
Paul-Christian Volkmer	a127133ba2	Add YAML file for master profile	2023-09-28 00:00:43 +02:00
Paul-Christian Volkmer	e2d4d71063	Bump version	2023-09-19 17:38:57 +02:00
Paul-Christian Volkmer	629cc8aba9	Merge pull request #7 from CCC-MF/issue_5 Add all required and optional assets into deb package	2023-09-19 17:34:57 +02:00
Paul-Christian Volkmer	298a142586	Merge pull request #6 from CCC-MF/issue_4 Skip serializing None option	2023-09-19 17:34:19 +02:00
Paul-Christian Volkmer	9b9a0b4622	Add all required and optional assets into deb package	2023-09-19 17:32:49 +02:00
Paul-Christian Volkmer	9ffc0783ff	Skip serializing None option	2023-09-19 17:31:28 +02:00
Paul-Christian Volkmer	771d99fa27	Add extended description for deb packages	2023-09-19 16:54:48 +02:00
Paul-Christian Volkmer	eadf9326d0	Update dependencies and mark as v0.4.0	2023-09-19 16:54:48 +02:00
Paul-Christian Volkmer	bf63d93efa	Add optional field 'Kontaktliste' to forms	2023-09-19 16:54:48 +02:00
Paul-Christian Volkmer	ce52f92a7f	Fix build error if dir "completion" does not exist	2023-09-11 18:32:31 +02:00
Paul-Christian Volkmer	b3054f971e	Package deb package containing bash completion	2023-09-04 17:46:55 +02:00
Paul-Christian Volkmer	e27d31a8bf	Use clap crate in version 4.4	2023-09-04 16:51:22 +02:00
Paul-Christian Volkmer	d30c2991c0	Filter printed elements for list and tree sub command	2023-09-04 13:24:28 +02:00
Paul-Christian Volkmer	ce8dca1c10	Use --sorted and --strip as options for productive use This will keep old experimental options as alias.	2023-09-04 13:04:44 +02:00
Paul-Christian Volkmer	bfa7cc3c6b	Add sub command to calculate sha256 sum of an OSC file	2023-09-03 18:49:28 +02:00
Paul-Christian Volkmer	9256e242eb	Allow (actual) unused option	2023-09-03 18:40:43 +02:00
Paul-Christian Volkmer	e33b1a3a4c	Do not list form references twice as dataform and unterformular	2023-09-03 18:14:06 +02:00
Paul-Christian Volkmer	42cbb9ce7e	Combine matches to produce the same string	2023-09-03 18:06:56 +02:00
Paul-Christian Volkmer	8edd50feb4	Show form references using tree sub command	2023-09-03 17:31:38 +02:00
Paul-Christian Volkmer	31eda3efc9	Show notice if form has no field to be used as procedure date This indicates that the form cannot be used as main form, but as subform only.	2023-09-03 14:03:31 +02:00
Paul-Christian Volkmer	54cea88486	Inline additional information about subform mark	2023-09-03 13:58:28 +02:00
Paul-Christian Volkmer	4040c49521	Update link to example files	2023-09-01 19:50:25 +02:00
Paul-Christian Volkmer	e0b16c16d4	Remove xml-rs and update dependencies	2023-09-01 19:50:22 +02:00
Paul-Christian Volkmer	c07d4c8976	Merge pull request #3 from CCC-MF/hide_form_fields Hide form fields in OSC file using profile configuration	2023-09-01 12:40:13 +02:00
Paul-Christian Volkmer	3ec51099c7	Extract method to apply form field profile part	2023-09-01 12:31:48 +02:00
Paul-Christian Volkmer	1e7a95bb09	Always save form field content for hidden form fields	2023-09-01 09:07:08 +02:00
Paul-Christian Volkmer	abdef90e90	Set filter to "false" if form field should be hidden	2023-08-31 22:20:19 +02:00
Paul-Christian Volkmer	a2df2650ed	Use empty entry lists if they did not exist in file	2023-08-31 17:30:47 +02:00
Paul-Christian Volkmer	f947395c54	Update dependencies	2023-08-31 17:00:32 +02:00
Paul-Christian Volkmer	d3d4ec2646	Add a section for experimental functions in README.md	2023-08-31 17:00:00 +02:00
Paul-Christian Volkmer	f507893b4d	Show required dependencies not included in OSC file	2023-08-31 16:46:40 +02:00
Paul-Christian Volkmer	af4ec8898a	Strip content that is included in system library	2023-08-31 16:10:19 +02:00
Paul-Christian Volkmer	7d6a6ee9b3	Add information about user library flag	2023-08-31 15:54:38 +02:00
Paul-Christian Volkmer	a605018176	Do not modify forms included in system library	2023-08-31 12:08:34 +02:00
Paul-Christian Volkmer	a8851c5e4f	Mark system library content	2023-08-31 11:32:51 +02:00
Paul-Christian Volkmer	0b0188bd30	Print info_xml content if using diff sub command	2023-08-30 17:57:53 +02:00
Paul-Christian Volkmer	1e553aad58	Add add line break to very long argument description	2023-08-30 17:57:44 +02:00
Paul-Christian Volkmer	f9c66cfdb1	Merge pull request #2 from CCC-MF/show_requirements Add sub command 'tree' to show dependencies	2023-08-29 17:38:51 +02:00
Paul-Christian Volkmer	103075ab78	Add sub command 'tree' to show dependencies	2023-08-29 17:34:02 +02:00
Paul-Christian Volkmer	37c8b47d1f	Update dependencies	2023-08-25 20:53:05 +02:00
Paul-Christian Volkmer	d83fa34adb	Update version and added deb package config	2023-08-07 15:50:16 +02:00
Paul-Christian Volkmer	5c91e4d10f	Merge pull request #1 from CCC-MF/sorted_export Sorted export	2023-08-07 14:20:12 +02:00
Paul-Christian Volkmer	e84a39b7c4	Apply exported sorting to items itself and nested items	2023-08-07 14:16:44 +02:00
Paul-Christian Volkmer	376bfb2852	Experimental sort of exported content	2023-08-07 10:11:45 +02:00
Paul-Christian Volkmer	ad35b99371	Update dependencies	2023-08-06 21:37:10 +02:00
Paul-Christian Volkmer	224a7dba27	Update dependencies	2023-08-02 12:56:15 +02:00
Paul-Christian Volkmer	62ab073cfa	Fix error in README.md, showing wrong example command	2023-07-29 13:40:36 +02:00
Paul-Christian Volkmer	b2adb3c5fe	Add install task to Makefile	2023-07-03 01:15:15 +02:00
Paul-Christian Volkmer	a8911f86dd	Update dependencies	2023-07-02 23:14:19 +02:00
Paul-Christian Volkmer	b030ce6a53	Add subcommand 'diff' to compare two OSC files	2023-07-01 17:40:04 +02:00
Paul-Christian Volkmer	b04ee563f2	Update dependencies	2023-07-01 11:57:33 +02:00
Paul-Christian Volkmer	6e266feaf5	Changes in UKM profile: Added more form field settings	2023-06-28 10:39:36 +02:00