Merge branch 'release/3.4'

(cherry picked from commit ca998c0685)

.browserslistrc

@@ -0,0 +1,7 @@
+last 1 Chrome version
+last 1 Firefox version
+last 2 Edge major versions
+last 2 iOS major versions
+safari > 11
+Firefox ESR
+not IE 11 # Angular supports IE 11 only as an opt-in. To opt-in, remove the 'not' prefix on this line.

.gitignore

@@ -5,6 +5,8 @@
 /tmp
 /out-tsc
 
+/
+
 # dependencies
 /node_modules
 
@@ -31,9 +33,11 @@ speed-measure-plugin.json
 .history/*
 
 # misc
+/.angular/cache
 /.sass-cache
 /connect.lock
 /coverage
+/testresults
 /libpeerconnection.log
 npm-debug.log
 yarn-error.log
@@ -45,4 +49,5 @@ testem.log
 .DS_Store
 Thumbs.db
 
-libs/swagger/src/lib/*
+libs/swagger/src/lib/*
+*storybook.log

.husky/pre-commit

@@ -0,0 +1 @@
+npm run pretty-quick

.npmrc

@@ -1,13 +1 @@
-registry=https://pkgs.dev.azure.com/hugendubel/_packaging/hugendubel%40Local/npm/registry/
-
-always-auth=true
-; Treat this auth token like a password. Do not share it with anyone, including Microsoft support. This token expires on or before 25.08.2020.
-; begin auth token
-//pkgs.dev.azure.com/hugendubel/_packaging/hugendubel%40Local/npm/registry/:username=hugendubel
-//pkgs.dev.azure.com/hugendubel/_packaging/hugendubel%40Local/npm/registry/:_password=M2JkaDdwNjIzbWVoZGlmeDU3N2Ficjc3M252NXBkaWg1M2VtaW94dXp5amwyejNkaW5yYQ==
-//pkgs.dev.azure.com/hugendubel/_packaging/hugendubel%40Local/npm/registry/:email=npm requires email to be set but doesn't use the value
-//pkgs.dev.azure.com/hugendubel/_packaging/hugendubel%40Local/npm/:username=hugendubel
-//pkgs.dev.azure.com/hugendubel/_packaging/hugendubel%40Local/npm/:_password=M2JkaDdwNjIzbWVoZGlmeDU3N2Ficjc3M252NXBkaWg1M2VtaW94dXp5amwyejNkaW5yYQ==
-//pkgs.dev.azure.com/hugendubel/_packaging/hugendubel%40Local/npm/:email=npm requires email to be set but doesn't use the value
-; end auth token
-
+@paragondata:registry=https://npm.pkg.github.com

.prettierignore

@@ -0,0 +1,10 @@
+# Add files here to ignore them from prettier formatting
+
+/dist
+/coverage
+/helmvalues
+/apps/swagger
+/ng-swagger-gen
+
+*.json
+*.yml

.prettierrc.json

@@ -0,0 +1,5 @@
+{
+    "singleQuote": true,
+    "printWidth": 140
+  }
+  

.vscode/extensions.json

@@ -0,0 +1,7 @@
+{
+    "recommendations": [
+        "johnpapa.angular2",
+        "esbenp.prettier-vscode",
+        "angular.ng-template",
+    ]
+}

.vscode/launch.json

@@ -1,22 +1,15 @@
 {
-  // Use IntelliSense to learn about possible attributes.
-  // Hover to view descriptions of existing attributes.
-  // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
-  "version": "0.11.0",
-  "configurations": [
-    {
-      "type": "chrome",
-      "request": "launch",
-      "name": "Launch Chrome",
-      "url": "https://192.168.2.112:4200",
-      "webRoot": "${workspaceFolder}",
-      "sourceMaps": true,
-      "sourceMapPathOverrides": {
-        "/./*": "${webRoot}/*",
-        "/src/*": "${webRoot}/*",
-        "/*": "*",
-        "/./~/*": "${webRoot}/node_modules/*"
-      }
-    }
-  ]
-}
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "type": "chrome",
+            "request": "launch",
+            "name": "ISA-App Chrome",
+            "url": "https://localhost:4200",
+            "webRoot": "${workspaceFolder}",
+        }
+    ]
+}

.vscode/settings.json

@@ -8,5 +8,8 @@
   },
   "[typescript]": {
     "editor.defaultFormatter": "esbenp.prettier-vscode"
-  }
+  },
+  "css.validate": false,
+"less.validate": false,
+"scss.validate": false
 }

Dockerfile

@@ -1,13 +1,29 @@
 #stage 1
-FROM node:10-stretch as node
+FROM node:18 as base
 ARG IS_PRODUCTION=false
+ARG SEMVERSION=1.0.0
+ARG BuildUniqueID
+LABEL build.uniqueid="${BuildUniqueID:-1}"
 WORKDIR /app
 COPY . .
 RUN umask 0022
+RUN npm version ${SEMVERSION}
 RUN npm install --always-auth=false
 RUN if [ "${IS_PRODUCTION}" = "true" ] ; then npm run-script build-prod ; else npm run-script build ; fi
 
-# stage 2
-FROM nginx:alpine
-COPY --from=node /app/dist/sales /usr/share/nginx/html
-COPY --from=node /app/nginx.conf /etc/nginx/conf.d/default.conf
+# stage final
+FROM nginx:alpine as publish
+ARG BuildUniqueID
+LABEL build.uniqueid="${BuildUniqueID:-1}"
+COPY --from=base /app/dist/isa-app /usr/share/nginx/html
+COPY --from=base /app/nginx.conf /etc/nginx/conf.d/default.conf
+
+# stage npm test
+FROM base as test
+ARG BuildUniqueID
+LABEL build.uniqueid="${BuildUniqueID:-1}"
+RUN wget https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb -q -O /tmp/chrome.deb && apt update && apt install -y /tmp/chrome.deb
+# ignore exitcode, sonst gibts keinen container
+RUN npm run ci || true
+ENTRYPOINT [ "/bin/sleep", "60000" ]
+

angular.json

@@ -3,495 +3,162 @@
   "version": 1,
   "newProjectRoot": "apps",
   "projects": {
-    "ui": {
-      "root": "libs/ui",
-      "sourceRoot": "libs/ui",
-      "projectType": "library",
-      "prefix": "lib",
-      "architect": {
-        "build": {
-          "builder": "@angular-devkit/build-ng-packagr:build",
-          "options": {
-            "tsConfig": "libs/ui/tsconfig.lib.json",
-            "project": "libs/ui/ng-package.json"
-          }
-        },
-        "test": {
-          "builder": "@angular-devkit/build-angular:karma",
-          "options": {
-            "main": "libs/ui/src/test.ts",
-            "tsConfig": "libs/ui/tsconfig.spec.json",
-            "karmaConfig": "libs/ui/karma.conf.js"
-          }
-        },
-        "lint": {
-          "builder": "@angular-devkit/build-angular:tslint",
-          "options": {
-            "tsConfig": [
-              "libs/ui/tsconfig.lib.json",
-              "libs/ui/tsconfig.spec.json"
-            ],
-            "exclude": ["**/node_modules/**"]
-          }
-        }
-      }
-    },
-    "sales": {
-      "root": "apps/sales/",
-      "sourceRoot": "apps/sales/src",
+    "isa-app": {
       "projectType": "application",
+      "schematics": {
+        "@schematics/angular:component": {
+          "style": "scss"
+        },
+        "@schematics/angular:application": {
+          "strict": true
+        }
+      },
+      "root": "apps/isa-app",
+      "sourceRoot": "apps/isa-app/src",
       "prefix": "app",
-      "schematics": {},
       "architect": {
         "build": {
           "builder": "@angular-devkit/build-angular:browser",
           "options": {
-            "outputPath": "dist/sales",
-            "index": "apps/sales/src/index.html",
-            "main": "apps/sales/src/main.ts",
-            "polyfills": "apps/sales/src/polyfills.ts",
-            "tsConfig": "apps/sales/tsconfig.app.json",
-            "assets": [
-              "apps/sales/src/favicon.ico",
-              "apps/sales/src/assets",
-              "apps/sales/src/manifest.webmanifest",
-              "apps/sales/src/silent-refresh.html"
+            "allowedCommonJsDependencies": [
+              "lodash",
+              "moment",
+              "jsrsasign",
+              "pdfjs-dist/build/pdf",
+              "pdfjs-dist/web/pdf_viewer",
+              "pdfjs-dist/es5/build/pdf",
+              "pdfjs-dist/es5/web/pdf_viewer"
             ],
-            "styles": ["apps/sales/src/styles.scss"],
-            "stylePreprocessorOptions": {
-              "includePaths": ["apps/sales/src/scss"]
-            },
-            "scripts": []
+            "outputPath": "dist/isa-app",
+            "index": "apps/isa-app/src/index.html",
+            "main": "apps/isa-app/src/main.ts",
+            "polyfills": "apps/isa-app/src/polyfills.ts",
+            "tsConfig": "apps/isa-app/tsconfig.app.json",
+            "inlineStyleLanguage": "scss",
+            "assets": [
+              "apps/isa-app/src/favicon.ico",
+              "apps/isa-app/src/assets",
+              "apps/isa-app/src/config",
+              "apps/isa-app/src/silent-refresh.html",
+              "apps/isa-app/src/manifest.webmanifest",
+              {
+                "glob": "**/*",
+                "input": "node_modules/scandit-web-datacapture-barcode/build/engine",
+                "output": "scandit"
+              }
+            ],
+            "styles": [
+              "apps/isa-app/src/styles.scss"
+            ],
+            "scripts": [],
+            "serviceWorker": true,
+            "ngswConfigPath": "apps/isa-app/ngsw-config.json"
           },
           "configurations": {
             "production": {
+              "budgets": [
+                {
+                  "type": "initial",
+                  "maximumWarning": "2mb",
+                  "maximumError": "5mb"
+                },
+                {
+                  "type": "anyComponentStyle",
+                  "maximumWarning": "25kb"
+                }
+              ],
               "fileReplacements": [
                 {
-                  "replace": "apps/sales/src/environments/environment.ts",
-                  "with": "apps/sales/src/environments/environment.prod.ts"
+                  "replace": "apps/isa-app/src/environments/environment.ts",
+                  "with": "apps/isa-app/src/environments/environment.prod.ts"
                 }
               ],
-              "optimization": true,
-              "outputHashing": "all",
-              "sourceMap": false,
-              "extractCss": true,
-              "namedChunks": false,
-              "aot": true,
-              "extractLicenses": true,
-              "vendorChunk": false,
-              "buildOptimizer": true,
-              "budgets": [
-                {
-                  "type": "initial",
-                  "maximumWarning": "2mb",
-                  "maximumError": "5mb"
-                }
-              ],
-              "serviceWorker": true
+              "outputHashing": "all"
             },
             "development": {
-              "optimization": true,
-              "outputHashing": "all",
-              "sourceMap": false,
-              "extractCss": true,
-              "namedChunks": false,
-              "aot": true,
-              "extractLicenses": true,
-              "vendorChunk": false,
-              "buildOptimizer": true,
-              "budgets": [
-                {
-                  "type": "initial",
-                  "maximumWarning": "2mb",
-                  "maximumError": "5mb"
-                }
-              ],
-              "serviceWorker": true
+              "buildOptimizer": false,
+              "optimization": false,
+              "vendorChunk": true,
+              "extractLicenses": false,
+              "sourceMap": true,
+              "namedChunks": true
             }
-          }
+          },
+          "defaultConfiguration": "production"
         },
         "serve": {
           "builder": "@angular-devkit/build-angular:dev-server",
-          "options": {
-            "browserTarget": "sales:build"
-          },
           "configurations": {
-            "test": {
-              "browserTarget": "sales:build:test"
-            },
-            "integration": {
-              "browserTarget": "sales:build:integration"
-            },
-            "staging": {
-              "browserTarget": "sales:build:staging"
-            },
             "production": {
-              "browserTarget": "sales:build:production"
+              "buildTarget": "isa-app:build:production"
+            },
+            "development": {
+              "buildTarget": "isa-app:build:development"
             }
-          }
+          },
+          "defaultConfiguration": "development"
         },
         "extract-i18n": {
           "builder": "@angular-devkit/build-angular:extract-i18n",
           "options": {
-            "browserTarget": "sales:build"
+            "buildTarget": "isa-app:build"
           }
         },
         "test": {
           "builder": "@angular-devkit/build-angular:karma",
           "options": {
-            "main": "apps/sales/src/test.ts",
-            "polyfills": "apps/sales/src/polyfills.ts",
-            "tsConfig": "apps/sales/tsconfig.spec.json",
-            "karmaConfig": "apps/sales/karma.conf.js",
-            "styles": ["apps/sales/src/styles.scss"],
-            "scripts": [],
+            "tsConfig": "apps/isa-app/tsconfig.spec.json",
+            "karmaConfig": "karma.conf.js",
+            "polyfills": [
+              "zone.js",
+              "zone.js/testing"
+            ],
+            "inlineStyleLanguage": "scss",
             "assets": [
-              "apps/sales/src/favicon.ico",
-              "apps/sales/src/assets",
-              "apps/sales/src/manifest.webmanifest"
-            ]
-          }
-        },
-        "lint": {
-          "builder": "@angular-devkit/build-angular:tslint",
-          "options": {
-            "tsConfig": [
-              "apps/sales/tsconfig.app.json",
-              "apps/sales/tsconfig.spec.json"
+              "apps/isa-app/src/favicon.ico",
+              "apps/isa-app/src/assets",
+              "apps/isa-app/src/manifest.webmanifest"
             ],
-            "exclude": ["**/node_modules/**"]
-          }
-        }
-      }
-    },
-    "sales-e2e": {
-      "root": "apps/sales-e2e/",
-      "projectType": "application",
-      "prefix": "",
-      "architect": {
-        "e2e": {
-          "builder": "@angular-devkit/build-angular:protractor",
-          "options": {
-            "protractorConfig": "apps/sales-e2e/protractor.conf.js",
-            "devServerTarget": "sales:serve"
-          },
-          "configurations": {
-            "integration": {
-              "devServerTarget": "sales:serve:integration"
-            },
-            "production": {
-              "devServerTarget": "sales:serve:production"
-            }
-          }
-        },
-        "lint": {
-          "builder": "@angular-devkit/build-angular:tslint",
-          "options": {
-            "tsConfig": "apps/sales-e2e/tsconfig.e2e.json",
-            "exclude": ["**/node_modules/**"]
-          }
-        }
-      }
-    },
-    "sso": {
-      "root": "libs/sso",
-      "sourceRoot": "libs/sso/src",
-      "projectType": "library",
-      "prefix": "lib",
-      "architect": {
-        "build": {
-          "builder": "@angular-devkit/build-ng-packagr:build",
-          "options": {
-            "tsConfig": "libs/sso/tsconfig.lib.json",
-            "project": "libs/sso/ng-package.json"
-          }
-        },
-        "test": {
-          "builder": "@angular-devkit/build-angular:karma",
-          "options": {
-            "main": "libs/sso/src/test.ts",
-            "tsConfig": "libs/sso/tsconfig.spec.json",
-            "karmaConfig": "libs/sso/karma.conf.js"
-          }
-        },
-        "lint": {
-          "builder": "@angular-devkit/build-angular:tslint",
-          "options": {
-            "tsConfig": [
-              "libs/sso/tsconfig.lib.json",
-              "libs/sso/tsconfig.spec.json"
+            "styles": [
+              "apps/isa-app/src/styles.scss"
             ],
-            "exclude": ["**/node_modules/**"]
-          }
-        }
-      }
-    },
-    "@swagger/availability": {
-      "root": "apps/swagger/availability",
-      "sourceRoot": "apps/swagger/availability/src",
-      "projectType": "library",
-      "prefix": "lib",
-      "architect": {
-        "build": {
-          "builder": "@angular-devkit/build-ng-packagr:build",
-          "options": {
-            "tsConfig": "apps/swagger/availability/tsconfig.lib.json",
-            "project": "apps/swagger/availability/ng-package.json"
+            "scripts": []
           }
         },
-        "test": {
-          "builder": "@angular-devkit/build-angular:karma",
+        "storybook": {
+          "builder": "@storybook/angular:start-storybook",
           "options": {
-            "main": "apps/swagger/availability/src/test.ts",
-            "tsConfig": "apps/swagger/availability/tsconfig.spec.json",
-            "karmaConfig": "apps/swagger/availability/karma.conf.js"
-          }
-        },
-        "lint": {
-          "builder": "@angular-devkit/build-angular:tslint",
-          "options": {
-            "tsConfig": [
-              "apps/swagger/availability/tsconfig.lib.json",
-              "apps/swagger/availability/tsconfig.spec.json"
+            "configDir": "apps/isa-app/.storybook",
+            "browserTarget": "isa-app:build",
+            "compodoc": true,
+            "compodocArgs": [
+              "-e",
+              "json",
+              "-d",
+              "apps/isa-app"
             ],
-            "exclude": ["**/node_modules/**"]
-          }
-        }
-      }
-    },
-    "@swagger/checkout": {
-      "root": "apps/swagger/checkout",
-      "sourceRoot": "apps/swagger/checkout/src",
-      "projectType": "library",
-      "prefix": "lib",
-      "architect": {
-        "build": {
-          "builder": "@angular-devkit/build-ng-packagr:build",
-          "options": {
-            "tsConfig": "apps/swagger/checkout/tsconfig.lib.json",
-            "project": "apps/swagger/checkout/ng-package.json"
+            "port": 6006
           }
         },
-        "test": {
-          "builder": "@angular-devkit/build-angular:karma",
+        "build-storybook": {
+          "builder": "@storybook/angular:build-storybook",
           "options": {
-            "main": "apps/swagger/checkout/src/test.ts",
-            "tsConfig": "apps/swagger/checkout/tsconfig.spec.json",
-            "karmaConfig": "apps/swagger/checkout/karma.conf.js"
-          }
-        },
-        "lint": {
-          "builder": "@angular-devkit/build-angular:tslint",
-          "options": {
-            "tsConfig": [
-              "apps/swagger/checkout/tsconfig.lib.json",
-              "apps/swagger/checkout/tsconfig.spec.json"
+            "configDir": "apps/isa-app/.storybook",
+            "browserTarget": "isa-app:build",
+            "compodoc": true,
+            "compodocArgs": [
+              "-e",
+              "json",
+              "-d",
+              "apps/isa-app"
             ],
-            "exclude": ["**/node_modules/**"]
-          }
-        }
-      }
-    },
-    "@swagger/crm": {
-      "root": "apps/swagger/crm",
-      "sourceRoot": "apps/swagger/crm/src",
-      "projectType": "library",
-      "prefix": "lib",
-      "architect": {
-        "build": {
-          "builder": "@angular-devkit/build-ng-packagr:build",
-          "options": {
-            "tsConfig": "apps/swagger/crm/tsconfig.lib.json",
-            "project": "apps/swagger/crm/ng-package.json"
-          }
-        },
-        "test": {
-          "builder": "@angular-devkit/build-angular:karma",
-          "options": {
-            "main": "apps/swagger/crm/src/test.ts",
-            "tsConfig": "apps/swagger/crm/tsconfig.spec.json",
-            "karmaConfig": "apps/swagger/crm/karma.conf.js"
-          }
-        },
-        "lint": {
-          "builder": "@angular-devkit/build-angular:tslint",
-          "options": {
-            "tsConfig": [
-              "apps/swagger/crm/tsconfig.lib.json",
-              "apps/swagger/crm/tsconfig.spec.json"
-            ],
-            "exclude": ["**/node_modules/**"]
-          }
-        }
-      }
-    },
-    "@swagger/isa": {
-      "root": "apps/swagger/isa",
-      "sourceRoot": "apps/swagger/isa/src",
-      "projectType": "library",
-      "prefix": "lib",
-      "architect": {
-        "build": {
-          "builder": "@angular-devkit/build-ng-packagr:build",
-          "options": {
-            "tsConfig": "apps/swagger/isa/tsconfig.lib.json",
-            "project": "apps/swagger/isa/ng-package.json"
-          }
-        },
-        "test": {
-          "builder": "@angular-devkit/build-angular:karma",
-          "options": {
-            "main": "apps/swagger/isa/src/test.ts",
-            "tsConfig": "apps/swagger/isa/tsconfig.spec.json",
-            "karmaConfig": "apps/swagger/isa/karma.conf.js"
-          }
-        },
-        "lint": {
-          "builder": "@angular-devkit/build-angular:tslint",
-          "options": {
-            "tsConfig": [
-              "apps/swagger/isa/tsconfig.lib.json",
-              "apps/swagger/isa/tsconfig.spec.json"
-            ],
-            "exclude": ["**/node_modules/**"]
-          }
-        }
-      }
-    },
-    "@swagger/oms": {
-      "root": "apps/swagger/oms",
-      "sourceRoot": "apps/swagger/oms/src",
-      "projectType": "library",
-      "prefix": "lib",
-      "architect": {
-        "build": {
-          "builder": "@angular-devkit/build-ng-packagr:build",
-          "options": {
-            "tsConfig": "apps/swagger/oms/tsconfig.lib.json",
-            "project": "apps/swagger/oms/ng-package.json"
-          }
-        },
-        "test": {
-          "builder": "@angular-devkit/build-angular:karma",
-          "options": {
-            "main": "apps/swagger/oms/src/test.ts",
-            "tsConfig": "apps/swagger/oms/tsconfig.spec.json",
-            "karmaConfig": "apps/swagger/oms/karma.conf.js"
-          }
-        },
-        "lint": {
-          "builder": "@angular-devkit/build-angular:tslint",
-          "options": {
-            "tsConfig": [
-              "apps/swagger/oms/tsconfig.lib.json",
-              "apps/swagger/oms/tsconfig.spec.json"
-            ],
-            "exclude": ["**/node_modules/**"]
-          }
-        }
-      }
-    },
-    "@swagger/print": {
-      "root": "apps/swagger/print",
-      "sourceRoot": "apps/swagger/print/src",
-      "projectType": "library",
-      "prefix": "lib",
-      "architect": {
-        "build": {
-          "builder": "@angular-devkit/build-ng-packagr:build",
-          "options": {
-            "tsConfig": "apps/swagger/print/tsconfig.lib.json",
-            "project": "apps/swagger/print/ng-package.json"
-          }
-        },
-        "test": {
-          "builder": "@angular-devkit/build-angular:karma",
-          "options": {
-            "main": "apps/swagger/print/src/test.ts",
-            "tsConfig": "apps/swagger/print/tsconfig.spec.json",
-            "karmaConfig": "apps/swagger/print/karma.conf.js"
-          }
-        },
-        "lint": {
-          "builder": "@angular-devkit/build-angular:tslint",
-          "options": {
-            "tsConfig": [
-              "apps/swagger/print/tsconfig.lib.json",
-              "apps/swagger/print/tsconfig.spec.json"
-            ],
-            "exclude": ["**/node_modules/**"]
-          }
-        }
-      }
-    },
-    "@swagger/cat": {
-      "root": "apps/swagger/cat",
-      "sourceRoot": "apps/swagger/cat/src",
-      "projectType": "library",
-      "prefix": "lib",
-      "architect": {
-        "build": {
-          "builder": "@angular-devkit/build-ng-packagr:build",
-          "options": {
-            "tsConfig": "apps/swagger/cat/tsconfig.lib.json",
-            "project": "apps/swagger/cat/ng-package.json"
-          }
-        },
-        "test": {
-          "builder": "@angular-devkit/build-angular:karma",
-          "options": {
-            "main": "apps/swagger/cat/src/test.ts",
-            "tsConfig": "apps/swagger/cat/tsconfig.spec.json",
-            "karmaConfig": "apps/swagger/cat/karma.conf.js"
-          }
-        },
-        "lint": {
-          "builder": "@angular-devkit/build-angular:tslint",
-          "options": {
-            "tsConfig": [
-              "apps/swagger/cat/tsconfig.lib.json",
-              "apps/swagger/cat/tsconfig.spec.json"
-            ],
-            "exclude": ["**/node_modules/**"]
-          }
-        }
-      }
-    },
-    "native-container": {
-      "projectType": "library",
-      "root": "apps/native-container",
-      "sourceRoot": "apps/native-container/src",
-      "prefix": "lib",
-      "architect": {
-        "build": {
-          "builder": "@angular-devkit/build-ng-packagr:build",
-          "options": {
-            "tsConfig": "apps/native-container/tsconfig.lib.json",
-            "project": "apps/native-container/ng-package.json"
-          }
-        },
-        "test": {
-          "builder": "@angular-devkit/build-angular:karma",
-          "options": {
-            "main": "apps/native-container/src/test.ts",
-            "tsConfig": "apps/native-container/tsconfig.spec.json",
-            "karmaConfig": "apps/native-container/karma.conf.js"
-          }
-        },
-        "lint": {
-          "builder": "@angular-devkit/build-angular:tslint",
-          "options": {
-            "tsConfig": [
-              "apps/native-container/tsconfig.lib.json",
-              "apps/native-container/tsconfig.spec.json"
-            ],
-            "exclude": [
-              "**/node_modules/**"
-            ]
+            "outputDir": "storybook-static"
           }
         }
       }
     }
   },
-  "defaultProject": "sales"
-}
+  "cli": {
+    "analytics": false
+  }
+}

apps/isa-app/.storybook/main.ts

@@ -0,0 +1,17 @@
+import type { StorybookConfig } from '@storybook/angular';
+
+const config: StorybookConfig = {
+  stories: ['../src/**/*.mdx', '../src/**/*.stories.@(js|jsx|mjs|ts|tsx)'],
+  addons: [
+    '@storybook/addon-onboarding',
+    '@storybook/addon-links',
+    '@storybook/addon-essentials',
+    '@chromatic-com/storybook',
+    '@storybook/addon-interactions',
+  ],
+  framework: {
+    name: '@storybook/angular',
+    options: {},
+  },
+};
+export default config;

apps/isa-app/.storybook/preview.ts

@@ -0,0 +1,17 @@
+import type { Preview } from '@storybook/angular';
+import { setCompodocJson } from '@storybook/addon-docs/angular';
+import docJson from '../documentation.json';
+setCompodocJson(docJson);
+
+const preview: Preview = {
+  parameters: {
+    controls: {
+      matchers: {
+        color: /(background|color)$/i,
+        date: /Date$/i,
+      },
+    },
+  },
+};
+
+export default preview;

apps/isa-app/.storybook/tsconfig.doc.json

@@ -0,0 +1,10 @@
+// This tsconfig is used by Compodoc to generate the documentation for the project.
+// If Compodoc is not used, this file can be deleted.
+{
+  "extends": "./tsconfig.json",
+  // Exclude all files that are not needed for documentation generation.
+  "exclude": ["../src/test.ts", "../src/**/*.spec.ts", "../src/**/*.stories.ts"],
+  // Please make sure to include all files from which Compodoc should generate documentation.
+  "include": ["../src/**/*"],
+  "files": ["./typings.d.ts"]
+}

apps/isa-app/.storybook/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../tsconfig.app.json",
+  "compilerOptions": {
+    "types": ["node"],
+    "allowSyntheticDefaultImports": true,
+    "resolveJsonModule": true
+  },
+  "exclude": ["../src/test.ts", "../src/**/*.spec.ts"],
+  "include": ["../src/**/*.stories.*", "./preview.ts", "../src/polyfills.ts"],
+  "files": ["./typings.d.ts"]
+}

apps/isa-app/.storybook/typings.d.ts

@@ -0,0 +1,4 @@
+declare module '*.md' {
+  const content: string;
+  export default content;
+}

apps/isa-app/ngsw-config.json

@@ -0,0 +1,32 @@
+{
+  "$schema": "../../node_modules/@angular/service-worker/config/schema.json",
+  "index": "/index.html",
+  "navigationRequestStrategy": "freshness",
+  "assetGroups": [
+    {
+      "name": "app",
+      "installMode": "prefetch",
+      "resources": {
+        "files": [
+          "/favicon.ico",
+          "/index.html",
+          "/manifest.webmanifest",
+          "/*.css",
+          "/*.js",
+          "/*.json"
+        ]
+      }
+    },
+    {
+      "name": "assets",
+      "installMode": "lazy",
+      "updateMode": "prefetch",
+      "resources": {
+        "files": [
+          "/assets/**",
+          "/*.(svg|cur|jpg|jpeg|png|apng|webp|avif|gif|otf|ttf|woff|woff2)"
+        ]
+      }
+    }
+  ]
+}

apps/isa-app/src/adapter/scan/dev.scan-adapter.ts

@@ -0,0 +1,44 @@
+import { inject, Injectable } from '@angular/core';
+import { EnvironmentService } from '@core/environment';
+import { PromptModalData, UiModalService, UiPromptModalComponent } from '@ui/modal';
+import { Observable } from 'rxjs';
+import { ScanAdapter } from './scan-adapter';
+
+@Injectable()
+export class DevScanAdapter implements ScanAdapter {
+  readonly name = 'Dev';
+
+  private _modal = inject(UiModalService);
+
+  async init(): Promise<boolean> {
+    return Promise.resolve(false);
+    // return new Promise((resolve, reject) => {
+    //   resolve(isDevMode());
+    // });
+  }
+
+  scan(): Observable<string> {
+    return new Observable((observer) => {
+      const modalRef = this._modal.open({
+        content: UiPromptModalComponent,
+        title: 'Scannen',
+        data: {
+          message: 'Diese Eingabemaske dient nur zu Entwicklungs und Testzwecken.',
+          placeholder: 'Scan Code',
+          confirmText: 'weiter',
+          cancelText: 'abbrechen',
+        } as PromptModalData,
+      });
+
+      const sub = modalRef.afterClosed$.subscribe((result) => {
+        observer.next(result.data);
+        observer.complete();
+      });
+
+      return () => {
+        modalRef.close();
+        sub.unsubscribe();
+      };
+    });
+  }
+}

apps/isa-app/src/adapter/scan/dummy.spec.ts

@@ -0,0 +1,5 @@
+describe('Dummy', () => {
+  it('should work', () => {
+    expect(true).toBeTruthy();
+  });
+});

apps/isa-app/src/adapter/scan/index.ts

@@ -0,0 +1,7 @@
+export * from './dev.scan-adapter';
+export * from './native.scan-adapter';
+export * from './scan-adapter';
+export * from './scan.module';
+export * from './scan.service';
+export * from './scandit';
+export * from './tokens';

apps/isa-app/src/adapter/scan/native.scan-adapter.ts

@@ -0,0 +1,30 @@
+import { Injectable } from '@angular/core';
+import { NativeContainerService } from '@external/native-container';
+import { Observable } from 'rxjs';
+import { filter, map, take } from 'rxjs/operators';
+import { ScanAdapter } from './scan-adapter';
+
+/**
+ * @deprecated This service will be removed in future versions.
+ * Please use the new ScanService instead.
+ */
+@Injectable()
+export class NativeScanAdapter implements ScanAdapter {
+  readonly name = 'Native';
+
+  constructor(private readonly nativeContainerService: NativeContainerService) {}
+
+  init(): Promise<boolean> {
+    return new Promise((resolve, reject) => {
+      resolve(this.nativeContainerService.isNative);
+    });
+  }
+
+  scan(): Observable<string> {
+    return this.nativeContainerService.openScanner('scanBook').pipe(
+      filter((result) => result.status === 'SUCCESS'),
+      map((result) => result.data),
+      take(1),
+    );
+  }
+}

apps/isa-app/src/adapter/scan/scan-adapter.ts

@@ -0,0 +1,18 @@
+import { Observable } from 'rxjs';
+
+export interface ScanAdapter {
+  /**
+   * Name to identify the adapter
+   */
+  readonly name: string;
+
+  /**
+   * @returns true if this adapter can be used
+   */
+  init(): Promise<boolean>;
+
+  /**
+   * scan for a barcode
+   */
+  scan(): Observable<string>;
+}

apps/isa-app/src/adapter/scan/scan.module.ts

@@ -0,0 +1,19 @@
+import { NgModule } from '@angular/core';
+import { DevScanAdapter } from './dev.scan-adapter';
+import { NativeScanAdapter } from './native.scan-adapter';
+import { SCAN_ADAPTER } from './tokens';
+
+@NgModule({})
+export class ScanAdapterModule {
+  static forRoot() {
+    return {
+      ngModule: ScanAdapterModule,
+      providers: [
+        { provide: SCAN_ADAPTER, useClass: NativeScanAdapter, multi: true },
+        { provide: SCAN_ADAPTER, useClass: DevScanAdapter, multi: true },
+      ],
+      // Use for testing:
+      // providers: [{ provide: SCAN_ADAPTER, useClass: dev ? DevScanAdapter : NativeScanAdapter, multi: true }],
+    };
+  }
+}

apps/isa-app/src/adapter/scan/scan.service.ts

@@ -0,0 +1,52 @@
+import { Inject, Injectable } from '@angular/core';
+import { Observable, throwError } from 'rxjs';
+import { ScanAdapter } from './scan-adapter';
+import { SCAN_ADAPTER } from './tokens';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class ScanAdapterService {
+  private _readyAdapters: Record<string, boolean> = {};
+
+  constructor(@Inject(SCAN_ADAPTER) private readonly scanAdapters: ScanAdapter[]) {}
+
+  async init(): Promise<void> {
+    for (const adapter of this.scanAdapters) {
+      const isReady = await adapter.init();
+      this._readyAdapters[adapter.name] = isReady;
+    }
+  }
+
+  adapters(): ScanAdapter[] {
+    return [...this.scanAdapters];
+  }
+
+  getAdapter(name: string): ScanAdapter | undefined {
+    return this._readyAdapters[name] && this.scanAdapters.find((adapter) => adapter.name === name);
+  }
+
+  isReady(): boolean {
+    return Object.values(this._readyAdapters).some((ready) => ready);
+  }
+
+  scan(): Observable<string> {
+    const adapterOrder = ['Native', 'Scandit', 'Dev'];
+
+    let adapter: ScanAdapter;
+
+    for (const name of adapterOrder) {
+      adapter = this.getAdapter(name);
+
+      if (adapter) {
+        break;
+      }
+    }
+
+    if (!adapter) {
+      return throwError('No adapter found');
+    }
+
+    return adapter.scan();
+  }
+}

apps/isa-app/src/adapter/scan/scandit/index.ts

@@ -0,0 +1,3 @@
+export * from './scandit-overlay.component';
+export * from './scandit-scan-adapter.module';
+export * from './scandit.scan-adapter';

apps/isa-app/src/adapter/scan/scandit/scandit-overlay.component.css

@@ -0,0 +1,22 @@
+:host {
+  @apply block relative;
+}
+
+.scanner-container {
+  /* width: 100vw;
+  height: 100vh;
+  max-width: 100vh;
+  max-height: 100vh; */
+}
+
+.close-scanner {
+  @apply absolute bottom-12 left-[50%] -translate-x-[50%] block px-6 py-4 bg-white text-brand border-2 border-solid border-brand rounded-full text-lg font-bold mx-auto mt-4;
+  @apply whitespace-nowrap;
+}
+
+@screen desktop {
+  .scanner-container {
+    max-width: 900px;
+    max-height: 900px;
+  }
+}

apps/isa-app/src/adapter/scan/scandit/scandit-overlay.component.html

@@ -0,0 +1,2 @@
+<div class="scanner-container" #scanContainer></div>
+<button class="close-scanner" type="button" (click)="close()">Scan abbrechen</button>

apps/isa-app/src/adapter/scan/scandit/scandit-overlay.component.ts

@@ -0,0 +1,95 @@
+import { Component, ChangeDetectionStrategy, ElementRef, ViewChild, NgZone, AfterViewInit, OnDestroy, OnInit } from '@angular/core';
+import { BarcodeCapture, BarcodeCaptureSettings, Symbology } from 'scandit-web-datacapture-barcode';
+import { Camera, DataCaptureContext, DataCaptureView, FrameSourceState } from 'scandit-web-datacapture-core';
+
+@Component({
+  selector: 'app-scandit-overlay',
+  templateUrl: 'scandit-overlay.component.html',
+  styleUrls: ['scandit-overlay.component.css'],
+  changeDetection: ChangeDetectionStrategy.OnPush,
+})
+export class ScanditOverlayComponent implements OnInit, AfterViewInit, OnDestroy {
+  private dataCaptureContext: DataCaptureContext;
+  private dataCaptureView: DataCaptureView;
+  private barcodeCapture: BarcodeCapture;
+  private camera: Camera;
+
+  private _onScan?: (code: string) => void;
+
+  private _onClose?: () => void;
+
+  @ViewChild('scanContainer', { read: ElementRef, static: true }) scanContainer: ElementRef;
+
+  constructor(private _zone: NgZone) {}
+
+  ngOnInit(): void {
+    this.dataCaptureView = new DataCaptureView();
+
+    this.dataCaptureView.connectToElement(this.scanContainer.nativeElement);
+
+    this.dataCaptureView.showProgressBar();
+  }
+
+  async ngAfterViewInit() {
+    this.dataCaptureContext = await DataCaptureContext.create();
+
+    this.dataCaptureView.setContext(this.dataCaptureContext);
+
+    this.barcodeCapture = await BarcodeCapture.forContext(this.dataCaptureContext, this.getScanSettings());
+
+    this.barcodeCapture.addListener({
+      didScan: (_, session, __) => {
+        this._zone.run(() => {
+          const result = session.newlyRecognizedBarcode;
+
+          const code = result?.data ?? '';
+
+          this._onScan?.(code);
+        });
+      },
+    });
+
+    this.camera = Camera.default;
+
+    this.dataCaptureContext.setFrameSource(this.camera);
+
+    await this.camera.switchToDesiredState(FrameSourceState.On);
+    this.dataCaptureView.hideProgressBar();
+  }
+
+  getScanSettings(): BarcodeCaptureSettings {
+    const settings = new BarcodeCaptureSettings();
+
+    settings.enableSymbologies([
+      Symbology.EAN8,
+      Symbology.EAN13UPCA,
+      Symbology.UPCE,
+      Symbology.Code128,
+      Symbology.Code39,
+      Symbology.Code93,
+      Symbology.InterleavedTwoOfFive,
+      Symbology.QR,
+    ]);
+
+    return settings;
+  }
+
+  onScan(fn: (code: string) => void) {
+    this._onScan = fn;
+  }
+
+  onClose(fn: () => void) {
+    this._onClose = fn;
+  }
+
+  close() {
+    this._onClose?.();
+  }
+
+  ngOnDestroy(): void {
+    this._zone.runOutsideAngular(() => {
+      this.barcodeCapture?.setEnabled(false);
+      this.camera?.switchToDesiredState(FrameSourceState.Off);
+    });
+  }
+}

apps/isa-app/src/adapter/scan/scandit/scandit-scan-adapter.module.ts

@@ -0,0 +1,20 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+
+import { ScanditOverlayComponent } from './scandit-overlay.component';
+import { ScanditScanAdapter } from './scandit.scan-adapter';
+import { SCAN_ADAPTER } from '../tokens';
+
+@NgModule({
+  imports: [CommonModule],
+  exports: [ScanditOverlayComponent],
+  declarations: [ScanditOverlayComponent],
+})
+export class ScanditScanAdapterModule {
+  static forRoot() {
+    return {
+      ngModule: ScanditScanAdapterModule,
+      providers: [{ provide: SCAN_ADAPTER, useClass: ScanditScanAdapter, multi: true }],
+    };
+  }
+}

apps/isa-app/src/adapter/scan/scandit/scandit.scan-adapter.ts

@@ -0,0 +1,103 @@
+import { Injectable } from '@angular/core';
+import { Observable, Subscriber } from 'rxjs';
+import { ScanAdapter } from '../scan-adapter';
+import { Overlay } from '@angular/cdk/overlay';
+
+import { configure } from 'scandit-web-datacapture-core';
+import { barcodeCaptureLoader } from 'scandit-web-datacapture-barcode';
+
+// import { ScanditModalComponent } from './scandit-modal';
+import { Config } from '@core/config';
+import { ComponentPortal } from '@angular/cdk/portal';
+import { ScanditOverlayComponent } from './scandit-overlay.component';
+import { EnvironmentService } from '@core/environment';
+import { injectNetworkStatus$ } from 'apps/isa-app/src/app/services/network-status.service';
+import { toSignal } from '@angular/core/rxjs-interop';
+
+@Injectable()
+export class ScanditScanAdapter implements ScanAdapter {
+  readonly name = 'Scandit';
+
+  private $networkStatus = toSignal(injectNetworkStatus$());
+
+  constructor(
+    private readonly _config: Config,
+    private _overlay: Overlay,
+    private _environmentService: EnvironmentService,
+  ) {}
+
+  async init(): Promise<boolean> {
+    if (this._environmentService.isTablet()) {
+      try {
+        await configure({
+          licenseKey: this._config.get('licence.scandit'),
+          libraryLocation: new URL('scandit', document.baseURI).toString(),
+          moduleLoaders: [barcodeCaptureLoader()],
+        });
+
+        return true;
+      } catch (error) {
+        console.error('ScanditScanAdapter.init', error);
+      }
+    }
+
+    return false;
+  }
+
+  scan(): Observable<string> {
+    return new Observable((observer) => {
+      if (this.$networkStatus() === 'offline') {
+        observer.error(new Error('No network connection'));
+        return;
+      }
+
+      const overlay = this.createOverlay();
+
+      const portal = this.createPortal();
+
+      const ref = overlay.attach(portal);
+
+      const sub = new Subscriber();
+
+      const complete = () => {
+        overlay.detach();
+        ref.destroy();
+        sub.unsubscribe();
+        sub.complete();
+        observer.complete();
+      };
+
+      sub.add(
+        overlay.backdropClick().subscribe(() => {
+          complete();
+        }),
+      );
+
+      ref.instance.onScan((code) => {
+        observer.next(code);
+        complete();
+      });
+
+      ref.instance.onClose(() => {
+        complete();
+      });
+
+      return complete;
+    });
+  }
+
+  createOverlay() {
+    const overlay = this._overlay.create({
+      positionStrategy: this._overlay.position().global().centerHorizontally().centerVertically(),
+      hasBackdrop: true,
+    });
+
+    return overlay;
+  }
+
+  createPortal() {
+    const portal = new ComponentPortal(ScanditOverlayComponent);
+
+    return portal;
+  }
+}

apps/isa-app/src/adapter/scan/tokens.ts

@@ -0,0 +1,4 @@
+import { InjectionToken } from '@angular/core';
+import { ScanAdapter } from './scan-adapter';
+
+export const SCAN_ADAPTER = new InjectionToken<ScanAdapter>('SCAN_ADAPTER');

apps/isa-app/src/app/app-domain.module.ts

@@ -0,0 +1,19 @@
+import { NgModule } from '@angular/core';
+import { DomainAvailabilityModule } from '@domain/availability';
+import { DomainCatalogModule } from '@domain/catalog';
+import { DomainIsaModule } from '@domain/isa';
+import { DomainCheckoutModule } from '@domain/checkout';
+import { DomainOmsModule } from '@domain/oms';
+import { DomainRemissionModule } from '@domain/remission';
+
+@NgModule({
+  imports: [
+    DomainIsaModule.forRoot(),
+    DomainCatalogModule.forRoot(),
+    DomainAvailabilityModule.forRoot(),
+    DomainCheckoutModule.forRoot(),
+    DomainOmsModule.forRoot(),
+    DomainRemissionModule.forRoot(),
+  ],
+})
+export class AppDomainModule {}

apps/isa-app/src/app/app-routing.module.ts

@@ -0,0 +1,159 @@
+import { isDevMode, NgModule } from '@angular/core';
+import { RouterModule, Routes } from '@angular/router';
+import {
+  CanActivateCartGuard,
+  CanActivateCartWithProcessIdGuard,
+  CanActivateCustomerGuard,
+  CanActivateCustomerOrdersGuard,
+  CanActivateCustomerOrdersWithProcessIdGuard,
+  CanActivateCustomerWithProcessIdGuard,
+  CanActivateGoodsInGuard,
+  CanActivateProductGuard,
+  CanActivateProductWithProcessIdGuard,
+  CanActivateRemissionGuard,
+  CanActivateTaskCalendarGuard,
+  IsAuthenticatedGuard,
+} from './guards';
+import { CanActivateAssortmentGuard } from './guards/can-activate-assortment.guard';
+import { CanActivatePackageInspectionGuard } from './guards/can-activate-package-inspection.guard';
+import { MainComponent } from './main.component';
+import { PreviewComponent } from './preview';
+import { BranchSectionResolver, CustomerSectionResolver, ProcessIdResolver } from './resolvers';
+import { TokenLoginComponent, TokenLoginModule } from './token-login';
+import { ProcessIdGuard } from './guards/process-id.guard';
+import { ActivateProcessIdGuard, ActivateProcessIdWithConfigKeyGuard } from './guards/activate-process-id.guard';
+
+const routes: Routes = [
+  {
+    path: 'login',
+    children: [
+      { path: ':token', component: TokenLoginComponent },
+      { path: '**', redirectTo: 'kunde', pathMatch: 'full' },
+    ],
+  },
+  {
+    path: '',
+    canActivate: [IsAuthenticatedGuard],
+    children: [
+      {
+        path: 'kunde',
+        component: MainComponent,
+        children: [
+          {
+            path: 'dashboard',
+            loadChildren: () => import('@page/dashboard').then((m) => m.DashboardModule),
+          },
+          {
+            path: 'product',
+            loadChildren: () => import('@page/catalog').then((m) => m.PageCatalogModule),
+            canActivate: [CanActivateProductGuard],
+          },
+          {
+            path: ':processId/product',
+            loadChildren: () => import('@page/catalog').then((m) => m.PageCatalogModule),
+            canActivate: [CanActivateProductWithProcessIdGuard],
+            resolve: { processId: ProcessIdResolver },
+          },
+          {
+            path: 'order',
+            loadChildren: () => import('@page/customer-order').then((m) => m.CustomerOrderModule),
+            canActivate: [CanActivateCustomerOrdersGuard],
+          },
+          {
+            path: ':processId/order',
+            loadChildren: () => import('@page/customer-order').then((m) => m.CustomerOrderModule),
+            canActivate: [CanActivateCustomerOrdersWithProcessIdGuard],
+            resolve: { processId: ProcessIdResolver },
+          },
+          {
+            path: 'customer',
+            loadChildren: () => import('@page/customer').then((m) => m.CustomerModule),
+            canActivate: [CanActivateCustomerGuard],
+          },
+          {
+            path: ':processId/customer',
+            loadChildren: () => import('@page/customer').then((m) => m.CustomerModule),
+            canActivate: [CanActivateCustomerWithProcessIdGuard],
+            resolve: { processId: ProcessIdResolver },
+          },
+          {
+            path: 'cart',
+            loadChildren: () => import('@page/checkout').then((m) => m.PageCheckoutModule),
+            canActivate: [CanActivateCartGuard],
+          },
+          {
+            path: ':processId/cart',
+            loadChildren: () => import('@page/checkout').then((m) => m.PageCheckoutModule),
+            canActivate: [CanActivateCartWithProcessIdGuard],
+          },
+          {
+            path: 'pickup-shelf',
+            canActivate: [ProcessIdGuard],
+            // NOTE: This is a workaround for the canActivate guard not being called
+            loadChildren: () => import('@page/pickup-shelf').then((m) => m.PickupShelfOutModule),
+          },
+          {
+            path: ':processId/pickup-shelf',
+            canActivate: [ActivateProcessIdGuard],
+            loadChildren: () => import('@page/pickup-shelf').then((m) => m.PickupShelfOutModule),
+          },
+          { path: '**', redirectTo: 'dashboard', pathMatch: 'full' },
+        ],
+        resolve: { section: CustomerSectionResolver },
+      },
+      {
+        path: 'filiale',
+        component: MainComponent,
+        children: [
+          {
+            path: 'task-calendar',
+            loadChildren: () => import('@page/task-calendar').then((m) => m.PageTaskCalendarModule),
+            canActivate: [CanActivateTaskCalendarGuard],
+          },
+          {
+            path: 'pickup-shelf',
+            canActivate: [ActivateProcessIdWithConfigKeyGuard('pickupShelf')],
+            // NOTE: This is a workaround for the canActivate guard not being called
+            loadChildren: () => import('@page/pickup-shelf').then((m) => m.PickupShelfInModule),
+          },
+          {
+            path: 'goods/in',
+            loadChildren: () => import('@page/goods-in').then((m) => m.GoodsInModule),
+            canActivate: [CanActivateGoodsInGuard],
+          },
+          {
+            path: 'remission',
+            loadChildren: () => import('@page/remission').then((m) => m.PageRemissionModule),
+            canActivate: [CanActivateRemissionGuard],
+          },
+          {
+            path: 'package-inspection',
+            loadChildren: () => import('@page/package-inspection').then((m) => m.PackageInspectionModule),
+            canActivate: [CanActivatePackageInspectionGuard],
+          },
+          {
+            path: 'assortment',
+            loadChildren: () => import('@page/assortment').then((m) => m.AssortmentModule),
+            canActivate: [CanActivateAssortmentGuard],
+          },
+          { path: '**', redirectTo: 'task-calendar', pathMatch: 'full' },
+        ],
+        resolve: { section: BranchSectionResolver },
+      },
+      { path: '**', redirectTo: 'kunde', pathMatch: 'full' },
+    ],
+  },
+];
+
+if (isDevMode()) {
+  routes.unshift({
+    path: 'preview',
+    component: PreviewComponent,
+  });
+}
+
+@NgModule({
+  imports: [RouterModule.forRoot(routes), TokenLoginModule],
+  exports: [RouterModule],
+})
+export class AppRoutingModule {}

apps/isa-app/src/app/app-store.module.ts

@@ -0,0 +1,34 @@
+import { NgModule } from '@angular/core';
+import { EffectsModule } from '@ngrx/effects';
+import { ActionReducer, MetaReducer, StoreModule } from '@ngrx/store';
+import { StoreDevtoolsModule } from '@ngrx/store-devtools';
+import { storeFreeze } from 'ngrx-store-freeze';
+import packageInfo from 'packageJson';
+import { environment } from '../environments/environment';
+import { RootStateService } from './store/root-state.service';
+import { rootReducer } from './store/root.reducer';
+import { RootState } from './store/root.state';
+
+export function storeInLocalStorage(reducer: ActionReducer<any>): ActionReducer<any> {
+  return function (state, action) {
+    if (action.type === 'HYDRATE') {
+      const initialState = RootStateService.LoadFromLocalStorage();
+
+      if (initialState?.version === packageInfo.version) {
+        return reducer(initialState, action);
+      }
+    }
+    return reducer(state, action);
+  };
+}
+
+export const metaReducers: MetaReducer<RootState>[] = !environment.production ? [storeFreeze, storeInLocalStorage] : [storeInLocalStorage];
+
+@NgModule({
+  imports: [
+    StoreModule.forRoot(rootReducer, { metaReducers }),
+    EffectsModule.forRoot([]),
+    StoreDevtoolsModule.instrument({ name: 'ISA Ngrx Application Store', connectInZone: true }),
+  ],
+})
+export class AppStoreModule {}

apps/isa-app/src/app/app-swagger.module.ts

@@ -0,0 +1,34 @@
+import { NgModule } from '@angular/core';
+import { Config } from '@core/config';
+import { AvConfiguration } from '@swagger/availability';
+import { CatConfiguration } from '@swagger/cat';
+import { CheckoutConfiguration } from '@swagger/checkout';
+import { CrmConfiguration } from '@swagger/crm';
+import { EisConfiguration } from '@swagger/eis';
+import { IsaConfiguration } from '@swagger/isa';
+import { OmsConfiguration } from '@swagger/oms';
+import { PrintConfiguration } from '@swagger/print';
+import { RemiConfiguration } from '@swagger/remi';
+import { WwsConfiguration } from '@swagger/wws';
+
+export function createConfigurationFactory(name: string) {
+  return function (config: Config): { rootUrl: string } {
+    return config.get(`@swagger/${name}`);
+  };
+}
+
+@NgModule({
+  providers: [
+    { provide: AvConfiguration, useFactory: createConfigurationFactory('av'), deps: [Config] },
+    { provide: CatConfiguration, useFactory: createConfigurationFactory('cat'), deps: [Config] },
+    { provide: CheckoutConfiguration, useFactory: createConfigurationFactory('checkout'), deps: [Config] },
+    { provide: CrmConfiguration, useFactory: createConfigurationFactory('crm'), deps: [Config] },
+    { provide: EisConfiguration, useFactory: createConfigurationFactory('eis'), deps: [Config] },
+    { provide: IsaConfiguration, useFactory: createConfigurationFactory('isa'), deps: [Config] },
+    { provide: OmsConfiguration, useFactory: createConfigurationFactory('oms'), deps: [Config] },
+    { provide: PrintConfiguration, useFactory: createConfigurationFactory('print'), deps: [Config] },
+    { provide: RemiConfiguration, useFactory: createConfigurationFactory('remi'), deps: [Config] },
+    { provide: WwsConfiguration, useFactory: createConfigurationFactory('wws'), deps: [Config] },
+  ],
+})
+export class AppSwaggerModule {}

apps/isa-app/src/app/app.component.html

@@ -0,0 +1,28 @@
+@if ($offlineBannerVisible()) {
+  <div [@fadeInOut] class="bg-brand text-white text-center fixed inset-x-0 top-0 z-tooltip p-4">
+    <h3 class="font-bold grid grid-flow-col items-center justify-center text-xl gap-4">
+      <div>
+        <ng-icon name="matWifiOff"></ng-icon>
+      </div>
+
+      <div>Sie sind offline, keine Verbindung zum Netzwerk.</div>
+    </h3>
+    <p>Bereits geladene Ihnalte werden angezeigt, Interaktionen sind aktuell nicht möglich.</p>
+  </div>
+}
+@if ($onlineBannerVisible()) {
+  <div [@fadeInOut] class="bg-green-500 text-white text-center fixed inset-x-0 top-0 z-tooltip p-4">
+    <h3 class="font-bold grid grid-flow-col items-center justify-center text-xl gap-4">
+      <div>
+        <ng-icon name="matWifi"></ng-icon>
+      </div>
+
+      <div>Sie sind wieder online.</div>
+    </h3>
+    <button class="fixed top-2 right-4 text-3xl w-12 h-12" type="button" (click)="$onlineBannerVisible.set(false)">
+      <ng-icon name="matClose"></ng-icon>
+    </button>
+  </div>
+}
+
+<router-outlet></router-outlet>

apps/isa-app/src/app/app.component.scss

@@ -0,0 +1,3 @@
+:host {
+  @apply block;
+}

apps/isa-app/src/app/app.component.spec.ts

@@ -0,0 +1,137 @@
+import { Spectator, createComponentFactory, SpyObject, createSpyObject } from '@ngneat/spectator';
+import { RouterTestingModule } from '@angular/router/testing';
+import { AppComponent } from './app.component';
+import { Config } from '@core/config';
+import { ApplicationService } from '@core/application';
+import { of } from 'rxjs';
+import { Renderer2 } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { SwUpdate } from '@angular/service-worker';
+import { NotificationsHub } from '@hub/notifications';
+import { UserStateService } from '@swagger/isa';
+import { UiModalService } from '@ui/modal';
+import { AuthService } from '@core/auth';
+
+describe('AppComponent', () => {
+  let spectator: Spectator<AppComponent>;
+  let config: SpyObject<Config>;
+  let renderer: SpyObject<Renderer2>;
+  let applicationServiceMock: SpyObject<ApplicationService>;
+  let notificationsHubMock: SpyObject<NotificationsHub>;
+  let swUpdateMock: SpyObject<SwUpdate>;
+  const createComponent = createComponentFactory({
+    component: AppComponent,
+    imports: [CommonModule, RouterTestingModule],
+    providers: [],
+    mocks: [Config, SwUpdate, UserStateService, UiModalService, AuthService],
+  });
+
+  beforeEach(() => {
+    applicationServiceMock = createSpyObject(ApplicationService);
+    applicationServiceMock.getSection$.and.returnValue(of('customer'));
+    applicationServiceMock.getActivatedProcessId$.and.returnValue(of(undefined));
+    renderer = jasmine.createSpyObj('Renderer2', ['addClass', 'removeClass']);
+
+    notificationsHubMock = createSpyObject(NotificationsHub);
+    notificationsHubMock.notifications$ = of({});
+    swUpdateMock = createSpyObject(SwUpdate);
+
+    spectator = createComponent({
+      providers: [
+        { provide: ApplicationService, useValue: applicationServiceMock },
+        {
+          provide: Renderer2,
+          useValue: renderer,
+        },
+        { provide: NotificationsHub, useValue: notificationsHubMock },
+        { provide: SwUpdate, useValue: swUpdateMock },
+      ],
+    });
+    config = spectator.inject(Config);
+  });
+
+  it('should create the app', () => {
+    expect(spectator.component).toBeTruthy();
+  });
+
+  it('should have a router outlet', () => {
+    expect(spectator.query('router-outlet')).toExist();
+  });
+
+  describe('ngOnInit', () => {
+    it('should call setTitle', () => {
+      const spy = spyOn(spectator.component, 'setTitle');
+      spectator.component.ngOnInit();
+      expect(spy).toHaveBeenCalled();
+    });
+
+    it('should call logVersion', () => {
+      const spy = spyOn(spectator.component, 'logVersion');
+      spectator.component.ngOnInit();
+      expect(spy).toHaveBeenCalled();
+    });
+  });
+
+  describe('setTitle', () => {
+    it('should call Title.setTitle()', () => {
+      const spyTitleSetTitle = spyOn(spectator.component['_title'], 'setTitle');
+      config.get.and.returnValue('test');
+      spectator.component.setTitle();
+      expect(spyTitleSetTitle).toHaveBeenCalledWith('test');
+    });
+  });
+
+  describe('logVersion', () => {
+    it('should call console.log()', () => {
+      const spyConsoleLog = spyOn(console, 'log');
+      config.get.and.returnValue('test');
+      spectator.component.logVersion();
+      expect(spyConsoleLog).toHaveBeenCalled();
+    });
+  });
+
+  // --------------------------------------------------------
+  // Unit Tests Implementation for Angular Version 13.x.x
+
+  // describe('updateClient()', () => {
+  //   it('should call checkForUpdate() if SwUpdate.isEnabled is True', () => {
+  //     spyOn(spectator.component, 'checkForUpdate');
+  //     spyOn(spectator.component, 'initialCheckForUpdate');
+  //     (swUpdateMock as any).isEnabled = true;
+  //     spectator.component.updateClient();
+  //     expect(spectator.component.initialCheckForUpdate).toHaveBeenCalled();
+  //     expect(spectator.component.checkForUpdate).toHaveBeenCalled();
+  //   });
+
+  //   it('should not call checkForUpdate() if SwUpdate.isEnabled is False', () => {
+  //     spyOn(spectator.component, 'checkForUpdate');
+  //     spyOn(spectator.component, 'initialCheckForUpdate');
+  //     (swUpdateMock as any).isEnabled = false;
+  //     spectator.component.updateClient();
+  //     expect(spectator.component.initialCheckForUpdate).not.toHaveBeenCalled();
+  //     expect(spectator.component.checkForUpdate).not.toHaveBeenCalled();
+  //   });
+  // });
+
+  // describe('checkForUpdate', () => {
+  //   it('should call swUpdate.checkForUpdate() and notifications.updateNotification() every second', fakeAsync(() => {
+  //     swUpdateMock.checkForUpdate.and.returnValue(Promise.resolve());
+  //     spectator.component.checkForUpdates = 1000;
+  //     spectator.component.checkForUpdate();
+
+  //     spectator.detectChanges();
+  //     tick(1100);
+
+  //     expect(notificationsHubMock.updateNotification).toHaveBeenCalled();
+  //     discardPeriodicTasks();
+  //   }));
+  // });
+
+  // describe('initialCheckForUpdate', () => {
+  //   it('should call swUpdate.checkForUpdate()', () => {
+  //     swUpdateMock.checkForUpdate.and.returnValue(new Promise(undefined));
+  //     spectator.component.initialCheckForUpdate();
+  //     expect(swUpdateMock.checkForUpdate).toHaveBeenCalled();
+  //   });
+  // });
+});

apps/isa-app/src/app/app.component.ts

@@ -0,0 +1,194 @@
+import { DOCUMENT } from '@angular/common';
+import { Component, effect, HostListener, Inject, OnInit, Renderer2, signal, untracked } from '@angular/core';
+import { Title } from '@angular/platform-browser';
+import { SwUpdate } from '@angular/service-worker';
+import { ApplicationService } from '@core/application';
+import { Config } from '@core/config';
+import { NotificationsHub } from '@hub/notifications';
+import packageInfo from 'packageJson';
+import { asapScheduler, interval, Subscription } from 'rxjs';
+import { UserStateService } from '@swagger/isa';
+import { IsaLogProvider } from './providers';
+import { EnvironmentService } from '@core/environment';
+import { AuthService } from '@core/auth';
+import { UiMessageModalComponent, UiModalService } from '@ui/modal';
+import { injectOnline$ } from './services/network-status.service';
+import { toSignal } from '@angular/core/rxjs-interop';
+import { animate, style, transition, trigger } from '@angular/animations';
+
+@Component({
+  selector: 'app-root',
+  templateUrl: './app.component.html',
+  styleUrls: ['./app.component.scss'],
+  animations: [
+    trigger('fadeInOut', [
+      transition(':enter', [
+        // :enter wird ausgelöst, wenn das Element zum DOM hinzugefügt wird
+        style({ opacity: 0, transform: 'translateY(-100%)' }),
+        animate('300ms', style({ opacity: 1, transform: 'translateY(0)' })),
+      ]),
+      transition(':leave', [
+        // :leave wird ausgelöst, wenn das Element aus dem DOM entfernt wird
+        animate('300ms', style({ opacity: 0, transform: 'translateY(-100%)' })),
+      ]),
+    ]),
+  ],
+})
+export class AppComponent implements OnInit {
+  $online = toSignal(injectOnline$());
+
+  $offlineBannerVisible = signal(false);
+
+  $onlineBannerVisible = signal(false);
+
+  private onlineBannerDismissTimeout: any;
+
+  onlineEffects = effect(() => {
+    const online = this.$online();
+    const offlineBannerVisible = this.$offlineBannerVisible();
+
+    untracked(() => {
+      this.$offlineBannerVisible.set(!online);
+
+      if (!online) {
+        this.$onlineBannerVisible.set(false);
+        clearTimeout(this.onlineBannerDismissTimeout);
+      }
+
+      if (offlineBannerVisible && online) {
+        this.$onlineBannerVisible.set(true);
+        this.onlineBannerDismissTimeout = setTimeout(() => this.$onlineBannerVisible.set(false), 5000);
+      }
+    });
+  });
+
+  private _checkForUpdates: number = this._config.get('checkForUpdates');
+
+  get checkForUpdates(): number {
+    return this._checkForUpdates ?? 60 * 60 * 1000; // default 1 hour
+  }
+
+  // For Unit Testing
+  set checkForUpdates(time: number) {
+    this._checkForUpdates = time;
+  }
+
+  subscriptions = new Subscription();
+
+  constructor(
+    private readonly _config: Config,
+    private readonly _title: Title,
+    private readonly _appService: ApplicationService,
+    @Inject(DOCUMENT) private readonly _document: Document,
+    private readonly _renderer: Renderer2,
+    private readonly _swUpdate: SwUpdate,
+    private readonly _notifications: NotificationsHub,
+    private infoService: UserStateService,
+    private readonly _environment: EnvironmentService,
+    private readonly _authService: AuthService,
+    private readonly _modal: UiModalService,
+  ) {
+    this.updateClient();
+    IsaLogProvider.InfoService = this.infoService;
+  }
+
+  ngOnInit() {
+    this.setTitle();
+    this.logVersion();
+    asapScheduler.schedule(() => this.determinePlatform(), 250);
+    this._appService.getSection$().subscribe(this.sectionChangeHandler.bind(this));
+
+    this.setupSilentRefresh();
+  }
+
+  // Setup interval for silent refresh
+  setupSilentRefresh() {
+    const silentRefreshInterval = this._config.get('silentRefresh.interval');
+    if (silentRefreshInterval > 0) {
+      interval(silentRefreshInterval).subscribe(() => {
+        if (this._authService.isAuthenticated()) {
+          this._authService.refresh();
+        }
+      });
+    }
+  }
+
+  setTitle() {
+    this._title.setTitle(this._config.get('title'));
+  }
+
+  logVersion() {
+    console.log(`%c${this._config.get('title')}\r\nVersion: ${packageInfo.version}`, 'font-weight: bold; font-size: 20px;');
+  }
+
+  determinePlatform() {
+    if (this._environment.isNative()) {
+      this._renderer.addClass(this._document.body, 'tablet-native');
+    } else if (this._environment.isTablet()) {
+      this._renderer.addClass(this._document.body, 'tablet-browser');
+    }
+    if (this._environment.isTablet()) {
+      this._renderer.addClass(this._document.body, 'tablet');
+    }
+    if (this._environment.isDesktop()) {
+      this._renderer.addClass(this._document.body, 'desktop');
+    }
+  }
+
+  sectionChangeHandler(section: string) {
+    if (section === 'customer') {
+      this._renderer.removeClass(this._document.body, 'branch');
+      this._renderer.addClass(this._document.body, 'customer');
+    } else if (section === 'branch') {
+      this._renderer.removeClass(this._document.body, 'customer');
+      this._renderer.addClass(this._document.body, 'branch');
+    }
+  }
+
+  updateClient() {
+    if (!this._swUpdate.isEnabled) {
+      return;
+    }
+
+    this.initialCheckForUpdate();
+    this.checkForUpdate();
+  }
+
+  checkForUpdate() {
+    interval(this._checkForUpdates).subscribe(() => {
+      this._swUpdate.checkForUpdate().then((value) => {
+        console.log('check for update', value);
+        if (value) {
+          this._notifications.updateNotification();
+        }
+      });
+    });
+  }
+
+  initialCheckForUpdate() {
+    this._swUpdate.checkForUpdate().then((value) => {
+      console.log('initial check for update', value);
+      if (value) {
+        location.reload();
+      }
+    });
+  }
+
+  @HostListener('window:visibilitychange', ['$event'])
+  onVisibilityChange(event: Event) {
+    // refresh token when app is in background
+    if (this._document.hidden && this._authService.isAuthenticated()) {
+      this._authService.refresh();
+    } else if (!this._authService.isAuthenticated()) {
+      return this._modal
+        .open({
+          content: UiMessageModalComponent,
+          title: 'Sie sind nicht mehr angemeldet',
+          data: { message: 'Sie werden neu angemeldet' },
+        })
+        .afterClosed$.subscribe(() => {
+          this._authService.login();
+        });
+    }
+  }
+}

apps/isa-app/src/app/app.module.ts

@@ -0,0 +1,188 @@
+import { HTTP_INTERCEPTORS, provideHttpClient, withInterceptorsFromDi } from '@angular/common/http';
+import { APP_INITIALIZER, ErrorHandler, Injector, LOCALE_ID, NgModule } from '@angular/core';
+import { BrowserModule } from '@angular/platform-browser';
+import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
+import { PlatformModule } from '@angular/cdk/platform';
+
+import { Config, ConfigModule, JsonConfigLoader } from '@core/config';
+import { AuthModule, AuthService } from '@core/auth';
+import { CoreCommandModule } from '@core/command';
+
+import { AppRoutingModule } from './app-routing.module';
+import { AppComponent } from './app.component';
+import { CoreApplicationModule } from '@core/application';
+import { AppStoreModule } from './app-store.module';
+import { ServiceWorkerModule } from '@angular/service-worker';
+import { environment } from '../environments/environment';
+import { AppSwaggerModule } from './app-swagger.module';
+import { AppDomainModule } from './app-domain.module';
+import { UiModalModule } from '@ui/modal';
+import { NotificationsHubModule, NOTIFICATIONS_HUB_OPTIONS } from '@hub/notifications';
+import { SignalRHubOptions } from '@core/signalr';
+import { CoreBreadcrumbModule } from '@core/breadcrumb';
+import { UiCommonModule } from '@ui/common';
+import { registerLocaleData } from '@angular/common';
+
+import localeDe from '@angular/common/locales/de';
+import localeDeExtra from '@angular/common/locales/extra/de';
+import { HttpErrorInterceptor } from './interceptors';
+import { CoreLoggerModule, LOG_PROVIDER } from '@core/logger';
+import { IsaLogProvider } from './providers';
+import { IsaErrorHandler } from './providers/isa.error-handler';
+import { ScanAdapterModule, ScanAdapterService, ScanditScanAdapterModule } from '@adapter/scan';
+import { RootStateService } from './store/root-state.service';
+import * as Commands from './commands';
+import { PreviewComponent } from './preview';
+import { NativeContainerService } from '@external/native-container';
+import { ShellModule } from '@shared/shell';
+import { MainComponent } from './main.component';
+import { IconModule } from '@shared/components/icon';
+import { NgIconsModule } from '@ng-icons/core';
+import { matClose, matWifi, matWifiOff } from '@ng-icons/material-icons/baseline';
+import { NetworkStatusService } from './services/network-status.service';
+import { firstValueFrom } from 'rxjs';
+
+registerLocaleData(localeDe, localeDeExtra);
+registerLocaleData(localeDe, 'de', localeDeExtra);
+
+export function _appInitializerFactory(
+  config: Config,
+  auth: AuthService,
+  injector: Injector,
+  scanAdapter: ScanAdapterService,
+  nativeContainer: NativeContainerService,
+  networkStatus: NetworkStatusService,
+) {
+  return async () => {
+    const statusElement = document.querySelector('#init-status');
+    const laoderElement = document.querySelector('#init-loader');
+
+    try {
+      let online = false;
+
+      while (!online) {
+        online = await firstValueFrom(networkStatus.online$);
+
+        if (!online) {
+          statusElement.innerHTML =
+            '<b>Warte auf Netzwerkverbindung (WLAN)</b><br><br>Bitte prüfen Sie die Netzwerkverbindung (WLAN).<br>Sobald eine Netzwerkverbindung besteht, wird die App automatisch neu geladen.';
+          await new Promise((resolve) => setTimeout(resolve, 250));
+        }
+      }
+
+      statusElement.innerHTML = 'Konfigurationen werden geladen...';
+      await config.init();
+      statusElement.innerHTML = 'Authentifizierung wird geprüft...';
+      await auth.init();
+
+      if (auth.isAuthenticated()) {
+        statusElement.innerHTML = 'App wird initialisiert...';
+        const state = injector.get(RootStateService);
+        await state.init();
+      }
+
+      statusElement.innerHTML = 'Native Container wird initialisiert...';
+      await nativeContainer.init();
+      statusElement.innerHTML = 'Scanner wird initialisiert...';
+      await scanAdapter.init();
+    } catch (error) {
+      laoderElement.remove();
+      statusElement.classList.add('text-xl');
+      statusElement.innerHTML +=
+        '⚡<br><br><b>Fehler bei der Initialisierung</b><br><br>Bitte prüfen Sie die Netzwerkverbindung (WLAN).<br><br>';
+
+      const reload = document.createElement('button');
+      reload.classList.add('bg-brand', 'text-white', 'p-2', 'rounded', 'cursor-pointer');
+      reload.innerHTML = 'App neu laden';
+      reload.onclick = () => window.location.reload();
+      statusElement.appendChild(reload);
+
+      const preLabel = document.createElement('div');
+      preLabel.classList.add('mt-12');
+      preLabel.innerHTML = 'Fehlermeldung:';
+
+      statusElement.appendChild(preLabel);
+
+      const pre = document.createElement('pre');
+      pre.classList.add('mt-4', 'text-wrap');
+      pre.innerHTML = error.message;
+
+      statusElement.appendChild(pre);
+
+      console.error('Error during app initialization', error);
+      throw error;
+    }
+  };
+}
+
+export function _notificationsHubOptionsFactory(config: Config, auth: AuthService): SignalRHubOptions {
+  const options = { ...config.get('hubs').notifications };
+  options.httpOptions.accessTokenFactory = () => auth.getToken();
+  return options;
+}
+
+@NgModule({
+  declarations: [AppComponent, MainComponent],
+  bootstrap: [AppComponent],
+  imports: [
+    BrowserModule,
+    BrowserAnimationsModule,
+    ShellModule.forRoot(),
+    AppRoutingModule,
+    AppSwaggerModule,
+    AppDomainModule,
+    CoreBreadcrumbModule.forRoot(),
+    ConfigModule.forRoot({
+      useConfigLoader: JsonConfigLoader,
+      jsonConfigLoaderUrl: '/config/config.json',
+    }),
+    CoreCommandModule.forRoot(Object.values(Commands)),
+    CoreLoggerModule.forRoot(),
+    AppStoreModule,
+    PreviewComponent,
+    AuthModule.forRoot(),
+    CoreApplicationModule.forRoot(),
+    UiModalModule.forRoot(),
+    UiCommonModule.forRoot(),
+    NotificationsHubModule.forRoot(),
+    ServiceWorkerModule.register('ngsw-worker.js', {
+      enabled: environment.production,
+      registrationStrategy: 'registerWhenStable:30000',
+    }),
+    ScanAdapterModule.forRoot(),
+    ScanditScanAdapterModule.forRoot(),
+    PlatformModule,
+    IconModule.forRoot(),
+    NgIconsModule.withIcons({ matWifiOff, matClose, matWifi }),
+  ],
+  providers: [
+    {
+      provide: APP_INITIALIZER,
+      useFactory: _appInitializerFactory,
+      multi: true,
+      deps: [Config, AuthService, Injector, ScanAdapterService, NativeContainerService, NetworkStatusService],
+    },
+    {
+      provide: NOTIFICATIONS_HUB_OPTIONS,
+      useFactory: _notificationsHubOptionsFactory,
+      deps: [Config, AuthService],
+    },
+    {
+      provide: HTTP_INTERCEPTORS,
+      useClass: HttpErrorInterceptor,
+      multi: true,
+    },
+    {
+      provide: LOG_PROVIDER,
+      useClass: IsaLogProvider,
+      multi: true,
+    },
+    {
+      provide: ErrorHandler,
+      useClass: IsaErrorHandler,
+    },
+    { provide: LOCALE_ID, useValue: 'de-DE' },
+    provideHttpClient(withInterceptorsFromDi()),
+  ],
+})
+export class AppModule {}

apps/isa-app/src/app/commands/close.command.ts

@@ -0,0 +1,14 @@
+import { Injectable } from '@angular/core';
+import { ActionHandler } from '@core/command';
+
+/** Dummy Command um Fehlermeldungen aus dem Diloag zu verhinden */
+@Injectable()
+export class CloseCommand extends ActionHandler<any> {
+  constructor() {
+    super('CLOSE');
+  }
+
+  handler(ctx: any): any {
+    return ctx;
+  }
+}

apps/isa-app/src/app/commands/create-customer.command.ts

@@ -0,0 +1,35 @@
+import { Injectable } from '@angular/core';
+import { Router } from '@angular/router';
+import { ApplicationService } from '@core/application';
+import { ActionHandler } from '@core/command';
+import { Result } from '@domain/defs';
+import { CustomerInfoDTO } from '@swagger/crm';
+
+@Injectable()
+export class CreateCustomerCommand extends ActionHandler<Result<CustomerInfoDTO[]>> {
+  constructor(private _router: Router, private _application: ApplicationService) {
+    super('CREATE_CUSTOMER');
+  }
+
+  async handler(data: Result<CustomerInfoDTO[]>): Promise<Result<CustomerInfoDTO[]>> {
+    let customerType: string;
+    if (data.result.length > 0) {
+      const customerInfo = data.result[0];
+      if (customerInfo.features) {
+        if (customerInfo.features.some((f) => f.key === 'store')) {
+          customerType = 'store';
+        }
+        if (customerInfo.features.some((f) => f.key === 'webshop')) {
+          customerType = 'webshop';
+        }
+      }
+    }
+
+    if (!customerType) {
+      customerType = 'store';
+    }
+
+    await this._router.navigate(['/kunde', this._application.activatedProcessId, 'customer', 'create', customerType]);
+    return data;
+  }
+}

apps/isa-app/src/app/commands/create-kubi-customer.command.ts

@@ -0,0 +1,48 @@
+import { Injectable } from '@angular/core';
+import { Router } from '@angular/router';
+import { ApplicationService } from '@core/application';
+import { ActionHandler } from '@core/command';
+import { Result } from '@domain/defs';
+import { encodeFormData, mapCustomerInfoDtoToCustomerCreateFormData } from '@page/customer';
+import { CustomerInfoDTO } from '@swagger/crm';
+
+@Injectable()
+export class CreateKubiCustomerCommand extends ActionHandler<Result<CustomerInfoDTO[]>> {
+  constructor(
+    private _router: Router,
+    private _application: ApplicationService,
+  ) {
+    super('CREATE_KUBI_CUSTOMER');
+  }
+
+  async handler(data: Result<CustomerInfoDTO[]>): Promise<Result<CustomerInfoDTO[]>> {
+    let customerType: string;
+    let formData: string;
+    if (data.result.length > 0) {
+      const customerInfo = data.result[0];
+      const fd = mapCustomerInfoDtoToCustomerCreateFormData(customerInfo);
+      formData = encodeFormData({
+        ...fd,
+        agb: true,
+      });
+
+      if (customerInfo.features) {
+        if (customerInfo.features.some((f) => f.key === 'store')) {
+          customerType = 'store';
+        }
+        if (customerInfo.features.some((f) => f.key === 'webshop')) {
+          customerType = 'webshop';
+        }
+      }
+    }
+
+    if (!customerType) {
+      customerType = 'store';
+    }
+
+    await this._router.navigate(['/kunde', this._application.activatedProcessId, 'customer', 'create', `${customerType}-p4m`], {
+      queryParams: { formData },
+    });
+    return data;
+  }
+}

apps/isa-app/src/app/commands/index.ts

@@ -0,0 +1,5 @@
+export * from './close.command';
+export * from './create-customer.command';
+export * from './create-kubi-customer.command';
+export * from './print-kubi-agb.command';
+export * from './remit.command';

apps/isa-app/src/app/commands/print-kubi-agb.command.ts

@@ -0,0 +1,34 @@
+import { Injectable } from '@angular/core';
+import { ActionHandler } from '@core/command';
+import { Result } from '@domain/defs';
+import { DomainPrinterService } from '@domain/printer';
+import { PrintModalComponent, PrintModalData } from '@modal/printer';
+import { CustomerInfoDTO } from '@swagger/crm';
+import { UiModalService } from '@ui/modal';
+
+@Injectable()
+export class PrintKubiCustomerCommand extends ActionHandler<Result<CustomerInfoDTO[]>> {
+  constructor(private _uiModal: UiModalService, private _printerService: DomainPrinterService) {
+    super('PRINT_KUBI_AGB');
+  }
+
+  async handler(data: Result<CustomerInfoDTO[]>): Promise<Result<CustomerInfoDTO[]>> {
+    const customerInfo = data.result ? data.result[0] : undefined;
+    let p4mCode: string;
+    if (customerInfo) {
+      p4mCode = customerInfo.features.find((f) => f.key === 'p4mUser').value;
+    }
+
+    await this._uiModal
+      .open({
+        content: PrintModalComponent,
+        config: { showScrollbarY: false },
+        data: {
+          printerType: 'Label',
+          print: (printer) => this._printerService.printKubiAgb({ printer, p4mCode }).toPromise(),
+        } as PrintModalData,
+      })
+      .afterClosed$.toPromise();
+    return data;
+  }
+}

apps/isa-app/src/app/commands/remit.command.ts

@@ -0,0 +1,14 @@
+import { Injectable } from '@angular/core';
+import { ActionHandler } from '@core/command';
+
+/** Dummy Command um Fehlermeldungen aus dem Diloag zu verhinden */
+@Injectable()
+export class RemitCommand extends ActionHandler<any> {
+  constructor() {
+    super('remit');
+  }
+
+  handler(ctx: any): any {
+    return ctx;
+  }
+}

apps/isa-app/src/app/debug/debug.component.html

@@ -0,0 +1,11 @@
+<div class="odd:bg-slate-200 grid grid-flow-col justify-start" *ngFor="let log of logs$ | async">
+  <div class="p-2 w-100 grow-0">
+    {{ log.timestamp | date }}
+  </div>
+  <div class="p-2 w-50 grow-0">
+    {{ log.type }}
+  </div>
+  <div class="p-2 grow">
+    {{ log.args | json }}
+  </div>
+</div>

apps/isa-app/src/app/debug/debug.component.scss

@@ -0,0 +1,6 @@
+:host {
+  @apply block;
+}
+:host {
+  @apply grid grid-flow-row bg-white overflow-scroll;
+}

apps/isa-app/src/app/debug/debug.component.ts

@@ -0,0 +1,17 @@
+import { CommonModule } from '@angular/common';
+import { Component, ChangeDetectionStrategy } from '@angular/core';
+import { DebugService } from './debug.service';
+
+@Component({
+  selector: 'app-debug',
+  templateUrl: 'debug.component.html',
+  styleUrls: ['debug.component.scss'],
+  changeDetection: ChangeDetectionStrategy.OnPush,
+  standalone: true,
+  imports: [CommonModule],
+})
+export class DebugComponent {
+  logs$ = this.debugService.logs$;
+
+  constructor(private debugService: DebugService) {}
+}

apps/isa-app/src/app/debug/debug.service.ts

@@ -0,0 +1,25 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, fromEvent } from 'rxjs';
+
+export interface ConsoleLog {
+  timestamp?: Date;
+  type: 'log' | 'warn' | 'error';
+  args: any[];
+}
+
+@Injectable()
+export class DebugService {
+  private _consoleSubject = new BehaviorSubject<ConsoleLog[]>([]);
+
+  logs$ = this._consoleSubject.asObservable();
+
+  constructor() {
+    fromEvent(window, 'message').subscribe((event: MessageEvent) => {
+      this.add({ type: 'log', args: [event.data] });
+    });
+  }
+
+  add(log: ConsoleLog) {
+    this._consoleSubject.next([...this._consoleSubject.value, { ...log, timestamp: new Date() }]);
+  }
+}

apps/isa-app/src/app/guards/activate-process-id.guard.ts

@@ -0,0 +1,46 @@
+import { inject } from '@angular/core';
+import { ActivatedRouteSnapshot, CanActivateFn, RouterStateSnapshot } from '@angular/router';
+import { ApplicationService } from '@core/application';
+import { Config } from '@core/config';
+import { take } from 'rxjs/operators';
+
+export const ActivateProcessIdGuard: CanActivateFn = async (route: ActivatedRouteSnapshot, state: RouterStateSnapshot) => {
+  const application = inject(ApplicationService);
+
+  const processIdStr = route.params.processId;
+
+  if (!processIdStr) {
+    return false;
+  }
+
+  const processId = Number(processIdStr);
+
+  // Check if Process already exists
+  const process = await application.getProcessById$(processId).pipe(take(1)).toPromise();
+
+  if (!process) {
+    application.createCustomerProcess(processId);
+  }
+
+  application.activateProcess(processId);
+
+  return true;
+};
+
+export const ActivateProcessIdWithConfigKeyGuard: (key: string) => CanActivateFn = (key) => async (
+  route: ActivatedRouteSnapshot,
+  state: RouterStateSnapshot
+) => {
+  const application = inject(ApplicationService);
+  const config = inject(Config);
+
+  const processId = config.get(`process.ids.${key}`);
+
+  if (isNaN(processId)) {
+    return false;
+  }
+
+  application.activateProcess(processId);
+
+  return true;
+};

apps/isa-app/src/app/guards/can-activate-assortment.guard.ts

@@ -0,0 +1,24 @@
+import { Injectable } from '@angular/core';
+import { ActivatedRouteSnapshot, RouterStateSnapshot } from '@angular/router';
+import { ApplicationService } from '@core/application';
+import { Config } from '@core/config';
+import { first } from 'rxjs/operators';
+
+@Injectable({ providedIn: 'root' })
+export class CanActivateAssortmentGuard {
+  constructor(private readonly _applicationService: ApplicationService, private readonly _config: Config) {}
+
+  async canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot) {
+    const process = await this._applicationService.getProcessById$(this._config.get('process.ids.assortment')).pipe(first()).toPromise();
+    if (!process) {
+      await this._applicationService.createProcess({
+        id: this._config.get('process.ids.assortment'),
+        type: 'assortment',
+        section: 'branch',
+        name: 'Sortiment',
+      });
+    }
+    this._applicationService.activateProcess(this._config.get('process.ids.assortment'));
+    return true;
+  }
+}

apps/isa-app/src/app/guards/can-activate-cart-with-process-id.guard.ts

@@ -0,0 +1,40 @@
+import { Injectable } from '@angular/core';
+import { ActivatedRouteSnapshot, RouterStateSnapshot } from '@angular/router';
+import { ApplicationProcess, ApplicationService } from '@core/application';
+import { first } from 'rxjs/operators';
+
+@Injectable({ providedIn: 'root' })
+export class CanActivateCartWithProcessIdGuard {
+  constructor(private readonly _applicationService: ApplicationService) {}
+
+  async canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot) {
+    const process = await this._applicationService
+      .getProcessById$(+route.params.processId)
+      .pipe(first())
+      .toPromise();
+
+    // if (!(process?.type === 'cart')) {
+    //   // TODO:
+    //   // Anderer Prozesstyp mit gleicher Id - Was soll gemacht werden?
+    //   return false;
+    // }
+
+    if (!process) {
+      const processes = await this._applicationService.getProcesses$('customer').pipe(first()).toPromise();
+      await this._applicationService.createProcess({
+        id: +route.params.processId,
+        type: 'cart',
+        section: 'customer',
+        name: `Vorgang ${this.processNumber(processes)}`,
+      });
+    }
+
+    this._applicationService.activateProcess(+route.params.processId);
+    return true;
+  }
+
+  processNumber(processes: ApplicationProcess[]) {
+    const processNumbers = processes?.map((process) => Number(process?.name?.replace(/\D/g, '')));
+    return !!processNumbers && processNumbers?.length > 0 ? Math.max(...processNumbers) + 1 : 1;
+  }
+}

apps/isa-app/src/app/guards/can-activate-cart.guard.ts

@@ -0,0 +1,31 @@
+import { Injectable } from '@angular/core';
+import { ActivatedRouteSnapshot, RouterStateSnapshot } from '@angular/router';
+import { ApplicationService } from '@core/application';
+import { CheckoutNavigationService } from '@shared/services/navigation';
+import { first } from 'rxjs/operators';
+
+@Injectable({ providedIn: 'root' })
+export class CanActivateCartGuard {
+  constructor(
+    private readonly _applicationService: ApplicationService,
+    private _checkoutNavigationService: CheckoutNavigationService,
+  ) {}
+
+  async canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot) {
+    const processes = await this._applicationService.getProcesses$('customer').pipe(first()).toPromise();
+    let lastActivatedProcessId = (
+      await this._applicationService.getLastActivatedProcessWithSectionAndType$('customer', 'cart').pipe(first()).toPromise()
+    )?.id;
+    if (!lastActivatedProcessId) {
+      lastActivatedProcessId = Date.now();
+      await this._applicationService.createProcess({
+        id: lastActivatedProcessId,
+        type: 'cart',
+        section: 'customer',
+        name: `Vorgang ${processes.length + 1}`,
+      });
+    }
+    await this._checkoutNavigationService.getCheckoutReviewPath(lastActivatedProcessId).path;
+    return false;
+  }
+}

apps/isa-app/src/app/guards/can-activate-customer-orders-with-process-id.guard.ts

@@ -0,0 +1,64 @@
+import { Injectable } from '@angular/core';
+import { ActivatedRouteSnapshot, RouterStateSnapshot } from '@angular/router';
+import { ApplicationProcess, ApplicationService } from '@core/application';
+import { BreadcrumbService } from '@core/breadcrumb';
+import { first } from 'rxjs/operators';
+
+@Injectable({ providedIn: 'root' })
+export class CanActivateCustomerOrdersWithProcessIdGuard {
+  constructor(private readonly _applicationService: ApplicationService, private readonly _breadcrumbService: BreadcrumbService) {}
+
+  async canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot) {
+    const process = await this._applicationService
+      .getProcessById$(+route.params.processId)
+      .pipe(first())
+      .toPromise();
+
+    if (!process) {
+      const processes = await this._applicationService.getProcesses$('customer').pipe(first()).toPromise();
+      await this._applicationService.createProcess({
+        id: +route.params.processId,
+        type: 'cart',
+        section: 'customer',
+        name: `Vorgang ${this.processNumber(processes.filter((process) => process.type === 'cart'))}`,
+      });
+    }
+
+    await this.removeBreadcrumbWithSameProcessId(route);
+    this._applicationService.activateProcess(+route.params.processId);
+    return true;
+  }
+
+  // Fix #3292: Alle Breadcrumbs die nichts mit dem aktuellen Prozess zu tun haben, müssen removed werden
+  async removeBreadcrumbWithSameProcessId(route: ActivatedRouteSnapshot) {
+    const crumbs = await this._breadcrumbService
+      .getBreadcrumbByKey$(+route.params.processId)
+      .pipe(first())
+      .toPromise();
+
+    // Entferne alle Crumbs die nichts mit den Kundenbestellungen zu tun haben
+    if (crumbs.length > 1) {
+      const crumbsToRemove = crumbs.filter((crumb) => crumb.tags.find((tag) => tag === 'customer-order') === undefined);
+      for (const crumb of crumbsToRemove) {
+        await this._breadcrumbService.removeBreadcrumb(crumb.id);
+      }
+    }
+  }
+
+  processNumber(processes: ApplicationProcess[]) {
+    const processNumbers = processes?.map((process) => Number(process?.name?.replace(/\D/g, '')));
+    return !!processNumbers && processNumbers.length > 0 ? this.findMissingNumber(processNumbers) : 1;
+  }
+
+  findMissingNumber(processNumbers: number[]) {
+    // Ticket #3272 Bei Klick auf "+" bzw. neuen Prozess hinzufügen soll der neue Tab immer die höchste Nummer haben (wie aktuell im Produktiv)
+    // ----------------------------------------------------------------------------------------------------------------------------------------
+
+    // for (let missingNumber = 1; missingNumber < Math.max(...processNumbers); missingNumber++) {
+    //   if (!processNumbers.find((number) => number === missingNumber)) {
+    //     return missingNumber;
+    //   }
+    // }
+    return Math.max(...processNumbers) + 1;
+  }
+}

apps/isa-app/src/app/guards/can-activate-customer-orders.guard.ts

@@ -0,0 +1,97 @@
+import { Injectable } from '@angular/core';
+import { ActivatedRouteSnapshot, RouterStateSnapshot } from '@angular/router';
+import { ApplicationProcess, ApplicationService } from '@core/application';
+import { DomainCheckoutService } from '@domain/checkout';
+import { CustomerOrdersNavigationService } from '@shared/services/navigation';
+import { first } from 'rxjs/operators';
+
+@Injectable({ providedIn: 'root' })
+export class CanActivateCustomerOrdersGuard {
+  constructor(
+    private readonly _applicationService: ApplicationService,
+    private readonly _checkoutService: DomainCheckoutService,
+    private readonly _navigationService: CustomerOrdersNavigationService,
+  ) {}
+
+  async canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot) {
+    const processes = await this._applicationService.getProcesses$('customer').pipe(first()).toPromise();
+
+    let lastActivatedProcessId = (
+      await this._applicationService.getLastActivatedProcessWithSectionAndType$('customer', 'cart').pipe(first()).toPromise()
+    )?.id;
+
+    const lastActivatedCartCheckoutProcessId = (
+      await this._applicationService.getLastActivatedProcessWithSectionAndType$('customer', 'cart-checkout').pipe(first()).toPromise()
+    )?.id;
+
+    const activatedProcessId = await this._applicationService.getActivatedProcessId$().pipe(first()).toPromise();
+
+    // Darf nur reinkommen wenn der aktuell aktive Tab ein Bestellabschluss Tab ist
+    if (!!lastActivatedCartCheckoutProcessId && lastActivatedCartCheckoutProcessId === activatedProcessId) {
+      await this.fromCartCheckoutProcess(processes, route, lastActivatedCartCheckoutProcessId);
+      return false;
+    }
+
+    if (!lastActivatedProcessId) {
+      await this.fromGoodsOutProcess(processes, route);
+      return false;
+    } else {
+      await this._navigationService.getCustomerOrdersBasePath(lastActivatedProcessId).navigate();
+    }
+
+    return false;
+  }
+
+  // Bei offenen Kundenbestellungen und Klick auf Kundenbestellungen
+  async fromGoodsOutProcess(processes: ApplicationProcess[], route: ActivatedRouteSnapshot) {
+    const newProcessId = Date.now();
+    await this._applicationService.createProcess({
+      id: newProcessId,
+      type: 'cart',
+      section: 'customer',
+      name: `Vorgang ${this.processNumber(processes.filter((process) => process.type === 'cart'))}`,
+    });
+
+    await this._navigationService.getCustomerOrdersBasePath(newProcessId).navigate();
+  }
+
+  // Bei offener Bestellbestätigung und Klick auf Kundenbestellungen
+  async fromCartCheckoutProcess(processes: ApplicationProcess[], route: ActivatedRouteSnapshot, processId: number) {
+    // Um alle Checkout Daten zu resetten die mit dem Prozess assoziiert sind
+    this._checkoutService.removeProcess({ processId });
+
+    // Ändere type cart-checkout zu customer-order
+    this._applicationService.patchProcess(processId, {
+      id: processId,
+      type: 'cart',
+      section: 'customer',
+      name: `Vorgang ${this.processNumber(processes.filter((process) => process.type === 'cart'))}`,
+      data: {},
+    });
+
+    // Navigation
+    await this._navigationService.getCustomerOrdersBasePath(processId).navigate();
+  }
+
+  getUrlFromSnapshot(route: ActivatedRouteSnapshot, url: string[] = []): string[] {
+    url.push(...route.url.map((segment) => segment.path));
+    if (route.firstChild) {
+      return this.getUrlFromSnapshot(route.firstChild, url);
+    }
+    return url.filter((segment) => !!segment);
+  }
+
+  processNumber(processes: ApplicationProcess[]) {
+    const processNumbers = processes?.map((process) => Number(process?.name?.replace(/\D/g, '')));
+    return !!processNumbers && processNumbers.length > 0 ? this.findMissingNumber(processNumbers) : 1;
+  }
+
+  findMissingNumber(processNumbers: number[]) {
+    for (let missingNumber = 1; missingNumber < Math.max(...processNumbers); missingNumber++) {
+      if (!processNumbers.find((number) => number === missingNumber)) {
+        return missingNumber;
+      }
+    }
+    return Math.max(...processNumbers) + 1;
+  }
+}

apps/isa-app/src/app/guards/can-activate-customer-with-process-id.guard.ts

@@ -0,0 +1,67 @@
+import { Injectable } from '@angular/core';
+import { ActivatedRouteSnapshot, RouterStateSnapshot } from '@angular/router';
+import { ApplicationProcess, ApplicationService } from '@core/application';
+import { BreadcrumbService } from '@core/breadcrumb';
+import { first } from 'rxjs/operators';
+
+@Injectable({ providedIn: 'root' })
+export class CanActivateCustomerWithProcessIdGuard {
+  constructor(private readonly _applicationService: ApplicationService, private readonly _breadcrumbService: BreadcrumbService) {}
+
+  async canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot) {
+    const process = await this._applicationService
+      .getProcessById$(+route.params.processId)
+      .pipe(first())
+      .toPromise();
+
+    // if (!(process?.type === 'cart')) {
+    //   // TODO:
+    //   // Anderer Prozesstyp mit gleicher Id - Was soll gemacht werden?
+    //   return false;
+    // }
+
+    if (!process) {
+      const processes = await this._applicationService.getProcesses$('customer').pipe(first()).toPromise();
+      await this._applicationService.createProcess({
+        id: +route.params.processId,
+        type: 'cart',
+        section: 'customer',
+        name: `Vorgang ${this.processNumber(processes.filter((process) => process.type === 'cart'))}`,
+      });
+    }
+
+    await this.removeBreadcrumbWithSameProcessId(route);
+    this._applicationService.activateProcess(+route.params.processId);
+    return true;
+  }
+
+  // Fix #3292: Alle Breadcrumbs die nichts mit dem aktuellen Prozess zu tun haben, müssen removed werden
+  async removeBreadcrumbWithSameProcessId(route: ActivatedRouteSnapshot) {
+    const crumbs = await this._breadcrumbService
+      .getBreadcrumbByKey$(+route.params.processId)
+      .pipe(first())
+      .toPromise();
+
+    // Entferne alle Crumbs die nichts mit der Kundensuche zu tun haben
+    if (crumbs.length > 1) {
+      const crumbsToRemove = crumbs.filter((crumb) => crumb.tags.find((tag) => tag === 'customer') === undefined);
+      for (const crumb of crumbsToRemove) {
+        await this._breadcrumbService.removeBreadcrumb(crumb.id);
+      }
+    }
+  }
+
+  processNumber(processes: ApplicationProcess[]) {
+    const processNumbers = processes?.map((process) => Number(process?.name?.replace(/\D/g, '')));
+    return !!processNumbers && processNumbers.length > 0 ? this.findMissingNumber(processNumbers) : 1;
+  }
+
+  findMissingNumber(processNumbers: number[]) {
+    for (let missingNumber = 1; missingNumber < Math.max(...processNumbers); missingNumber++) {
+      if (!processNumbers.find((number) => number === missingNumber)) {
+        return missingNumber;
+      }
+    }
+    return Math.max(...processNumbers) + 1;
+  }
+}

apps/isa-app/src/app/guards/can-activate-customer.guard.ts

@@ -0,0 +1,125 @@
+import { Injectable } from '@angular/core';
+import { ActivatedRouteSnapshot, Router, RouterStateSnapshot } from '@angular/router';
+import { ApplicationProcess, ApplicationService } from '@core/application';
+import { DomainCheckoutService } from '@domain/checkout';
+import { CustomerSearchNavigation } from '@shared/services/navigation';
+import { first } from 'rxjs/operators';
+
+@Injectable({ providedIn: 'root' })
+export class CanActivateCustomerGuard {
+  constructor(
+    private readonly _applicationService: ApplicationService,
+    private readonly _checkoutService: DomainCheckoutService,
+    private readonly _router: Router,
+    private readonly _navigation: CustomerSearchNavigation,
+  ) {}
+
+  async canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot) {
+    const processes = await this._applicationService.getProcesses$('customer').pipe(first()).toPromise();
+    let lastActivatedProcessId = (
+      await this._applicationService.getLastActivatedProcessWithSectionAndType$('customer', 'cart').pipe(first()).toPromise()
+    )?.id;
+
+    const lastActivatedCartCheckoutProcessId = (
+      await this._applicationService.getLastActivatedProcessWithSectionAndType$('customer', 'cart-checkout').pipe(first()).toPromise()
+    )?.id;
+
+    const lastActivatedGoodsOutProcessId = (
+      await this._applicationService.getLastActivatedProcessWithSectionAndType$('customer', 'goods-out').pipe(first()).toPromise()
+    )?.id;
+
+    const activatedProcessId = await this._applicationService.getActivatedProcessId$().pipe(first()).toPromise();
+
+    // Darf nur reinkommen wenn der aktuell aktive Tab ein Bestellabschluss Tab ist
+    if (!!lastActivatedCartCheckoutProcessId && lastActivatedCartCheckoutProcessId === activatedProcessId) {
+      await this.fromCartCheckoutProcess(processes, lastActivatedCartCheckoutProcessId);
+      return false;
+    } else if (!!lastActivatedGoodsOutProcessId && lastActivatedGoodsOutProcessId === activatedProcessId) {
+      await this.fromGoodsOutProcess(processes, lastActivatedGoodsOutProcessId);
+      return false;
+    }
+
+    if (!lastActivatedProcessId) {
+      await this.fromCartProcess(processes);
+      return false;
+    } else {
+      await this.navigateToDefaultRoute(lastActivatedProcessId);
+    }
+    return false;
+  }
+
+  async navigateToDefaultRoute(processId: number) {
+    const route = this._navigation.defaultRoute({ processId });
+
+    await this._router.navigate(route.path, { queryParams: route.queryParams });
+  }
+
+  // Bei offener Artikelsuche/Kundensuche und Klick auf Footer Kundensuche
+  async fromCartProcess(processes: ApplicationProcess[]) {
+    const newProcessId = Date.now();
+    await this._applicationService.createProcess({
+      id: newProcessId,
+      type: 'cart',
+      section: 'customer',
+      name: `Vorgang ${this.processNumber(processes.filter((process) => process.type === 'cart'))}`,
+    });
+
+    await this.navigateToDefaultRoute(newProcessId);
+  }
+
+  // Bei offener Bestellbestätigung und Klick auf Footer Kundensuche
+  async fromCartCheckoutProcess(processes: ApplicationProcess[], processId: number) {
+    // Um alle Checkout Daten zu resetten die mit dem Prozess assoziiert sind
+    this._checkoutService.removeProcess({ processId });
+
+    // Ändere type cart-checkout zu cart
+    this._applicationService.patchProcess(processId, {
+      id: processId,
+      type: 'cart',
+      section: 'customer',
+      name: `Vorgang ${this.processNumber(processes.filter((process) => process.type === 'cart'))}`,
+      data: {},
+    });
+
+    // Navigation
+    await this.navigateToDefaultRoute(processId);
+  }
+
+  // Bei offener Warenausgabe und Klick auf Footer Kundensuche
+  async fromGoodsOutProcess(processes: ApplicationProcess[], processId: number) {
+    const buyer = await this._checkoutService.getBuyer({ processId }).pipe(first()).toPromise();
+    const customerFeatures = await this._checkoutService.getCustomerFeatures({ processId }).pipe(first()).toPromise();
+    const name = buyer
+      ? customerFeatures?.b2b
+        ? buyer.organisation?.name
+          ? buyer.organisation?.name
+          : buyer.lastName
+        : buyer.lastName
+      : `Vorgang ${this.processNumber(processes.filter((process) => process.type === 'cart'))}`;
+
+    // Ändere type goods-out zu cart
+    this._applicationService.patchProcess(processId, {
+      id: processId,
+      type: 'cart',
+      section: 'customer',
+      name,
+    });
+
+    // Navigation
+    await this.navigateToDefaultRoute(processId);
+  }
+
+  processNumber(processes: ApplicationProcess[]) {
+    const processNumbers = processes?.map((process) => Number(process?.name?.replace(/\D/g, '')));
+    return !!processNumbers && processNumbers.length > 0 ? this.findMissingNumber(processNumbers) : 1;
+  }
+
+  findMissingNumber(processNumbers: number[]) {
+    for (let missingNumber = 1; missingNumber < Math.max(...processNumbers); missingNumber++) {
+      if (!processNumbers.find((number) => number === missingNumber)) {
+        return missingNumber;
+      }
+    }
+    return Math.max(...processNumbers) + 1;
+  }
+}

apps/isa-app/src/app/guards/can-activate-goods-in.guard.ts

@@ -0,0 +1,24 @@
+import { Injectable } from '@angular/core';
+import { ActivatedRouteSnapshot, RouterStateSnapshot } from '@angular/router';
+import { ApplicationService } from '@core/application';
+import { Config } from '@core/config';
+import { first } from 'rxjs/operators';
+
+@Injectable({ providedIn: 'root' })
+export class CanActivateGoodsInGuard {
+  constructor(private readonly _applicationService: ApplicationService, private readonly _config: Config) {}
+
+  async canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot) {
+    const process = await this._applicationService.getProcessById$(this._config.get('process.ids.goodsIn')).pipe(first()).toPromise();
+    if (!process) {
+      await this._applicationService.createProcess({
+        id: this._config.get('process.ids.goodsIn'),
+        type: 'goods-in',
+        section: 'branch',
+        name: '',
+      });
+    }
+    this._applicationService.activateProcess(this._config.get('process.ids.goodsIn'));
+    return true;
+  }
+}

apps/isa-app/src/app/guards/can-activate-goods-out-with-process-id.guard.ts

@@ -0,0 +1,52 @@
+import { Injectable } from '@angular/core';
+import { ActivatedRouteSnapshot, RouterStateSnapshot } from '@angular/router';
+import { ApplicationProcess, ApplicationService } from '@core/application';
+import { BreadcrumbService } from '@core/breadcrumb';
+import { first } from 'rxjs/operators';
+
+@Injectable({ providedIn: 'root' })
+export class CanActivateGoodsOutWithProcessIdGuard {
+  constructor(private readonly _applicationService: ApplicationService, private readonly _breadcrumbService: BreadcrumbService) {}
+
+  async canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot) {
+    const process = await this._applicationService
+      .getProcessById$(+route.params.processId)
+      .pipe(first())
+      .toPromise();
+
+    if (!process) {
+      // const processes = await this._applicationService.getProcesses$('customer').pipe(first()).toPromise();
+      await this._applicationService.createProcess({
+        id: +route.params.processId,
+        type: 'goods-out',
+        section: 'customer',
+        name: `Warenausgabe`,
+      });
+    }
+
+    await this.removeBreadcrumbWithSameProcessId(route);
+    this._applicationService.activateProcess(+route.params.processId);
+    return true;
+  }
+
+  // Fix #3292: Alle Breadcrumbs die nichts mit dem aktuellen Prozess zu tun haben, müssen removed werden
+  async removeBreadcrumbWithSameProcessId(route: ActivatedRouteSnapshot) {
+    const crumbs = await this._breadcrumbService
+      .getBreadcrumbByKey$(+route.params.processId)
+      .pipe(first())
+      .toPromise();
+
+    // Entferne alle Crumbs die nichts mit der Warenausgabe zu tun haben
+    if (crumbs.length > 1) {
+      const crumbsToRemove = crumbs.filter((crumb) => crumb.tags.find((tag) => tag === 'goods-out') === undefined);
+      for (const crumb of crumbsToRemove) {
+        await this._breadcrumbService.removeBreadcrumb(crumb.id);
+      }
+    }
+  }
+
+  processNumber(processes: ApplicationProcess[]) {
+    const processNumbers = processes?.map((process) => Number(process?.name?.replace(/\D/g, '')));
+    return !!processNumbers && processNumbers?.length > 0 ? Math.max(...processNumbers) + 1 : 1;
+  }
+}

apps/isa-app/src/app/guards/can-activate-goods-out.guard.ts

@@ -0,0 +1,183 @@
+import { Injectable } from '@angular/core';
+import { ActivatedRouteSnapshot, Router, RouterStateSnapshot } from '@angular/router';
+import { ApplicationProcess, ApplicationService } from '@core/application';
+import { DomainCheckoutService } from '@domain/checkout';
+import { first } from 'rxjs/operators';
+
+@Injectable({ providedIn: 'root' })
+export class CanActivateGoodsOutGuard {
+  constructor(
+    private readonly _applicationService: ApplicationService,
+    private readonly _checkoutService: DomainCheckoutService,
+    private readonly _router: Router
+  ) {}
+
+  // !!! Ticket #3272 Code soll vorerst bestehen bleiben. Prozess Warenausgabe soll wieder Vorgang heißen (wie aktuell im Produktiv), bis zum neuen Navigationskonzept
+  // -----------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+  // async canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot) {
+  //   const processes = await this._applicationService.getProcesses$('customer').pipe(first()).toPromise();
+
+  //   let lastActivatedProcessId = (
+  //     await this._applicationService.getLastActivatedProcessWithSectionAndType$('customer', 'goods-out').pipe(first()).toPromise()
+  //   )?.id;
+
+  //   const lastActivatedCartProcessId = (
+  //     await this._applicationService.getLastActivatedProcessWithSectionAndType$('customer', 'cart').pipe(first()).toPromise()
+  //   )?.id;
+
+  //   const lastActivatedCartCheckoutProcessId = (
+  //     await this._applicationService.getLastActivatedProcessWithSectionAndType$('customer', 'cart-checkout').pipe(first()).toPromise()
+  //   )?.id;
+
+  //   const activatedProcessId = await this._applicationService.getActivatedProcessId$().pipe(first()).toPromise();
+
+  //   // Darf nur reinkommen wenn der aktuell aktive Tab ein Bestellabschluss Tab ist
+  //   if (!!lastActivatedCartProcessId && lastActivatedCartProcessId === activatedProcessId) {
+  //     await this.fromCartProcess(processes, route, lastActivatedCartProcessId);
+  //     return false;
+  //   } else if (!!lastActivatedCartCheckoutProcessId && lastActivatedCartCheckoutProcessId === activatedProcessId) {
+  //     await this.fromCartCheckoutProcess(processes, route, lastActivatedCartCheckoutProcessId);
+  //     return false;
+  //   }
+
+  //   if (!lastActivatedProcessId) {
+  //     await this.fromGoodsOutProcess(processes, route);
+  //     return false;
+  //   } else {
+  //     await this._router.navigate(this.getUrlFromSnapshot(route, ['/kunde', String(lastActivatedProcessId)]));
+  //   }
+
+  //   return false;
+  // }
+
+  // // Bei offener Warenausgabe und Klick auf Footer Warenausgabe
+  // async fromGoodsOutProcess(processes: ApplicationProcess[], route: ActivatedRouteSnapshot) {
+  //   const newProcessId = Date.now();
+  //   await this._applicationService.createProcess({
+  //     id: newProcessId,
+  //     type: 'goods-out',
+  //     section: 'customer',
+  //     name: `Warenausgabe ${this.processNumber(processes.filter((process) => process.type === 'goods-out'))}`,
+  //   });
+
+  //   await this._router.navigate(this.getUrlFromSnapshot(route, ['/kunde', String(newProcessId)]));
+  // }
+
+  // // Bei offener Artikelsuche/Kundensuche und Klick auf Footer Warenausgabe
+  // async fromCartProcess(processes: ApplicationProcess[], route: ActivatedRouteSnapshot, processId: number) {
+  //   // Ändere type cart zu goods-out
+  //   this._applicationService.patchProcess(processId, {
+  //     id: processId,
+  //     type: 'goods-out',
+  //     section: 'customer',
+  //     name: `Warenausgabe ${this.processNumber(processes.filter((process) => process.type === 'goods-out'))}`,
+  //   });
+
+  //   // Navigation
+  //   await this._router.navigate(this.getUrlFromSnapshot(route, ['/kunde', String(processId)]));
+  // }
+
+  // // Bei offener Bestellbestätigung, Artikelsuche/Kundensuche und Klick auf Footer Warenausgabe
+  // async fromCartCheckoutProcess(processes: ApplicationProcess[], route: ActivatedRouteSnapshot, processId: number) {
+  //   // Um alle Checkout Daten zu resetten die mit dem Prozess assoziiert sind
+  //   this._checkoutService.removeProcess({ processId });
+
+  //   // Ändere type cart-checkout zu goods-out
+  //   this._applicationService.patchProcess(processId, {
+  //     id: processId,
+  //     type: 'goods-out',
+  //     section: 'customer',
+  //     name: `Warenausgabe ${this.processNumber(processes.filter((process) => process.type === 'goods-out'))}`,
+  //     data: {},
+  //   });
+
+  //   // Navigation
+  //   await this._router.navigate(this.getUrlFromSnapshot(route, ['/kunde', String(processId)]));
+  // }
+
+  // !!! Ticket #3272 Code soll vorerst bestehen bleiben. Prozess Warenausgabe soll wieder Vorgang heißen (wie aktuell im Produktiv), bis zum neuen Navigationskonzept
+  // -----------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+  async canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot) {
+    const processes = await this._applicationService.getProcesses$('customer').pipe(first()).toPromise();
+
+    let lastActivatedProcessId = (
+      await this._applicationService.getLastActivatedProcessWithSectionAndType$('customer', 'cart').pipe(first()).toPromise()
+    )?.id;
+
+    const lastActivatedCartCheckoutProcessId = (
+      await this._applicationService.getLastActivatedProcessWithSectionAndType$('customer', 'cart-checkout').pipe(first()).toPromise()
+    )?.id;
+
+    const activatedProcessId = await this._applicationService.getActivatedProcessId$().pipe(first()).toPromise();
+
+    // Darf nur reinkommen wenn der aktuell aktive Tab ein Bestellabschluss Tab ist
+    if (!!lastActivatedCartCheckoutProcessId && lastActivatedCartCheckoutProcessId === activatedProcessId) {
+      await this.fromCartCheckoutProcess(processes, route, lastActivatedCartCheckoutProcessId);
+      return false;
+    }
+
+    if (!lastActivatedProcessId) {
+      await this.fromGoodsOutProcess(processes, route);
+      return false;
+    } else {
+      await this._router.navigate(this.getUrlFromSnapshot(route, ['/kunde', String(lastActivatedProcessId)]));
+    }
+
+    return false;
+  }
+
+  // Bei offener Warenausgabe und Klick auf Footer Warenausgabe
+  async fromGoodsOutProcess(processes: ApplicationProcess[], route: ActivatedRouteSnapshot) {
+    const newProcessId = Date.now();
+    await this._applicationService.createProcess({
+      id: newProcessId,
+      type: 'cart',
+      section: 'customer',
+      name: `Vorgang ${this.processNumber(processes.filter((process) => process.type === 'cart'))}`,
+    });
+
+    await this._router.navigate(this.getUrlFromSnapshot(route, ['/kunde', String(newProcessId)]));
+  }
+
+  // Bei offener Bestellbestätigung und Klick auf Footer Warenausgabe
+  async fromCartCheckoutProcess(processes: ApplicationProcess[], route: ActivatedRouteSnapshot, processId: number) {
+    // Um alle Checkout Daten zu resetten die mit dem Prozess assoziiert sind
+    this._checkoutService.removeProcess({ processId });
+
+    // Ändere type cart-checkout zu goods-out
+    this._applicationService.patchProcess(processId, {
+      id: processId,
+      type: 'cart',
+      section: 'customer',
+      name: `Vorgang ${this.processNumber(processes.filter((process) => process.type === 'cart'))}`,
+      data: {},
+    });
+
+    // Navigation
+    await this._router.navigate(this.getUrlFromSnapshot(route, ['/kunde', String(processId)]));
+  }
+
+  getUrlFromSnapshot(route: ActivatedRouteSnapshot, url: string[] = []): string[] {
+    url.push(...route.url.map((segment) => segment.path));
+    if (route.firstChild) {
+      return this.getUrlFromSnapshot(route.firstChild, url);
+    }
+    return url.filter((segment) => !!segment);
+  }
+
+  processNumber(processes: ApplicationProcess[]) {
+    const processNumbers = processes?.map((process) => Number(process?.name?.replace(/\D/g, '')));
+    return !!processNumbers && processNumbers.length > 0 ? this.findMissingNumber(processNumbers) : 1;
+  }
+
+  findMissingNumber(processNumbers: number[]) {
+    for (let missingNumber = 1; missingNumber < Math.max(...processNumbers); missingNumber++) {
+      if (!processNumbers.find((number) => number === missingNumber)) {
+        return missingNumber;
+      }
+    }
+    return Math.max(...processNumbers) + 1;
+  }
+}

apps/isa-app/src/app/guards/can-activate-package-inspection.guard.ts

@@ -0,0 +1,27 @@
+import { Injectable } from '@angular/core';
+import { ActivatedRouteSnapshot, RouterStateSnapshot } from '@angular/router';
+import { ApplicationService } from '@core/application';
+import { Config } from '@core/config';
+import { first } from 'rxjs/operators';
+
+@Injectable({ providedIn: 'root' })
+export class CanActivatePackageInspectionGuard {
+  constructor(private readonly _applicationService: ApplicationService, private readonly _config: Config) {}
+
+  async canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot) {
+    const process = await this._applicationService
+      .getProcessById$(this._config.get('process.ids.packageInspection'))
+      .pipe(first())
+      .toPromise();
+    if (!process) {
+      await this._applicationService.createProcess({
+        id: this._config.get('process.ids.packageInspection'),
+        type: 'package-inspection',
+        section: 'branch',
+        name: 'Packstück-Kontrolle',
+      });
+    }
+    this._applicationService.activateProcess(this._config.get('process.ids.packageInspection'));
+    return true;
+  }
+}

apps/isa-app/src/app/guards/can-activate-product-with-process-id.guard.ts

@@ -0,0 +1,70 @@
+import { Injectable } from '@angular/core';
+import { ActivatedRouteSnapshot, RouterStateSnapshot } from '@angular/router';
+import { ApplicationProcess, ApplicationService } from '@core/application';
+import { BreadcrumbService } from '@core/breadcrumb';
+import { first } from 'rxjs/operators';
+
+@Injectable({ providedIn: 'root' })
+export class CanActivateProductWithProcessIdGuard {
+  constructor(private readonly _applicationService: ApplicationService, private readonly _breadcrumbService: BreadcrumbService) {}
+
+  async canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot) {
+    const process = await this._applicationService
+      .getProcessById$(+route.params.processId)
+      .pipe(first())
+      .toPromise();
+
+    // if (!(process?.type === 'cart')) {
+    //   // TODO:
+    //   // Anderer Prozesstyp mit gleicher Id - Was soll gemacht werden?
+    //   return false;
+    // }
+
+    if (!process) {
+      const processes = await this._applicationService.getProcesses$('customer').pipe(first()).toPromise();
+      await this._applicationService.createProcess({
+        id: +route.params.processId,
+        type: 'cart',
+        section: 'customer',
+        name: `Vorgang ${this.processNumber(processes.filter((process) => process.type === 'cart'))}`,
+      });
+    }
+
+    await this.removeBreadcrumbWithSameProcessId(route);
+    this._applicationService.activateProcess(+route.params.processId);
+    return true;
+  }
+
+  // Fix #3292: Alle Breadcrumbs die nichts mit dem aktuellen Prozess zu tun haben, müssen removed werden
+  async removeBreadcrumbWithSameProcessId(route: ActivatedRouteSnapshot) {
+    const crumbs = await this._breadcrumbService
+      .getBreadcrumbByKey$(+route.params.processId)
+      .pipe(first())
+      .toPromise();
+
+    // Entferne alle Crumbs die nichts mit der Artikelsuche zu tun haben
+    if (crumbs.length > 1) {
+      const crumbsToRemove = crumbs.filter((crumb) => crumb.tags.find((tag) => tag === 'catalog') === undefined);
+      for (const crumb of crumbsToRemove) {
+        await this._breadcrumbService.removeBreadcrumb(crumb.id);
+      }
+    }
+  }
+
+  processNumber(processes: ApplicationProcess[]) {
+    const processNumbers = processes?.map((process) => Number(process?.name?.replace(/\D/g, '')));
+    return !!processNumbers && processNumbers.length > 0 ? this.findMissingNumber(processNumbers) : 1;
+  }
+
+  findMissingNumber(processNumbers: number[]) {
+    // Ticket #3272 Bei Klick auf "+" bzw. neuen Prozess hinzufügen soll der neue Tab immer die höchste Nummer haben (wie aktuell im Produktiv)
+    // ----------------------------------------------------------------------------------------------------------------------------------------
+
+    // for (let missingNumber = 1; missingNumber < Math.max(...processNumbers); missingNumber++) {
+    //   if (!processNumbers.find((number) => number === missingNumber)) {
+    //     return missingNumber;
+    //   }
+    // }
+    return Math.max(...processNumbers) + 1;
+  }
+}

apps/isa-app/src/app/guards/can-activate-product.guard.ts

@@ -0,0 +1,127 @@
+import { Injectable } from '@angular/core';
+import { ActivatedRouteSnapshot, RouterStateSnapshot } from '@angular/router';
+import { ApplicationProcess, ApplicationService } from '@core/application';
+import { DomainCheckoutService } from '@domain/checkout';
+import { ProductCatalogNavigationService } from '@shared/services/navigation';
+import { first } from 'rxjs/operators';
+
+@Injectable({ providedIn: 'root' })
+export class CanActivateProductGuard {
+  constructor(
+    private readonly _applicationService: ApplicationService,
+    private readonly _checkoutService: DomainCheckoutService,
+    private readonly _navigationService: ProductCatalogNavigationService,
+  ) {}
+
+  async canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot) {
+    const processes = await this._applicationService.getProcesses$('customer').pipe(first()).toPromise();
+    let lastActivatedProcessId = (
+      await this._applicationService.getLastActivatedProcessWithSectionAndType$('customer', 'cart').pipe(first()).toPromise()
+    )?.id;
+
+    const lastActivatedCartCheckoutProcessId = (
+      await this._applicationService.getLastActivatedProcessWithSectionAndType$('customer', 'cart-checkout').pipe(first()).toPromise()
+    )?.id;
+
+    const lastActivatedGoodsOutProcessId = (
+      await this._applicationService.getLastActivatedProcessWithSectionAndType$('customer', 'goods-out').pipe(first()).toPromise()
+    )?.id;
+
+    const activatedProcessId = await this._applicationService.getActivatedProcessId$().pipe(first()).toPromise();
+
+    // Darf nur reinkommen wenn der aktuell aktive Tab ein Bestellabschluss Tab ist
+    if (!!lastActivatedCartCheckoutProcessId && lastActivatedCartCheckoutProcessId === activatedProcessId) {
+      await this.fromCartCheckoutProcess(processes, route, lastActivatedCartCheckoutProcessId);
+      return false;
+    } else if (!!lastActivatedGoodsOutProcessId && lastActivatedGoodsOutProcessId === activatedProcessId) {
+      await this.fromGoodsOutProcess(processes, route, lastActivatedGoodsOutProcessId);
+      return false;
+    }
+
+    if (!lastActivatedProcessId) {
+      await this.fromCartProcess(processes);
+      return false;
+    } else {
+      await this._navigationService.getArticleSearchBasePath(lastActivatedProcessId).navigate();
+    }
+
+    return false;
+  }
+
+  // Bei offener Artikelsuche/Kundensuche und Klick auf Footer Artikelsuche
+  async fromCartProcess(processes: ApplicationProcess[]) {
+    const newProcessId = Date.now();
+    await this._applicationService.createProcess({
+      id: newProcessId,
+      type: 'cart',
+      section: 'customer',
+      name: `Vorgang ${this.processNumber(processes.filter((process) => process.type === 'cart'))}`,
+    });
+
+    await this._navigationService.getArticleSearchBasePath(newProcessId).navigate();
+  }
+
+  // Bei offener Warenausgabe und Klick auf Footer Artikelsuche
+  async fromGoodsOutProcess(processes: ApplicationProcess[], route: ActivatedRouteSnapshot, processId: number) {
+    const buyer = await this._checkoutService.getBuyer({ processId }).pipe(first()).toPromise();
+    const customerFeatures = await this._checkoutService.getCustomerFeatures({ processId }).pipe(first()).toPromise();
+    const name = buyer
+      ? customerFeatures?.b2b
+        ? buyer.organisation?.name
+          ? buyer.organisation?.name
+          : buyer.lastName
+        : buyer.lastName
+      : `Vorgang ${this.processNumber(processes.filter((process) => process.type === 'cart'))}`;
+
+    // Ändere type goods-out zu cart
+    this._applicationService.patchProcess(processId, {
+      id: processId,
+      type: 'cart',
+      section: 'customer',
+      name,
+    });
+
+    // Navigation
+    await this._navigationService.getArticleSearchBasePath(processId).navigate();
+  }
+
+  // Bei offener Bestellbestätigung und Klick auf Footer Artikelsuche
+  async fromCartCheckoutProcess(processes: ApplicationProcess[], route: ActivatedRouteSnapshot, processId: number) {
+    // Um alle Checkout Daten zu resetten die mit dem Prozess assoziiert sind
+    this._checkoutService.removeProcess({ processId });
+
+    // Ändere type cart-checkout zu cart
+    this._applicationService.patchProcess(processId, {
+      id: processId,
+      type: 'cart',
+      section: 'customer',
+      name: `Vorgang ${this.processNumber(processes.filter((process) => process.type === 'cart'))}`,
+      data: {},
+    });
+
+    // Navigation
+    await this._navigationService.getArticleSearchBasePath(processId).navigate();
+  }
+
+  getUrlFromSnapshot(route: ActivatedRouteSnapshot, url: string[] = []): string[] {
+    url.push(...route.url.map((segment) => segment.path));
+    if (route.firstChild) {
+      return this.getUrlFromSnapshot(route.firstChild, url);
+    }
+    return url.filter((segment) => !!segment);
+  }
+
+  processNumber(processes: ApplicationProcess[]) {
+    const processNumbers = processes?.map((process) => Number(process?.name?.replace(/\D/g, '')));
+    return !!processNumbers && processNumbers.length > 0 ? this.findMissingNumber(processNumbers) : 1;
+  }
+
+  findMissingNumber(processNumbers: number[]) {
+    for (let missingNumber = 1; missingNumber < Math.max(...processNumbers); missingNumber++) {
+      if (!processNumbers.find((number) => number === missingNumber)) {
+        return missingNumber;
+      }
+    }
+    return Math.max(...processNumbers) + 1;
+  }
+}

apps/isa-app/src/app/guards/can-activate-remission.guard.ts

@@ -0,0 +1,36 @@
+import { Injectable } from '@angular/core';
+import { ActivatedRouteSnapshot, Router, RouterStateSnapshot } from '@angular/router';
+import { ApplicationService } from '@core/application';
+import { Config } from '@core/config';
+import { first } from 'rxjs/operators';
+
+@Injectable({ providedIn: 'root' })
+export class CanActivateRemissionGuard {
+  constructor(
+    private readonly _applicationService: ApplicationService,
+    private readonly _config: Config,
+    private readonly _router: Router
+  ) {}
+
+  async canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot) {
+    const process = await this._applicationService.getProcessById$(this._config.get('process.ids.remission')).pipe(first()).toPromise();
+    if (!process) {
+      await this._applicationService.createProcess({
+        id: this._config.get('process.ids.remission'),
+        type: 'remission',
+        section: 'branch',
+        name: 'Remission',
+      });
+    }
+
+    this._applicationService.activateProcess(this._config.get('process.ids.remission'));
+
+    if (!!process?.data?.active && !state.url.includes(`/filiale/remission/${process?.data?.active}`)) {
+      const queryParams = process?.data?.queryParams ?? {};
+      await this._router.navigate(['/filiale', 'remission', process?.data?.active, 'list'], { queryParams });
+      return false;
+    } else {
+      return true;
+    }
+  }
+}

apps/isa-app/src/app/guards/can-activate-task-calendar.guard.ts

@@ -0,0 +1,24 @@
+import { Injectable } from '@angular/core';
+import { ActivatedRouteSnapshot, RouterStateSnapshot } from '@angular/router';
+import { ApplicationService } from '@core/application';
+import { Config } from '@core/config';
+import { first } from 'rxjs/operators';
+
+@Injectable({ providedIn: 'root' })
+export class CanActivateTaskCalendarGuard {
+  constructor(private readonly _applicationService: ApplicationService, private readonly _config: Config) {}
+
+  async canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot) {
+    const process = await this._applicationService.getProcessById$(this._config.get('process.ids.taskCalendar')).pipe(first()).toPromise();
+    if (!process) {
+      await this._applicationService.createProcess({
+        id: this._config.get('process.ids.taskCalendar'),
+        type: 'task-calendar',
+        section: 'branch',
+        name: 'Tätigkeitskalender',
+      });
+    }
+    this._applicationService.activateProcess(this._config.get('process.ids.taskCalendar'));
+    return true;
+  }
+}

apps/isa-app/src/app/guards/index.ts

@@ -0,0 +1,14 @@
+export * from './can-activate-cart-with-process-id.guard';
+export * from './can-activate-cart.guard';
+export * from './can-activate-customer-with-process-id.guard';
+export * from './can-activate-customer.guard';
+export * from './can-activate-goods-in.guard';
+export * from './can-activate-goods-out-with-process-id.guard';
+export * from './can-activate-goods-out.guard';
+export * from './can-activate-customer-orders.guard';
+export * from './can-activate-customer-orders-with-process-id.guard';
+export * from './can-activate-product-with-process-id.guard';
+export * from './can-activate-product.guard';
+export * from './can-activate-remission.guard';
+export * from './can-activate-task-calendar.guard';
+export * from './is-authenticated.guard';

apps/isa-app/src/app/guards/is-authenticated.guard.ts

@@ -0,0 +1,94 @@
+import { Injectable } from '@angular/core';
+import { ActivatedRouteSnapshot, Router, RouterStateSnapshot } from '@angular/router';
+import { AuthService } from '@core/auth';
+import { ScanAdapterService } from '@adapter/scan';
+import { AuthService as IsaAuthService } from '@swagger/isa';
+import { UiConfirmModalComponent, UiErrorModalComponent, UiModalResult, UiModalService } from '@ui/modal';
+import { EnvironmentService } from '@core/environment';
+import { injectNetworkStatus$ } from '../services/network-status.service';
+import { toSignal } from '@angular/core/rxjs-interop';
+
+@Injectable({ providedIn: 'root' })
+export class IsAuthenticatedGuard {
+  constructor(
+    private _router: Router,
+    private _authService: AuthService,
+    private _scanService: ScanAdapterService,
+    private _isaAuthService: IsaAuthService,
+    private _modal: UiModalService,
+    private _environmentService: EnvironmentService,
+  ) {}
+
+  networkStatus = toSignal(injectNetworkStatus$());
+
+  async canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot) {
+    const authenticated = await this._authService.isAuthenticated();
+
+    if (!authenticated) {
+      const token = await this.scanAndGetToken();
+
+      if (token) {
+        this._authService.setKeyCardToken(token);
+      }
+      this._authService.login();
+    }
+
+    return authenticated;
+  }
+
+  async scanAndGetToken(): Promise<string> {
+    if (this._environmentService.isDesktop()) {
+      return undefined;
+    }
+
+    let loginModalResult: UiModalResult<any>;
+
+    do {
+      const loginModal = this._modal.open({
+        content: UiConfirmModalComponent,
+        title: 'Anmeldung',
+        data: {
+          message: 'Bitte wählen Sie die Anmeldeoption aus.',
+          rejectLabel: 'Anmeldung mit Logindaten',
+          confirmLabel: 'Anmeldung mit Keycard',
+        },
+      });
+
+      loginModalResult = await loginModal.afterClosed$.toPromise();
+    } while (this.networkStatus() === 'offline');
+
+    if (!loginModalResult.data) {
+      return undefined;
+    }
+
+    const result = await this._scanService.scan()?.toPromise();
+
+    if (typeof result === 'string') {
+      try {
+        const res = await this._isaAuthService
+          .AuthLogin({
+            code: result,
+            application: 'isa',
+            hostname: location.host,
+          })
+          .toPromise();
+
+        return res.token;
+      } catch (error) {
+        const errorModalRef = this._modal.open({
+          content: UiErrorModalComponent,
+          title: 'Fehler bei der Anmeldung',
+          data: {
+            message: 'Versuchen Sie es erneut\noder melden Sie sich mit\nIhren Benutzerdaten an.',
+          },
+        });
+
+        await errorModalRef.afterClosed$.toPromise();
+
+        return this.scanAndGetToken();
+      }
+    }
+
+    return undefined;
+  }
+}

apps/isa-app/src/app/guards/process-id.guard.ts

@@ -0,0 +1,33 @@
+import { inject } from '@angular/core';
+import { ActivatedRouteSnapshot, CanActivateFn, Router, RouterStateSnapshot, UrlTree } from '@angular/router';
+import { ApplicationService } from '@core/application';
+import { take } from 'rxjs/operators';
+
+export const ProcessIdGuard: CanActivateFn = async (
+  route: ActivatedRouteSnapshot,
+  state: RouterStateSnapshot
+): Promise<boolean | UrlTree> => {
+  const application = inject(ApplicationService);
+  const router = inject(Router);
+
+  const process = await application.getLastActivatedProcessWithSection$('customer').pipe(take(1)).toPromise();
+
+  const processId = process?.id ?? Date.now();
+
+  const originalUrl = state.url?.split('?')[0] ?? '';
+
+  let url: string = '';
+
+  if (originalUrl.startsWith('/kunde')) {
+    url = originalUrl.replace('/kunde', `/kunde/${processId}`);
+  } else {
+    url = originalUrl;
+  }
+
+  if (originalUrl === url) {
+    return true;
+  }
+
+  await router.navigateByUrl(url);
+  return false;
+};

apps/isa-app/src/app/interceptors/http-error.interceptor.spec.ts

@@ -0,0 +1,66 @@
+// import { HttpErrorInterceptor } from './http-error.interceptor';
+// import { createServiceFactory, SpectatorService } from '@ngneat/spectator';
+// import { UiMessageModalComponent, UiModalResult, UiModalService } from '@ui/modal';
+// import { of, Subject, throwError } from 'rxjs';
+// import { HttpErrorResponse } from '@angular/common/http';
+// import { AuthService } from '@core/auth';
+
+// describe('HttpErrorInterceptor', () => {
+//   let spectator: SpectatorService<HttpErrorInterceptor>;
+//   let modalMock: jasmine.SpyObj<UiModalService>;
+//   let httpErrorInterceptor: HttpErrorInterceptor;
+
+//   const createService = createServiceFactory({
+//     service: HttpErrorInterceptor,
+//     mocks: [UiModalService, AuthService],
+//   });
+
+//   beforeEach(() => {
+//     spectator = createService();
+//     httpErrorInterceptor = spectator.service;
+//     modalMock = spectator.inject(UiModalService);
+
+//     modalMock.open.and.returnValue({
+//       afterClosed$: of({} as UiModalResult<any>),
+//     } as any);
+//   });
+
+//   it('should be created', () => {
+//     expect(httpErrorInterceptor).toBeTruthy();
+//   });
+
+//   describe('intercept', () => {
+//     it('should catch the error and call handleError', (done) => {
+//       const error = new HttpErrorResponse({
+//         status: 0,
+//         statusText: '',
+//         url: '',
+//       });
+
+//       const handleErrorSpy = spyOn(httpErrorInterceptor, 'handleError').and.callThrough();
+//       httpErrorInterceptor.intercept(null, { handle: () => throwError(error) }).subscribe({
+//         error: () => {
+//           expect(handleErrorSpy).toHaveBeenCalledWith(error);
+//           done();
+//         },
+//       });
+//     });
+//   });
+
+//   describe('handleError', () => {
+//     it('should call modal.open with offline message if status is 0', () => {
+//       const error = {
+//         error: {
+//           message: 'test',
+//         },
+//         status: 0,
+//       };
+//       httpErrorInterceptor.handleError(error as any);
+//       expect(modalMock.open).toHaveBeenCalledWith({
+//         content: UiMessageModalComponent,
+//         title: 'Sie sind offline, keine Verbindung zum Netzwerk',
+//         data: { message: 'Bereits geladene Inhalte werden angezeigt. Interaktionen sind aktuell nicht möglich.' },
+//       });
+//     });
+//   });
+// });

apps/isa-app/src/app/interceptors/http-error.interceptor.ts

@@ -0,0 +1,50 @@
+import { Injectable } from '@angular/core';
+import { HttpInterceptor, HttpEvent, HttpHandler, HttpRequest, HttpErrorResponse } from '@angular/common/http';
+import { NEVER, Observable, throwError } from 'rxjs';
+import { UiMessageModalComponent, UiModalService } from '@ui/modal';
+import { catchError, filter, mergeMap, takeUntil, tap } from 'rxjs/operators';
+import { AuthService } from '@core/auth';
+import { IsaLogProvider } from '../providers';
+import { LogLevel } from '@core/logger';
+import { injectOnline$ } from '../services/network-status.service';
+
+@Injectable()
+export class HttpErrorInterceptor implements HttpInterceptor {
+  readonly offline$ = injectOnline$().pipe(filter((online) => !online));
+
+  constructor(
+    private _modal: UiModalService,
+    private _auth: AuthService,
+    private _isaLogProvider: IsaLogProvider,
+  ) {}
+
+  intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
+    return next.handle(req).pipe(
+      takeUntil(this.offline$),
+      catchError((error: HttpErrorResponse, caught: any) => this.handleError(error)),
+    );
+  }
+
+  handleError(error: HttpErrorResponse): Observable<any> {
+    if (error.status === 401) {
+      return this._modal
+        .open({
+          content: UiMessageModalComponent,
+          title: 'Sie sind nicht mehr angemeldet',
+          data: { message: 'Sie werden neu angemeldet' },
+        })
+        .afterClosed$.pipe(
+          tap(() => {
+            this._auth.login();
+          }),
+          mergeMap(() => NEVER),
+        );
+    }
+
+    if (!error.url.endsWith('/isa/logging')) {
+      this._isaLogProvider.log(LogLevel.ERROR, 'Http Error', error);
+    }
+
+    return throwError(error);
+  }
+}

apps/isa-app/src/app/interceptors/index.ts

@@ -0,0 +1,3 @@
+// start:ng42.barrel
+export * from './http-error.interceptor';
+// end:ng42.barrel

apps/isa-app/src/app/main.component.html

@@ -0,0 +1,3 @@
+<shell-root>
+  <router-outlet></router-outlet>
+</shell-root>

apps/isa-app/src/app/main.component.ts

@@ -0,0 +1,10 @@
+import { Component, ChangeDetectionStrategy } from '@angular/core';
+
+@Component({
+  selector: 'app-main',
+  templateUrl: 'main.component.html',
+  changeDetection: ChangeDetectionStrategy.OnPush,
+})
+export class MainComponent {
+  constructor() {}
+}

apps/isa-app/src/app/preview/index.ts

@@ -0,0 +1,3 @@
+// start:ng42.barrel
+export * from './preview.component';
+// end:ng42.barrel

apps/isa-app/src/app/preview/preview.component.css

@@ -0,0 +1,3 @@
+:host {
+  @apply grid min-h-screen content-center justify-center;
+}

apps/isa-app/src/app/preview/preview.component.html

@@ -0,0 +1,10 @@
+<h1>Platform: {{ platform | json }}</h1>
+<br />
+<h1>{{ appVersion }}</h1>
+<br />
+<h1>{{ userAgent }}</h1>
+<br />
+<h1>Navigator: {{ navigator | json }}</h1>
+<br />
+<br />
+<h1>Device: {{ device }}</h1>

apps/isa-app/src/app/preview/preview.component.ts

@@ -0,0 +1,60 @@
+import { Platform, PlatformModule } from '@angular/cdk/platform';
+import { CommonModule } from '@angular/common';
+import { Component, OnInit } from '@angular/core';
+import { BranchSelectorComponent } from '@shared/components/branch-selector';
+import { BranchDTO } from '@swagger/checkout';
+import { BehaviorSubject } from 'rxjs';
+
+@Component({
+  selector: 'app-preview',
+  templateUrl: 'preview.component.html',
+  styleUrls: ['preview.component.css'],
+  imports: [CommonModule, BranchSelectorComponent, PlatformModule],
+  standalone: true,
+})
+export class PreviewComponent implements OnInit {
+  selectedBranch$ = new BehaviorSubject<BranchDTO>({});
+
+  get appVersion() {
+    return 'App Version: ' + (window.navigator as any).appVersion;
+  }
+
+  get userAgent() {
+    return 'User Agent: ' + (window.navigator as any).userAgent;
+  }
+
+  get navigator() {
+    const nav = {};
+    for (let i in window.navigator) nav[i] = navigator[i];
+    return nav;
+  }
+
+  get platform() {
+    return this._platform;
+  }
+
+  get device() {
+    const isIpadNative = this._platform.IOS && !this._platform.SAFARI;
+    const isIpadMini6Native = window?.navigator?.userAgent?.includes('Macintosh') && !this._platform.SAFARI;
+    const isNative = isIpadNative || isIpadMini6Native;
+    const isPWA = this._platform.IOS && this._platform.SAFARI;
+    const isDesktop = !isNative && !isPWA;
+    if (isNative) {
+      if (isIpadMini6Native) {
+        return 'IPAD mini 6 Native App';
+      } else if (isIpadNative) {
+        return 'IPAD mini 2 Native App or IPAD mini 5 Native App';
+      }
+    } else if (isPWA) {
+      return 'IPAD Safari PWA';
+    } else if (isDesktop) return 'Desktop or Macintosh';
+  }
+
+  constructor(private readonly _platform: Platform) {}
+
+  ngOnInit() {}
+
+  setNewBranch(branch: BranchDTO) {
+    this.selectedBranch$.next(branch);
+  }
+}

apps/isa-app/src/app/providers/index.ts

@@ -0,0 +1,3 @@
+// start:ng42.barrel
+export * from './isa.log-provider';
+// end:ng42.barrel

apps/isa-app/src/app/providers/isa.error-handler.ts

@@ -0,0 +1,53 @@
+import { HttpErrorResponse } from '@angular/common/http';
+import { ErrorHandler, Injectable } from '@angular/core';
+import { AuthService } from '@core/auth';
+import { DialogModel, UiDialogModalComponent, UiErrorModalComponent, UiModalService } from '@ui/modal';
+import { IsaLogProvider } from './isa.log-provider';
+import { LogLevel } from '@core/logger';
+
+@Injectable({ providedIn: 'root' })
+export class IsaErrorHandler implements ErrorHandler {
+  constructor(
+    private _modal: UiModalService,
+    private _authService: AuthService,
+    private _isaLogProvider: IsaLogProvider,
+  ) {}
+
+  async handleError(error: any): Promise<void> {
+    console.error(error);
+
+    // Bei Klick auf Abbrechen auf der Login Seite erneut zur Login Seite weiterleiten
+    if (error?.type === 'token_error') {
+      this._authService.login();
+      return;
+    }
+
+    if (error instanceof HttpErrorResponse && error?.status === 401) {
+      await this._modal
+        .open({
+          content: UiDialogModalComponent,
+          title: 'Sitzung abgelaufen',
+          data: {
+            handleCommand: false,
+            content: 'Sie waren zu lange nicht in der ISA aktiv. Bitte melden Sie sich erneut an',
+            actions: [{ command: 'CLOSE', selected: true, label: 'Erneut anmelden' }],
+          } as DialogModel,
+        })
+        .afterClosed$.toPromise();
+
+      this._authService.logout();
+      return;
+    }
+
+    this._isaLogProvider.log(LogLevel.ERROR, 'Client Error', error);
+
+    // this._modal.open({
+    //   content: UiErrorModalComponent,
+    //   title:
+    //     !navigator.onLine || (error instanceof HttpErrorResponse && error?.status === 0)
+    //       ? 'Sie sind offline, keine Verbindung zum Netzwerk'
+    //       : 'Unbekannter Fehler',
+    //   data: error,
+    // });
+  }
+}

apps/isa-app/src/app/providers/isa.log-provider.ts

@@ -0,0 +1,28 @@
+import { Injectable, Injector } from '@angular/core';
+import { LogLevel, LogProvider } from '@core/logger';
+import { UserStateService } from '@swagger/isa';
+import { environment } from '../../environments/environment';
+
+@Injectable({ providedIn: 'root' })
+export class IsaLogProvider implements LogProvider {
+  static InfoService: UserStateService | undefined;
+
+  constructor() {}
+
+  log(logLevel: LogLevel, message: string, error: Error, ...optionalParams: any[]): void {
+    if (!environment.production && (logLevel === LogLevel.WARN || logLevel === LogLevel.ERROR)) {
+      IsaLogProvider.InfoService?.UserStateSaveLog({
+        logType: logLevel,
+        message: message,
+        content: JSON.stringify({
+          error: error?.name,
+          message: error?.message,
+          stack: error?.stack,
+          data: optionalParams,
+        }),
+      })
+        .toPromise()
+        .catch(() => {});
+    }
+  }
+}

apps/isa-app/src/app/resolvers/index.ts

@@ -0,0 +1,4 @@
+// start:ng42.barrel
+export * from './process-id.resolver';
+export * from './section.resolver';
+// end:ng42.barrel

apps/isa-app/src/app/resolvers/process-id.resolver.ts

@@ -0,0 +1,12 @@
+import { Injectable } from '@angular/core';
+import { ActivatedRouteSnapshot } from '@angular/router';
+import { Observable } from 'rxjs';
+
+@Injectable({ providedIn: 'root' })
+export class ProcessIdResolver {
+  constructor() {}
+
+  resolve(route: ActivatedRouteSnapshot): Observable<number> | Promise<number> | number {
+    return route.params.processId;
+  }
+}

apps/isa-app/src/app/resolvers/section.resolver.ts

@@ -0,0 +1,27 @@
+import { Injectable } from '@angular/core';
+import { ActivatedRouteSnapshot } from '@angular/router';
+import { ApplicationService } from '@core/application';
+import { Observable } from 'rxjs';
+
+export abstract class SectionResolver {
+  constructor(protected section: 'customer' | 'branch', protected applicationService: ApplicationService) {}
+
+  resolve(route: ActivatedRouteSnapshot): Observable<string> | Promise<string> | string {
+    this.applicationService.setSection(this.section);
+    return this.section;
+  }
+}
+
+@Injectable({ providedIn: 'root' })
+export class CustomerSectionResolver extends SectionResolver {
+  constructor(applicationService: ApplicationService) {
+    super('customer', applicationService);
+  }
+}
+
+@Injectable({ providedIn: 'root' })
+export class BranchSectionResolver extends SectionResolver {
+  constructor(applicationService: ApplicationService) {
+    super('branch', applicationService);
+  }
+}

apps/isa-app/src/app/services/network-status.service.ts

@@ -0,0 +1,25 @@
+import { inject, Injectable } from '@angular/core';
+import { map, Observable } from 'rxjs';
+
+@Injectable({ providedIn: 'root' })
+export class NetworkStatusService {
+  online$ = new Observable<boolean>((subscriber) => {
+    const handler = () => subscriber.next(navigator.onLine);
+
+    window.addEventListener('online', handler);
+    window.addEventListener('offline', handler);
+
+    handler();
+
+    return () => {
+      window.removeEventListener('online', handler);
+      window.removeEventListener('offline', handler);
+    };
+  });
+
+  status$ = this.online$.pipe(map((online) => (online ? 'online' : 'offline')));
+}
+
+export const injectNetworkStatus$ = () => inject(NetworkStatusService).status$;
+
+export const injectOnline$ = () => inject(NetworkStatusService).online$;

apps/isa-app/src/app/store/root-state.service.ts

@@ -0,0 +1,118 @@
+import { Injectable } from '@angular/core';
+import { Logger, LogLevel } from '@core/logger';
+import { Store } from '@ngrx/store';
+import { UserStateService } from '@swagger/isa';
+import { debounceTime, switchMap, takeUntil } from 'rxjs/operators';
+import { RootState } from './root.state';
+import packageInfo from 'packageJson';
+import { environment } from '../../environments/environment';
+import { Subject } from 'rxjs';
+import { AuthService } from '@core/auth';
+
+@Injectable({ providedIn: 'root' })
+export class RootStateService {
+  static LOCAL_STORAGE_KEY = 'ISA_APP_INITIALSTATE';
+
+  private _cancelSave = new Subject<void>();
+
+  constructor(
+    private readonly _authService: AuthService,
+    private readonly _userStateService: UserStateService,
+    private _logger: Logger,
+    private _store: Store,
+  ) {
+    if (!environment.production) {
+      console.log('Die UserState kann in der Konsole mit der Funktion "clearUserState()" geleert werden.');
+    }
+
+    window['clearUserState'] = () => {
+      this.clear();
+    };
+  }
+
+  async init() {
+    await this.load();
+    this._store.dispatch({ type: 'HYDRATE', payload: RootStateService.LoadFromLocalStorage() });
+    this.initSave();
+  }
+
+  initSave() {
+    this._store
+      .select((state) => state)
+      .pipe(
+        takeUntil(this._cancelSave),
+        debounceTime(1000),
+        switchMap((state) => {
+          const raw = JSON.stringify({ ...state, version: packageInfo.version, sub: this._authService.getClaimByKey('sub') });
+          RootStateService.SaveToLocalStorageRaw(raw);
+          return this._userStateService.UserStateSetUserState({ content: raw });
+        }),
+      )
+      .subscribe();
+  }
+
+  /**
+   * Loads the initial state from local storage and returns true/false if state was changed
+   */
+  async load(): Promise<boolean> {
+    try {
+      const res = await this._userStateService.UserStateGetUserState().toPromise();
+
+      const resContent = res?.result?.content ?? null;
+      const storageContent = RootStateService.LoadFromLocalStorageRaw();
+
+      if (resContent) {
+        RootStateService.SaveToLocalStorageRaw(res.result.content);
+      }
+
+      if (resContent !== storageContent) {
+        return true;
+      }
+    } catch (error) {
+      this._logger.log(LogLevel.ERROR, error);
+    }
+    return false;
+  }
+
+  async clear() {
+    try {
+      this._cancelSave.next();
+      await this._userStateService.UserStateResetUserState().toPromise();
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      RootStateService.RemoveFromLocalStorage();
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      window.location.reload();
+    } catch (error) {
+      this._logger.log(LogLevel.ERROR, error);
+    }
+  }
+
+  static SaveToLocalStorage(state: RootState) {
+    RootStateService.SaveToLocalStorageRaw(JSON.stringify(state));
+  }
+
+  static SaveToLocalStorageRaw(state: string) {
+    localStorage.setItem(RootStateService.LOCAL_STORAGE_KEY, state);
+  }
+
+  static LoadFromLocalStorage(): RootState {
+    const raw = RootStateService.LoadFromLocalStorageRaw();
+    if (raw) {
+      try {
+        return JSON.parse(raw);
+      } catch (error) {
+        console.error('Error parsing local storage:', error);
+        this.RemoveFromLocalStorage();
+      }
+    }
+    return undefined;
+  }
+
+  static LoadFromLocalStorageRaw(): string {
+    return localStorage.getItem(RootStateService.LOCAL_STORAGE_KEY);
+  }
+
+  static RemoveFromLocalStorage() {
+    localStorage.removeItem(RootStateService.LOCAL_STORAGE_KEY);
+  }
+}

apps/isa-app/src/app/store/root.reducer.ts

@@ -0,0 +1,4 @@
+import { ActionReducerMap } from '@ngrx/store';
+import { RootState } from './root.state';
+
+export const rootReducer: ActionReducerMap<RootState> = {};

apps/isa-app/src/app/store/root.state.ts

@@ -0,0 +1,3 @@
+export interface RootState {
+  version?: string;
+}

apps/isa-app/src/app/token-login/index.ts

@@ -0,0 +1,2 @@
+export * from './token-login.component';
+export * from './token-login.module';

apps/isa-app/src/app/token-login/token-login.component.ts

@@ -0,0 +1,24 @@
+import { Component, ChangeDetectionStrategy, OnInit } from '@angular/core';
+import { ActivatedRoute, Router } from '@angular/router';
+import { AuthService } from '@core/auth';
+
+@Component({
+  selector: 'app-token-login',
+  templateUrl: 'token-login.component.html',
+  styleUrls: ['token-login.component.scss'],
+  changeDetection: ChangeDetectionStrategy.OnPush,
+})
+export class TokenLoginComponent implements OnInit {
+  constructor(private _route: ActivatedRoute, private _authService: AuthService, private _router: Router) {}
+
+  ngOnInit() {
+    if (this._route.snapshot.params.token && !this._authService.isAuthenticated()) {
+      this._authService.setKeyCardToken(this._route.snapshot.params.token);
+      this._authService.login();
+    } else if (!this._authService.isAuthenticated()) {
+      this._authService.login();
+    } else if (this._authService.isAuthenticated()) {
+      this._router.navigate(['/']);
+    }
+  }
+}

apps/isa-app/src/app/token-login/token-login.module.ts

@@ -0,0 +1,11 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+
+import { TokenLoginComponent } from './token-login.component';
+
+@NgModule({
+  imports: [CommonModule],
+  exports: [TokenLoginComponent],
+  declarations: [TokenLoginComponent],
+})
+export class TokenLoginModule {}