First Commit

2023-06-29 16:03:38 +02:00 · 2023-06-29 16:03:38 +02:00 · 09b028d42a
commit 09b028d42a
385 changed files with 68166 additions and 0 deletions
--- a/.browserslistrc
+++ b/.browserslistrc
@ -0,0 +1,18 @@
+# This file is used by the build system to adjust CSS and JS output to support the specified browsers below.
+# For additional information regarding the format and rule options, please see:
+# https://github.com/browserslist/browserslist#queries
+
+# For the full list of supported browsers by the Angular framework, please see:
+# https://angular.io/guide/browser-support
+
+# You can see what browsers were selected by your queries by running:
+#   npx browserslist
+
+last 1 Chrome version
+last 1 Firefox version
+last 2 Edge major versions
+last 2 Safari major versions
+last 2 iOS major versions
+Firefox ESR
+not IE 9-10 # Angular support for IE 9-10 has been deprecated and will be removed as of Angular v11. To opt-in, remove the 'not' prefix on this line.
+not IE 11 # Angular supports IE 11 only as an opt-in. To opt-in, remove the 'not' prefix on this line.
--- a/.classpath
+++ b/.classpath
@ -0,0 +1,51 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" output="target/classes" path="src/main/java">
+		<attributes>
+			<attribute name="optional" value="true"/>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry excluding="**" kind="src" output="target/classes" path="src/main/resources"/>
+	<classpathentry kind="src" output="target/test-classes" path="src/test/java">
+		<attributes>
+			<attribute name="test" value="true"/>
+			<attribute name="optional" value="true"/>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry excluding="**" kind="src" output="target/test-classes" path="src/test/resources">
+		<attributes>
+			<attribute name="test" value="true"/>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-11">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="src" path="target/generated-sources/annotations">
+		<attributes>
+			<attribute name="ignore_optional_problems" value="true"/>
+			<attribute name="optional" value="true"/>
+			<attribute name="maven.pomderived" value="true"/>
+			<attribute name="m2e-apt" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="src" output="target/test-classes" path="target/generated-test-sources/test-annotations">
+		<attributes>
+			<attribute name="optional" value="true"/>
+			<attribute name="maven.pomderived" value="true"/>
+			<attribute name="ignore_optional_problems" value="true"/>
+			<attribute name="m2e-apt" value="true"/>
+			<attribute name="test" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="output" path="target/classes"/>
+</classpath>
--- a/.devcontainer/Dockerfile
+++ b/.devcontainer/Dockerfile
@ -0,0 +1,25 @@
+# See here for image contents: https://github.com/microsoft/vscode-dev-containers/tree/v0.209.6/containers/java/.devcontainer/base.Dockerfile
+
+# [Choice] Java version (use -bullseye variants on local arm64/Apple Silicon): 11, 17, 11-bullseye, 17-bullseye, 11-buster, 17-buster
+ARG VARIANT="11"
+FROM mcr.microsoft.com/vscode/devcontainers/java:0-${VARIANT}
+
+# [Option] Install Maven
+ARG INSTALL_MAVEN="false"
+ARG MAVEN_VERSION=""
+# [Option] Install Gradle
+ARG INSTALL_GRADLE="false"
+ARG GRADLE_VERSION=""
+RUN if [ "${INSTALL_MAVEN}" = "true" ]; then su vscode -c "umask 0002 && . /usr/local/sdkman/bin/sdkman-init.sh && sdk install maven \"${MAVEN_VERSION}\""; fi \
+    && if [ "${INSTALL_GRADLE}" = "true" ]; then su vscode -c "umask 0002 && . /usr/local/sdkman/bin/sdkman-init.sh && sdk install gradle \"${GRADLE_VERSION}\""; fi
+
+# [Choice] Node.js version: none, lts/*, 16, 14, 12, 10
+ARG NODE_VERSION="none"
+RUN if [ "${NODE_VERSION}" != "none" ]; then su vscode -c "umask 0002 && . /usr/local/share/nvm/nvm.sh && nvm install ${NODE_VERSION} 2>&1"; fi
+
+# [Optional] Uncomment this section to install additional OS packages.
+# RUN apt-get update && export DEBIAN_FRONTEND=noninteractive \
+#     && apt-get -y install --no-install-recommends <your-package-list-here>
+
+# [Optional] Uncomment this line to install global node packages.
+# RUN su vscode -c "source /usr/local/share/nvm/nvm.sh && npm install -g <your-package-here>" 2>&1
--- a/.devcontainer/devcontainer.json
+++ b/.devcontainer/devcontainer.json
@ -0,0 +1,48 @@
+// For format details, see https://aka.ms/devcontainer.json. For config options, see the README at:
+// https://github.com/microsoft/vscode-dev-containers/tree/v0.209.6/containers/java
+{
+  "name": "Informationsystemmonitor",
+  "build": {
+    "dockerfile": "Dockerfile",
+    "args": {
+      // Update the VARIANT arg to pick a Java version: 11, 17
+      // Append -bullseye or -buster to pin to an OS version.
+      // Use the -bullseye variants on local arm64/Apple Silicon.
+      "VARIANT": "11",
+      // Options
+      "INSTALL_MAVEN": "true",
+      "INSTALL_GRADLE": "false",
+      "NODE_VERSION": "lts/*"
+    }
+  },
+
+  // Set *default* container specific settings.json values on container create.
+  "settings": {
+    "java.home": "/docker-java-home"
+  },
+
+  // Add the IDs of extensions you want installed when the container is created.
+  "extensions": [
+    "angular.ng-template",
+    "christian-kohler.npm-intellisense",
+    "firsttris.vscode-jest-runner",
+    "ms-vscode.vscode-typescript-tslint-plugin",
+    "dbaeumer.vscode-eslint",
+    "vscjava.vscode-java-pack",
+    "pivotal.vscode-boot-dev-pack",
+    "esbenp.prettier-vscode"
+  ],
+
+  // Use 'forwardPorts' to make a list of ports inside the container available locally.
+  "forwardPorts": [4200, 3001, 9000, 8080],
+
+  // Use 'postCreateCommand' to run commands after the container is created.
+  // "postCreateCommand": "java -version",
+
+  // Comment out connect as root instead. More info: https://aka.ms/vscode-remote/containers/non-root.
+  "remoteUser": "vscode",
+  "features": {
+    "docker-in-docker": "latest",
+    "docker-from-docker": "latest"
+  }
+}
--- a/.editorconfig
+++ b/.editorconfig
@ -0,0 +1,23 @@
+# EditorConfig helps developers define and maintain consistent
+# coding styles between different editors and IDEs
+# editorconfig.org
+
+root = true
+
+[*]
+
+# We recommend you to keep these unchanged
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+# Change these settings to your own preference
+indent_style = space
+indent_size = 4
+
+[*.{ts,tsx,js,jsx,json,css,scss,yml,html,vue}]
+indent_size = 2
+
+[*.md]
+trim_trailing_whitespace = false
--- a/.eslintignore
+++ b/.eslintignore
@ -0,0 +1,8 @@
+node_modules/
+src/main/docker/
+jest.conf.js
+webpack/
+target/
+build/
+node/
+postcss.config.js
--- a/.eslintrc.json
+++ b/.eslintrc.json
@ -0,0 +1,99 @@
+{
+  "parser": "@typescript-eslint/parser",
+  "plugins": ["@angular-eslint/eslint-plugin", "@typescript-eslint"],
+  "extends": [
+    "eslint:recommended",
+    "plugin:@typescript-eslint/recommended",
+    "plugin:@typescript-eslint/recommended-requiring-type-checking",
+    "plugin:@angular-eslint/recommended",
+    "prettier",
+    "eslint-config-prettier"
+  ],
+  "env": {
+    "browser": true,
+    "es6": true,
+    "commonjs": true
+  },
+  "parserOptions": {
+    "ecmaVersion": 2018,
+    "sourceType": "module",
+    "project": ["./tsconfig.app.json", "./tsconfig.spec.json"]
+  },
+  "rules": {
+    "@angular-eslint/component-selector": [
+      "error",
+      {
+        "type": "element",
+        "prefix": "jhi",
+        "style": "kebab-case"
+      }
+    ],
+    "@angular-eslint/directive-selector": [
+      "error",
+      {
+        "type": "attribute",
+        "prefix": "jhi",
+        "style": "camelCase"
+      }
+    ],
+    "@angular-eslint/relative-url-prefix": "error",
+    "@typescript-eslint/ban-types": [
+      "error",
+      {
+        "extendDefaults": true,
+        "types": {
+          "{}": false
+        }
+      }
+    ],
+    "@typescript-eslint/explicit-function-return-type": ["error", { "allowExpressions": true }],
+    "@typescript-eslint/explicit-module-boundary-types": "off",
+    "@typescript-eslint/member-ordering": [
+      "error",
+      {
+        "default": [
+          "public-static-field",
+          "protected-static-field",
+          "private-static-field",
+          "public-instance-field",
+          "protected-instance-field",
+          "private-instance-field",
+          "constructor",
+          "public-static-method",
+          "protected-static-method",
+          "private-static-method",
+          "public-instance-method",
+          "protected-instance-method",
+          "private-instance-method"
+        ]
+      }
+    ],
+    "@typescript-eslint/no-explicit-any": "off",
+    "@typescript-eslint/no-floating-promises": "off",
+    "@typescript-eslint/no-non-null-assertion": "off",
+    "@typescript-eslint/no-parameter-properties": ["warn", { "allows": ["public", "private", "protected"] }],
+    "@typescript-eslint/no-shadow": ["error"],
+    "@typescript-eslint/no-unnecessary-condition": "error",
+    "@typescript-eslint/no-unsafe-argument": "off",
+    "@typescript-eslint/no-unsafe-assignment": "off",
+    "@typescript-eslint/no-unsafe-call": "off",
+    "@typescript-eslint/no-unsafe-member-access": "off",
+    "@typescript-eslint/prefer-nullish-coalescing": "error",
+    "@typescript-eslint/prefer-optional-chain": "error",
+    "@typescript-eslint/unbound-method": "off",
+    "arrow-body-style": "error",
+    "curly": "error",
+    "eqeqeq": ["error", "always", { "null": "ignore" }],
+    "guard-for-in": "error",
+    "no-bitwise": "error",
+    "no-caller": "error",
+    "no-console": ["error", { "allow": ["warn", "error"] }],
+    "no-eval": "error",
+    "no-labels": "error",
+    "no-new": "error",
+    "no-new-wrappers": "error",
+    "object-shorthand": ["error", "always", { "avoidExplicitReturnArrows": true }],
+    "radix": "error",
+    "spaced-comment": ["warn", "always"]
+  }
+}
--- a/.factorypath
+++ b/.factorypath
@ -0,0 +1,5 @@
+<factorypath>
+    <factorypathentry kind="VARJAR" id="M2_REPO/org/projectlombok/lombok/1.18.24/lombok-1.18.24.jar" enabled="true" runInBatchMode="false"/>
+    <factorypathentry kind="VARJAR" id="M2_REPO/org/springframework/boot/spring-boot-configuration-processor/2.7.3/spring-boot-configuration-processor-2.7.3.jar" enabled="true" runInBatchMode="false"/>
+    <factorypathentry kind="VARJAR" id="M2_REPO/org/mapstruct/mapstruct-processor/1.5.2.Final/mapstruct-processor-1.5.2.Final.jar" enabled="true" runInBatchMode="false"/>
+</factorypath>
--- a/.gitignore
+++ b/.gitignore
@ -0,0 +1,2 @@
+/target/
+/node_modules/
--- a/.mvn/jvm.config
+++ b/.mvn/jvm.config
@ -0,0 +1 @@
+
--- a/.mvn/wrapper/maven-wrapper.jar
+++ b/.mvn/wrapper/maven-wrapper.jar
--- a/.mvn/wrapper/maven-wrapper.properties
+++ b/.mvn/wrapper/maven-wrapper.properties
@ -0,0 +1,18 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+distributionUrl=https://repo.maven.apache.org/maven2/org/apache/maven/apache-maven/3.8.6/apache-maven-3.8.6-bin.zip
+wrapperUrl=https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.1.1/maven-wrapper-3.1.1.jar
--- a/.prettierignore
+++ b/.prettierignore
@ -0,0 +1,8 @@
+node_modules
+target
+build
+package-lock.json
+.git
+.mvn
+gradle
+.gradle
--- a/.prettierrc
+++ b/.prettierrc
@ -0,0 +1,18 @@
+# Prettier configuration
+
+printWidth: 140
+singleQuote: true
+tabWidth: 2
+useTabs: false
+
+# js and ts rules:
+arrowParens: avoid
+
+# jsx and tsx rules:
+bracketSameLine: false
+
+# java rules:
+overrides:
+  - files: "*.java"
+    options:
+      tabWidth: 4
--- a/.project
+++ b/.project
@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>informationsystemmonitor</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.springframework.ide.eclipse.boot.validation.springbootbuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.m2e.core.maven2Builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+		<nature>org.eclipse.m2e.core.maven2Nature</nature>
+	</natures>
+</projectDescription>
--- a/.settings/org.eclipse.core.resources.prefs
+++ b/.settings/org.eclipse.core.resources.prefs
@ -0,0 +1,6 @@
+eclipse.preferences.version=1
+encoding//src/main/java=UTF-8
+encoding//src/main/resources=UTF-8
+encoding//src/test/java=UTF-8
+encoding//src/test/resources=UTF-8
+encoding/<project>=UTF-8
--- a/.settings/org.eclipse.jdt.apt.core.prefs
+++ b/.settings/org.eclipse.jdt.apt.core.prefs
@ -0,0 +1,4 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.apt.aptEnabled=true
+org.eclipse.jdt.apt.genSrcDir=target/generated-sources/annotations
+org.eclipse.jdt.apt.genTestSrcDir=target/generated-test-sources/test-annotations
--- a/.settings/org.eclipse.jdt.core.prefs
+++ b/.settings/org.eclipse.jdt.core.prefs
@ -0,0 +1,9 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=11
+org.eclipse.jdt.core.compiler.compliance=11
+org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=disabled
+org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
+org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=ignore
+org.eclipse.jdt.core.compiler.processAnnotations=enabled
+org.eclipse.jdt.core.compiler.release=disabled
+org.eclipse.jdt.core.compiler.source=11
--- a/.settings/org.eclipse.m2e.core.prefs
+++ b/.settings/org.eclipse.m2e.core.prefs
@ -0,0 +1,4 @@
+activeProfiles=
+eclipse.preferences.version=1
+resolveWorkspaceProjects=true
+version=1
--- a/.settings/org.springframework.ide.eclipse.prefs
+++ b/.settings/org.springframework.ide.eclipse.prefs
@ -0,0 +1,2 @@
+boot.validation.initialized=true
+eclipse.preferences.version=1
--- a/.yo-rc-global.json
+++ b/.yo-rc-global.json
@ -0,0 +1,8 @@
+{
+  "generator-jhipster:7.9.3": {
+    "promptValues": {
+      "packageName": "org.gcube.fullstackapps.informationsystemmonitor",
+      "nativeLanguage": "en"
+    }
+  }
+}
--- a/.yo-rc.json
+++ b/.yo-rc.json
@ -0,0 +1,49 @@
+{
+  "generator-jhipster": {
+    "applicationType": "monolith",
+    "authenticationType": "oauth2",
+    "baseName": "informationsystemmonitor",
+    "blueprints": [],
+    "buildTool": "maven",
+    "cacheProvider": "no",
+    "clientFramework": "angularX",
+    "clientPackageManager": "npm",
+    "clientTheme": "none",
+    "clientThemeVariant": "",
+    "creationTimestamp": 1687526025362,
+    "databaseType": "no",
+    "devDatabaseType": "no",
+    "devServerPort": 4200,
+    "dtoSuffix": "DTO",
+    "enableGradleEnterprise": false,
+    "enableHibernateCache": false,
+    "enableSwaggerCodegen": true,
+    "enableTranslation": true,
+    "entitySuffix": "",
+    "jhiPrefix": "jhi",
+    "jhipsterVersion": "7.9.3",
+    "languages": ["en"],
+    "messageBroker": false,
+    "microfrontend": false,
+    "microfrontends": [],
+    "monorepository": true,
+    "nativeLanguage": "en",
+    "otherModules": [],
+    "packageName": "org.gcube.fullstackapps.informationsystemmonitor",
+    "pages": [],
+    "prodDatabaseType": "no",
+    "reactive": false,
+    "searchEngine": false,
+    "serverPort": "8080",
+    "serverSideOptions": ["enableSwaggerCodegen:true"],
+    "serviceDiscoveryType": "no",
+    "skipCheckLengthOfIdentifier": false,
+    "skipClient": false,
+    "skipCommitHook": true,
+    "skipFakeData": false,
+    "skipUserManagement": true,
+    "testFrameworks": [],
+    "websocket": false,
+    "withAdminUi": true
+  }
+}
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -0,0 +1,8 @@
+This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+# Changelog for "informationsystemmonitor"
+
+
+## [v1.0.0-SNAPSHOT]
+
+- First Release
--- a/FUNDING.md
+++ b/FUNDING.md
@ -0,0 +1,26 @@
+# Acknowledgments
+
+The projects leading to this software have received funding from a series of European Union programmes including:
+
+- the Sixth Framework Programme for Research and Technological Development
+    - [DILIGENT](https://cordis.europa.eu/project/id/004260) (grant no. 004260).
+- the Seventh Framework Programme for research, technological development and demonstration 
+    - [D4Science](https://cordis.europa.eu/project/id/212488) (grant no. 212488);
+    - [D4Science-II](https://cordis.europa.eu/project/id/239019) (grant no.239019);
+    - [ENVRI](https://cordis.europa.eu/project/id/283465) (grant no. 283465);
+    - [iMarine](https://cordis.europa.eu/project/id/283644) (grant no. 283644);
+    - [EUBrazilOpenBio](https://cordis.europa.eu/project/id/288754) (grant no. 288754).
+- the H2020 research and innovation programme 
+    - [SoBigData](https://cordis.europa.eu/project/id/654024) (grant no. 654024);
+    - [PARTHENOS](https://cordis.europa.eu/project/id/654119) (grant no. 654119);
+    - [EGI-Engage](https://cordis.europa.eu/project/id/654142) (grant no. 654142);
+    - [ENVRI PLUS](https://cordis.europa.eu/project/id/654182) (grant no. 654182);
+    - [BlueBRIDGE](https://cordis.europa.eu/project/id/675680) (grant no. 675680);
+    - [PerformFISH](https://cordis.europa.eu/project/id/727610) (grant no. 727610);
+    - [AGINFRA PLUS](https://cordis.europa.eu/project/id/731001) (grant no. 731001);
+    - [DESIRA](https://cordis.europa.eu/project/id/818194) (grant no. 818194);
+    - [ARIADNEplus](https://cordis.europa.eu/project/id/823914) (grant no. 823914);
+    - [RISIS 2](https://cordis.europa.eu/project/id/824091) (grant no. 824091);
+    - [EOSC-Pillar](https://cordis.europa.eu/project/id/857650) (grant no. 857650);
+    - [Blue Cloud](https://cordis.europa.eu/project/id/862409) (grant no. 862409);
+    - [SoBigData-PlusPlus](https://cordis.europa.eu/project/id/871042) (grant no. 871042);
--- a/LICENSE.md
+++ b/LICENSE.md
@ -0,0 +1,311 @@
+# European Union Public Licence V. 1.1
+
+
+EUPL © the European Community 2007
+
+
+This European Union Public Licence (the “EUPL”) applies to the Work or Software
+(as defined below) which is provided under the terms of this Licence. Any use of
+the Work, other than as authorised under this Licence is prohibited (to the
+extent such use is covered by a right of the copyright holder of the Work).
+
+The Original Work is provided under the terms of this Licence when the Licensor
+(as defined below) has placed the following notice immediately following the
+copyright notice for the Original Work:
+
+Licensed under the EUPL V.1.1
+
+or has expressed by any other mean his willingness to license under the EUPL.
+
+
+
+## 1. Definitions
+
+In this Licence, the following terms have the following meaning:
+
+- The Licence: this Licence.
+
+- The Original Work or the Software: the software distributed and/or
+  communicated by the Licensor under this Licence, available as Source Code and
+  also as Executable Code as the case may be.
+
+- Derivative Works: the works or software that could be created by the Licensee,
+  based upon the Original Work or modifications thereof. This Licence does not
+  define the extent of modification or dependence on the Original Work required
+  in order to classify a work as a Derivative Work; this extent is determined by
+  copyright law applicable in the country mentioned in Article 15.
+
+- The Work: the Original Work and/or its Derivative Works.
+
+- The Source Code: the human-readable form of the Work which is the most
+  convenient for people to study and modify.
+
+- The Executable Code: any code which has generally been compiled and which is
+  meant to be interpreted by a computer as a program.
+
+- The Licensor: the natural or legal person that distributes and/or communicates
+  the Work under the Licence.
+
+- Contributor(s): any natural or legal person who modifies the Work under the
+  Licence, or otherwise contributes to the creation of a Derivative Work.
+
+- The Licensee or “You”: any natural or legal person who makes any usage of the
+  Software under the terms of the Licence.
+
+- Distribution and/or Communication: any act of selling, giving, lending,
+  renting, distributing, communicating, transmitting, or otherwise making
+  available, on-line or off-line, copies of the Work or providing access to its
+  essential functionalities at the disposal of any other natural or legal
+  person.
+
+
+
+## 2. Scope of the rights granted by the Licence
+
+The Licensor hereby grants You a world-wide, royalty-free, non-exclusive,
+sub-licensable licence to do the following, for the duration of copyright vested
+in the Original Work:
+
+- use the Work in any circumstance and for all usage, reproduce the Work, modify
+- the Original Work, and make Derivative Works based upon the Work, communicate
+- to the public, including the right to make available or display the Work or
+- copies thereof to the public and perform publicly, as the case may be, the
+- Work, distribute the Work or copies thereof, lend and rent the Work or copies
+- thereof, sub-license rights in the Work or copies thereof.
+
+Those rights can be exercised on any media, supports and formats, whether now
+known or later invented, as far as the applicable law permits so.
+
+In the countries where moral rights apply, the Licensor waives his right to
+exercise his moral right to the extent allowed by law in order to make effective
+the licence of the economic rights here above listed.
+
+The Licensor grants to the Licensee royalty-free, non exclusive usage rights to
+any patents held by the Licensor, to the extent necessary to make use of the
+rights granted on the Work under this Licence.
+
+
+
+## 3. Communication of the Source Code
+
+The Licensor may provide the Work either in its Source Code form, or as
+Executable Code. If the Work is provided as Executable Code, the Licensor
+provides in addition a machine-readable copy of the Source Code of the Work
+along with each copy of the Work that the Licensor distributes or indicates, in
+a notice following the copyright notice attached to the Work, a repository where
+the Source Code is easily and freely accessible for as long as the Licensor
+continues to distribute and/or communicate the Work.
+
+
+
+## 4. Limitations on copyright
+
+Nothing in this Licence is intended to deprive the Licensee of the benefits from
+any exception or limitation to the exclusive rights of the rights owners in the
+Original Work or Software, of the exhaustion of those rights or of other
+applicable limitations thereto.
+
+
+
+## 5. Obligations of the Licensee
+
+The grant of the rights mentioned above is subject to some restrictions and
+obligations imposed on the Licensee. Those obligations are the following:
+
+Attribution right: the Licensee shall keep intact all copyright, patent or
+trademarks notices and all notices that refer to the Licence and to the
+disclaimer of warranties. The Licensee must include a copy of such notices and a
+copy of the Licence with every copy of the Work he/she distributes and/or
+communicates. The Licensee must cause any Derivative Work to carry prominent
+notices stating that the Work has been modified and the date of modification.
+
+Copyleft clause: If the Licensee distributes and/or communicates copies of the
+Original Works or Derivative Works based upon the Original Work, this
+Distribution and/or Communication will be done under the terms of this Licence
+or of a later version of this Licence unless the Original Work is expressly
+distributed only under this version of the Licence. The Licensee (becoming
+Licensor) cannot offer or impose any additional terms or conditions on the Work
+or Derivative Work that alter or restrict the terms of the Licence.
+
+Compatibility clause: If the Licensee Distributes and/or Communicates Derivative
+Works or copies thereof based upon both the Original Work and another work
+licensed under a Compatible Licence, this Distribution and/or Communication can
+be done under the terms of this Compatible Licence. For the sake of this clause,
+“Compatible Licence” refers to the licences listed in the appendix attached to
+this Licence. Should the Licensee’s obligations under the Compatible Licence
+conflict with his/her obligations under this Licence, the obligations of the
+Compatible Licence shall prevail.
+
+Provision of Source Code: When distributing and/or communicating copies of the
+Work, the Licensee will provide a machine-readable copy of the Source Code or
+indicate a repository where this Source will be easily and freely available for
+as long as the Licensee continues to distribute and/or communicate the Work.
+
+Legal Protection: This Licence does not grant permission to use the trade names,
+trademarks, service marks, or names of the Licensor, except as required for
+reasonable and customary use in describing the origin of the Work and
+reproducing the content of the copyright notice.
+
+
+
+## 6. Chain of Authorship
+
+The original Licensor warrants that the copyright in the Original Work granted
+hereunder is owned by him/her or licensed to him/her and that he/she has the
+power and authority to grant the Licence.
+
+Each Contributor warrants that the copyright in the modifications he/she brings
+to the Work are owned by him/her or licensed to him/her and that he/she has the
+power and authority to grant the Licence.
+
+Each time You accept the Licence, the original Licensor and subsequent
+Contributors grant You a licence to their contributions to the Work, under the
+terms of this Licence.
+
+
+
+## 7. Disclaimer of Warranty
+
+The Work is a work in progress, which is continuously improved by numerous
+contributors. It is not a finished work and may therefore contain defects or
+“bugs” inherent to this type of software development.
+
+For the above reason, the Work is provided under the Licence on an “as is” basis
+and without warranties of any kind concerning the Work, including without
+limitation merchantability, fitness for a particular purpose, absence of defects
+or errors, accuracy, non-infringement of intellectual property rights other than
+copyright as stated in Article 6 of this Licence.
+
+This disclaimer of warranty is an essential part of the Licence and a condition
+for the grant of any rights to the Work.
+
+
+
+## 8. Disclaimer of Liability
+
+Except in the cases of wilful misconduct or damages directly caused to natural
+persons, the Licensor will in no event be liable for any direct or indirect,
+material or moral, damages of any kind, arising out of the Licence or of the use
+of the Work, including without limitation, damages for loss of goodwill, work
+stoppage, computer failure or malfunction, loss of data or any commercial
+damage, even if the Licensor has been advised of the possibility of such
+damage. However, the Licensor will be liable under statutory product liability
+laws as far such laws apply to the Work.
+
+
+
+## 9. Additional agreements
+
+While distributing the Original Work or Derivative Works, You may choose to
+conclude an additional agreement to offer, and charge a fee for, acceptance of
+support, warranty, indemnity, or other liability obligations and/or services
+consistent with this Licence. However, in accepting such obligations, You may
+act only on your own behalf and on your sole responsibility, not on behalf of
+the original Licensor or any other Contributor, and only if You agree to
+indemnify, defend, and hold each Contributor harmless for any liability incurred
+by, or claims asserted against such Contributor by the fact You have accepted
+any such warranty or additional liability.
+
+
+
+## 10. Acceptance of the Licence
+
+The provisions of this Licence can be accepted by clicking on an icon “I agree”
+placed under the bottom of a window displaying the text of this Licence or by
+affirming consent in any other similar way, in accordance with the rules of
+applicable law. Clicking on that icon indicates your clear and irrevocable
+acceptance of this Licence and all of its terms and conditions.
+
+Similarly, you irrevocably accept this Licence and all of its terms and
+conditions by exercising any rights granted to You by Article 2 of this Licence,
+such as the use of the Work, the creation by You of a Derivative Work or the
+Distribution and/or Communication by You of the Work or copies thereof.
+
+
+
+## 11. Information to the public
+
+In case of any Distribution and/or Communication of the Work by means of
+electronic communication by You (for example, by offering to download the Work
+from a remote location) the distribution channel or media (for example, a
+website) must at least provide to the public the information requested by the
+applicable law regarding the Licensor, the Licence and the way it may be
+accessible, concluded, stored and reproduced by the Licensee.
+
+
+
+## 12. Termination of the Licence
+
+The Licence and the rights granted hereunder will terminate automatically upon
+any breach by the Licensee of the terms of the Licence.
+
+Such a termination will not terminate the licences of any person who has
+received the Work from the Licensee under the Licence, provided such persons
+remain in full compliance with the Licence.
+
+
+
+## 13. Miscellaneous
+
+Without prejudice of Article 9 above, the Licence represents the complete
+agreement between the Parties as to the Work licensed hereunder.
+
+If any provision of the Licence is invalid or unenforceable under applicable
+law, this will not affect the validity or enforceability of the Licence as a
+whole. Such provision will be construed and/or reformed so as necessary to make
+it valid and enforceable.
+
+The European Commission may publish other linguistic versions and/or new
+versions of this Licence, so far this is required and reasonable, without
+reducing the scope of the rights granted by the Licence. New versions of the
+Licence will be published with a unique version number.
+
+All linguistic versions of this Licence, approved by the European Commission,
+have identical value. Parties can take advantage of the linguistic version of
+their choice.
+
+
+
+## 14. Jurisdiction
+
+Any litigation resulting from the interpretation of this License, arising
+between the European Commission, as a Licensor, and any Licensee, will be
+subject to the jurisdiction of the Court of Justice of the European Communities,
+as laid down in article 238 of the Treaty establishing the European Community.
+
+Any litigation arising between Parties, other than the European Commission, and
+resulting from the interpretation of this License, will be subject to the
+exclusive jurisdiction of the competent court where the Licensor resides or
+conducts its primary business.
+
+
+
+## 15. Applicable Law
+
+This Licence shall be governed by the law of the European Union country where
+the Licensor resides or has his registered office.
+
+This licence shall be governed by the Belgian law if:
+
+- a litigation arises between the European Commission, as a Licensor, and any
+- Licensee; the Licensor, other than the European Commission, has no residence
+- or registered office inside a European Union country.
+
+
+
+## Appendix
+
+
+
+“Compatible Licences” according to article 5 EUPL are:
+
+
+- GNU General Public License (GNU GPL) v. 2
+
+- Open Software License (OSL) v. 2.1, v. 3.0
+
+- Common Public License v. 1.0
+
+- Eclipse Public License v. 1.0
+
+- Cecill v. 2.0
--- a/README.md
+++ b/README.md
@ -0,0 +1,39 @@
+# Information System Monitor
+
+Information System Monitor is a administration tool for monitoring and displaying resources data concerning the D4Science Infrastructure.
+
+## Structure of the project
+
+* The source code is present in the src folder. 
+
+## Built With
+
+* [OpenJDK](https://openjdk.java.net/) - The JDK used
+* [Maven](https://maven.apache.org/) - Dependency Management
+
+## Documentation
+
+* Use of this application is is described on [Wiki](https://wiki.gcube-system.org/gcube/InformationSytemMonitor).
+
+## Change log
+
+See [Releases](https://code-repo.d4science.org/gCubeSystem/informationsystemmonitor/releases).
+
+## Authors
+
+* **Maria Teresa Paratore** ([ORCID](http://orcid.org/0000-0001-8375-6644)) - [ISTI-CNR Infrascience Group](http://nemis.isti.cnr.it/groups/infrascience)
+* **Giancarlo Panichi** ([ORCID](http://orcid.org/0000-0001-8375-6644)) - [ISTI-CNR Infrascience Group](http://nemis.isti.cnr.it/groups/infrascience)
+
+
+## License
+
+This project is licensed under the EUPL V.1.1 License - see the [LICENSE.md](LICENSE.md) file for details.
+
+
+## About the gCube Framework
+This software is part of the [gCubeFramework](https://www.gcube-system.org/ "gCubeFramework"): an
+open-source software toolkit used for building and operating Hybrid Data
+Infrastructures enabling the dynamic deployment of Virtual Research Environments
+by favouring the realisation of reuse oriented policies.
+ 
+The projects leading to this software have received funding from a series of European Union programmes see [FUNDING.md](FUNDING.md)
--- a/README_original.md
+++ b/README_original.md
@ -0,0 +1,396 @@
+# informationsystemmonitor
+
+This application was generated using JHipster 7.9.3, you can find documentation and help at [https://www.jhipster.tech/documentation-archive/v7.9.3](https://www.jhipster.tech/documentation-archive/v7.9.3).
+
+## Project Structure
+
+Node is required for generation and recommended for development. `package.json` is always generated for a better development experience with prettier, commit hooks, scripts and so on.
+
+In the project root, JHipster generates configuration files for tools like git, prettier, eslint, husky, and others that are well known and you can find references in the web.
+
+`/src/*` structure follows default Java structure.
+
+- `.yo-rc.json` - Yeoman configuration file
+  JHipster configuration is stored in this file at `generator-jhipster` key. You may find `generator-jhipster-*` for specific blueprints configuration.
+- `.yo-resolve` (optional) - Yeoman conflict resolver
+  Allows to use a specific action when conflicts are found skipping prompts for files that matches a pattern. Each line should match `[pattern] [action]` with pattern been a [Minimatch](https://github.com/isaacs/minimatch#minimatch) pattern and action been one of skip (default if ommited) or force. Lines starting with `#` are considered comments and are ignored.
+- `.jhipster/*.json` - JHipster entity configuration files
+
+- `npmw` - wrapper to use locally installed npm.
+  JHipster installs Node and npm locally using the build tool by default. This wrapper makes sure npm is installed locally and uses it avoiding some differences different versions can cause. By using `./npmw` instead of the traditional `npm` you can configure a Node-less environment to develop or test your application.
+- `/src/main/docker` - Docker configurations for the application and services that the application depends on
+
+## Development
+
+Before you can build this project, you must install and configure the following dependencies on your machine:
+
+1. [Node.js][]: We use Node to run a development web server and build the project.
+   Depending on your system, you can install Node either from source or as a pre-packaged bundle.
+
+After installing Node, you should be able to run the following command to install development tools.
+You will only need to run this command when dependencies change in [package.json](package.json).
+
+```
+npm install
+```
+
+We use npm scripts and [Angular CLI][] with [Webpack][] as our build system.
+
+Run the following commands in two separate terminals to create a blissful development experience where your browser
+auto-refreshes when files change on your hard drive.
+
+```
+./mvnw
+npm start
+```
+
+Npm is also used to manage CSS and JavaScript dependencies used in this application. You can upgrade dependencies by
+specifying a newer version in [package.json](package.json). You can also run `npm update` and `npm install` to manage dependencies.
+Add the `help` flag on any command to see how you can use it. For example, `npm help update`.
+
+The `npm run` command will list all of the scripts available to run for this project.
+
+### PWA Support
+
+JHipster ships with PWA (Progressive Web App) support, and it's turned off by default. One of the main components of a PWA is a service worker.
+
+The service worker initialization code is disabled by default. To enable it, uncomment the following code in `src/main/webapp/app/app.module.ts`:
+
+```typescript
+ServiceWorkerModule.register('ngsw-worker.js', { enabled: false }),
+```
+
+### Managing dependencies
+
+For example, to add [Leaflet][] library as a runtime dependency of your application, you would run following command:
+
+```
+npm install --save --save-exact leaflet
+```
+
+To benefit from TypeScript type definitions from [DefinitelyTyped][] repository in development, you would run following command:
+
+```
+npm install --save-dev --save-exact @types/leaflet
+```
+
+Then you would import the JS and CSS files specified in library's installation instructions so that [Webpack][] knows about them:
+Edit [src/main/webapp/app/app.module.ts](src/main/webapp/app/app.module.ts) file:
+
+```
+import 'leaflet/dist/leaflet.js';
+```
+
+Edit [src/main/webapp/content/scss/vendor.scss](src/main/webapp/content/scss/vendor.scss) file:
+
+```
+@import '~leaflet/dist/leaflet.css';
+```
+
+Note: There are still a few other things remaining to do for Leaflet that we won't detail here.
+
+For further instructions on how to develop with JHipster, have a look at [Using JHipster in development][].
+
+### Using Angular CLI
+
+You can also use [Angular CLI][] to generate some custom client code.
+
+For example, the following command:
+
+```
+ng generate component my-component
+```
+
+will generate few files:
+
+```
+create src/main/webapp/app/my-component/my-component.component.html
+create src/main/webapp/app/my-component/my-component.component.ts
+update src/main/webapp/app/app.module.ts
+```
+
+### JHipster Control Center
+
+JHipster Control Center can help you manage and control your application(s). You can start a local control center server (accessible on http://localhost:7419) with:
+
+```
+docker-compose -f src/main/docker/jhipster-control-center.yml up
+```
+
+### OAuth 2.0 / OpenID Connect
+
+Congratulations! You've selected an excellent way to secure your JHipster application. If you're not sure what OAuth and OpenID Connect (OIDC) are, please see [What the Heck is OAuth?](https://developer.okta.com/blog/2017/06/21/what-the-heck-is-oauth)
+
+To log in to your app, you'll need to have [Keycloak](https://keycloak.org) up and running. The JHipster Team has created a Docker container for you that has the default users and roles. Start Keycloak using the following command.
+
+```
+docker-compose -f src/main/docker/keycloak.yml up
+```
+
+The security settings in `src/main/resources/config/application.yml` are configured for this image.
+
+```yaml
+spring:
+  ...
+  security:
+    oauth2:
+      client:
+        provider:
+          oidc:
+            issuer-uri: http://localhost:9080/realms/jhipster
+        registration:
+          oidc:
+            client-id: web_app
+            client-secret: web_app
+            scope: openid,profile,email
+```
+
+Some of Keycloak configuration is now done in build time and the other part before running the app, here is the [list](https://www.keycloak.org/server/all-config) of all build and configuration options.
+
+Before moving to production, please make sure to follow this [guide](https://www.keycloak.org/server/configuration) for better security and performance.
+
+Also, you should never use `start-dev` nor `KC_DB=dev-file` in production.
+
+When using Kubernetes, importing should be done using init-containers (with a volume when using `db=dev-file`).
+
+### Okta
+
+If you'd like to use Okta instead of Keycloak, it's pretty quick using the [Okta CLI](https://cli.okta.com/). After you've installed it, run:
+
+```shell
+okta register
+```
+
+Then, in your JHipster app's directory, run `okta apps create` and select **JHipster**. This will set up an Okta app for you, create `ROLE_ADMIN` and `ROLE_USER` groups, create a `.okta.env` file with your Okta settings, and configure a `groups` claim in your ID token.
+
+Run `source .okta.env` and start your app with Maven or Gradle. You should be able to sign in with the credentials you registered with.
+
+If you're on Windows, you should install [WSL](https://docs.microsoft.com/en-us/windows/wsl/install-win10) so the `source` command will work.
+
+If you'd like to configure things manually through the Okta developer console, see the instructions below.
+
+First, you'll need to create a free developer account at <https://developer.okta.com/signup/>. After doing so, you'll get your own Okta domain, that has a name like `https://dev-123456.okta.com`.
+
+Modify `src/main/resources/config/application.yml` to use your Okta settings.
+
+```yaml
+spring:
+  ...
+  security:
+    oauth2:
+      client:
+        provider:
+          oidc:
+            issuer-uri: https://{yourOktaDomain}/oauth2/default
+        registration:
+          oidc:
+            client-id: {clientId}
+            client-secret: {clientSecret}
+security:
+```
+
+Create an OIDC App in Okta to get a `{clientId}` and `{clientSecret}`. To do this, log in to your Okta Developer account and navigate to **Applications** > **Add Application**. Click **Web** and click the **Next** button. Give the app a name you’ll remember, specify `http://localhost:8080` as a Base URI, and `http://localhost:8080/login/oauth2/code/oidc` as a Login Redirect URI. Click **Done**, then Edit and add `http://localhost:8080` as a Logout redirect URI. Copy and paste the client ID and secret into your `application.yml` file.
+
+Create a `ROLE_ADMIN` and `ROLE_USER` group and add users into them. Modify e2e tests to use this account when running integration tests. You'll need to change credentials in `src/test/javascript/e2e/account/account.spec.ts` and `src/test/javascript/e2e/admin/administration.spec.ts`.
+
+Navigate to **API** > **Authorization Servers**, click the **Authorization Servers** tab and edit the default one. Click the **Claims** tab and **Add Claim**. Name it "groups", and include it in the ID Token. Set the value type to "Groups" and set the filter to be a Regex of `.*`.
+
+After making these changes, you should be good to go! If you have any issues, please post them to [Stack Overflow](https://stackoverflow.com/questions/tagged/jhipster). Make sure to tag your question with "jhipster" and "okta".
+
+### Auth0
+
+If you'd like to use [Auth0](https://auth0.com/) instead of Keycloak, follow the configuration steps below:
+
+- Create a free developer account at <https://auth0.com/signup>. After successful sign-up, your account will be associated with a unique domain like `dev-xxx.us.auth0.com`
+- Create a new application of type `Regular Web Applications`. Switch to the `Settings` tab, and configure your application settings like:
+  - Allowed Callback URLs: `http://localhost:8080/login/oauth2/code/oidc`
+  - Allowed Logout URLs: `http://localhost:8080/`
+- Navigate to **User Management** > **Roles** and create new roles named `ROLE_ADMIN`, and `ROLE_USER`.
+- Navigate to **User Management** > **Users** and create a new user account. Click on the **Role** tab to assign roles to the newly created user account.
+- Navigate to **Auth Pipeline** > **Rules** and create a new Rule. Choose `Empty rule` template. Provide a meaningful name like `JHipster claims` and replace `Script` content with the following and Save.
+
+```javascript
+function (user, context, callback) {
+  user.preferred_username = user.email;
+  const roles = (context.authorization || {}).roles;
+
+  function prepareCustomClaimKey(claim) {
+    return `https://www.jhipster.tech/${claim}`;
+  }
+
+  const rolesClaim = prepareCustomClaimKey('roles');
+
+  if (context.idToken) {
+    context.idToken[rolesClaim] = roles;
+  }
+
+  if (context.accessToken) {
+    context.accessToken[rolesClaim] = roles;
+  }
+
+  callback(null, user, context);
+}
+```
+
+- In your `JHipster` application, modify `src/main/resources/config/application.yml` to use your Auth0 application settings:
+
+```yaml
+spring:
+  ...
+  security:
+    oauth2:
+      client:
+        provider:
+          oidc:
+            # make sure to include the ending slash!
+            issuer-uri: https://{your-auth0-domain}/
+        registration:
+          oidc:
+            client-id: {clientId}
+            client-secret: {clientSecret}
+            scope: openid,profile,email
+jhipster:
+  ...
+  security:
+    oauth2:
+      audience:
+        - https://{your-auth0-domain}/api/v2/
+```
+
+### Doing API-First development using openapi-generator-cli
+
+[OpenAPI-Generator]() is configured for this application. You can generate API code from the `src/main/resources/swagger/api.yml` definition file by running:
+
+```bash
+./mvnw generate-sources
+```
+
+Then implements the generated delegate classes with `@Service` classes.
+
+To edit the `api.yml` definition file, you can use a tool such as [Swagger-Editor](). Start a local instance of the swagger-editor using docker by running: `docker-compose -f src/main/docker/swagger-editor.yml up -d`. The editor will then be reachable at [http://localhost:7742](http://localhost:7742).
+
+Refer to [Doing API-First development][] for more details.
+
+## Building for production
+
+### Packaging as jar
+
+To build the final jar and optimize the informationsystemmonitor application for production, run:
+
+```
+./mvnw -Pprod clean verify
+```
+
+This will concatenate and minify the client CSS and JavaScript files. It will also modify `index.html` so it references these new files.
+To ensure everything worked, run:
+
+```
+java -jar target/*.jar
+```
+
+Then navigate to [http://localhost:8080](http://localhost:8080) in your browser.
+
+Refer to [Using JHipster in production][] for more details.
+
+### Packaging as war
+
+To package your application as a war in order to deploy it to an application server, run:
+
+```
+./mvnw -Pprod,war clean verify
+```
+
+## Testing
+
+To launch your application's tests, run:
+
+```
+./mvnw verify
+```
+
+### Client tests
+
+Unit tests are run by [Jest][]. They're located in [src/test/javascript/](src/test/javascript/) and can be run with:
+
+```
+npm test
+```
+
+For more information, refer to the [Running tests page][].
+
+### Code quality
+
+Sonar is used to analyse code quality. You can start a local Sonar server (accessible on http://localhost:9001) with:
+
+```
+docker-compose -f src/main/docker/sonar.yml up -d
+```
+
+Note: we have turned off authentication in [src/main/docker/sonar.yml](src/main/docker/sonar.yml) for out of the box experience while trying out SonarQube, for real use cases turn it back on.
+
+You can run a Sonar analysis with using the [sonar-scanner](https://docs.sonarqube.org/display/SCAN/Analyzing+with+SonarQube+Scanner) or by using the maven plugin.
+
+Then, run a Sonar analysis:
+
+```
+./mvnw -Pprod clean verify sonar:sonar
+```
+
+If you need to re-run the Sonar phase, please be sure to specify at least the `initialize` phase since Sonar properties are loaded from the sonar-project.properties file.
+
+```
+./mvnw initialize sonar:sonar
+```
+
+For more information, refer to the [Code quality page][].
+
+## Using Docker to simplify development (optional)
+
+You can use Docker to improve your JHipster development experience. A number of docker-compose configuration are available in the [src/main/docker](src/main/docker) folder to launch required third party services.
+
+You can also fully dockerize your application and all the services that it depends on.
+To achieve this, first build a docker image of your app by running:
+
+```
+npm run java:docker
+```
+
+Or build a arm64 docker image when using an arm64 processor os like MacOS with M1 processor family running:
+
+```
+npm run java:docker:arm64
+```
+
+Then run:
+
+```
+docker-compose -f src/main/docker/app.yml up -d
+```
+
+When running Docker Desktop on MacOS Big Sur or later, consider enabling experimental `Use the new Virtualization framework` for better processing performance ([disk access performance is worse](https://github.com/docker/roadmap/issues/7)).
+
+For more information refer to [Using Docker and Docker-Compose][], this page also contains information on the docker-compose sub-generator (`jhipster docker-compose`), which is able to generate docker configurations for one or several JHipster applications.
+
+## Continuous Integration (optional)
+
+To configure CI for your project, run the ci-cd sub-generator (`jhipster ci-cd`), this will let you generate configuration files for a number of Continuous Integration systems. Consult the [Setting up Continuous Integration][] page for more information.
+
+[jhipster homepage and latest documentation]: https://www.jhipster.tech
+[jhipster 7.9.3 archive]: https://www.jhipster.tech/documentation-archive/v7.9.3
+[using jhipster in development]: https://www.jhipster.tech/documentation-archive/v7.9.3/development/
+[using docker and docker-compose]: https://www.jhipster.tech/documentation-archive/v7.9.3/docker-compose
+[using jhipster in production]: https://www.jhipster.tech/documentation-archive/v7.9.3/production/
+[running tests page]: https://www.jhipster.tech/documentation-archive/v7.9.3/running-tests/
+[code quality page]: https://www.jhipster.tech/documentation-archive/v7.9.3/code-quality/
+[setting up continuous integration]: https://www.jhipster.tech/documentation-archive/v7.9.3/setting-up-ci/
+[node.js]: https://nodejs.org/
+[npm]: https://www.npmjs.com/
+[webpack]: https://webpack.github.io/
+[browsersync]: https://www.browsersync.io/
+[jest]: https://facebook.github.io/jest/
+[leaflet]: https://leafletjs.com/
+[definitelytyped]: https://definitelytyped.org/
+[angular cli]: https://cli.angular.io/
+[openapi-generator]: https://openapi-generator.tech
+[swagger-editor]: https://editor.swagger.io
+[doing api-first development]: https://www.jhipster.tech/documentation-archive/v7.9.3/doing-api-first-development/
--- a/angular.json
+++ b/angular.json
@ -0,0 +1,109 @@
+{
+  "$schema": "./node_modules/@angular/cli/lib/config/schema.json",
+  "version": 1,
+  "newProjectRoot": "projects",
+  "projects": {
+    "informationsystemmonitor": {
+      "projectType": "application",
+      "schematics": {
+        "@schematics/angular:component": {
+          "style": "scss"
+        },
+        "@schematics/angular:application": {
+          "strict": true
+        }
+      },
+      "root": "",
+      "sourceRoot": "src/main/webapp",
+      "prefix": "jhi",
+      "architect": {
+        "build": {
+          "builder": "@angular-builders/custom-webpack:browser",
+          "options": {
+            "customWebpackConfig": {
+              "path": "./webpack/webpack.custom.js"
+            },
+            "outputPath": "target/classes/static/",
+            "index": "src/main/webapp/index.html",
+            "main": "src/main/webapp/main.ts",
+            "polyfills": "src/main/webapp/polyfills.ts",
+            "tsConfig": "tsconfig.app.json",
+            "inlineStyleLanguage": "scss",
+            "assets": [
+              "src/main/webapp/content",
+              "src/main/webapp/favicon.ico",
+              "src/main/webapp/manifest.webapp",
+              "src/main/webapp/robots.txt"
+            ],
+            "styles": ["src/main/webapp/content/scss/vendor.scss", "src/main/webapp/content/scss/global.scss"],
+            "scripts": []
+          },
+          "configurations": {
+            "production": {
+              "optimization": true,
+              "outputHashing": "all",
+              "sourceMap": false,
+              "namedChunks": false,
+              "extractLicenses": true,
+              "vendorChunk": false,
+              "buildOptimizer": true,
+              "serviceWorker": true,
+              "ngswConfigPath": "ngsw-config.json",
+              "budgets": [
+                {
+                  "type": "initial",
+                  "maximumWarning": "500kb",
+                  "maximumError": "1mb"
+                },
+                {
+                  "type": "anyComponentStyle",
+                  "maximumWarning": "2kb",
+                  "maximumError": "4kb"
+                }
+              ]
+            },
+            "development": {
+              "buildOptimizer": false,
+              "optimization": false,
+              "vendorChunk": true,
+              "extractLicenses": false,
+              "sourceMap": true,
+              "namedChunks": true
+            }
+          },
+          "defaultConfiguration": "production"
+        },
+        "serve": {
+          "builder": "@angular-builders/custom-webpack:dev-server",
+          "options": {
+            "browserTarget": "informationsystemmonitor:build:development",
+            "port": 4200
+          },
+          "configurations": {
+            "production": {
+              "browserTarget": "informationsystemmonitor:build:production"
+            },
+            "development": {
+              "browserTarget": "informationsystemmonitor:build:development"
+            }
+          },
+          "defaultConfiguration": "development"
+        },
+        "test": {
+          "builder": "@angular-builders/jest:run",
+          "options": {
+            "configPath": "jest.conf.js"
+          }
+        }
+      }
+    }
+  },
+  "cli": {
+    "cache": {
+      "enabled": true,
+      "path": "./target/angular/",
+      "environment": "all"
+    },
+    "packageManager": "npm"
+  }
+}
--- a/checkstyle.xml
+++ b/checkstyle.xml
@ -0,0 +1,20 @@
+<?xml version="1.0"?>
+<!DOCTYPE module PUBLIC "-//Puppy Crawl//DTD Check Configuration 1.3//EN"
+        "https://checkstyle.org/dtds/configuration_1_3.dtd">
+<module name="Checker">
+
+    <!-- Configure checker to use UTF-8 encoding -->
+    <property name="charset" value="UTF-8"/>
+    <!-- Configure checker to run on files with these extensions -->
+    <property name="fileExtensions" value=""/>
+    <!-- For detailed checkstyle configuration, see https://github.com/spring-io/nohttp/tree/master/nohttp-checkstyle -->
+    <module name="io.spring.nohttp.checkstyle.check.NoHttpCheck">
+        <property name="allowlist" value="^\Qhttp://maven.apache.org/POM/4.0.0&#10;^\Qhttp://www.w3.org/2001/XMLSchema-instance"/>
+    </module>
+    <!-- Allow suppression with comments
+       // CHECKSTYLE:OFF
+       ... ignored content ...
+       // CHECKSTYLE:ON
+    -->
+    <module name="SuppressWithPlainTextCommentFilter"/>
+</module>
--- a/jest.conf.js
+++ b/jest.conf.js
@ -0,0 +1,29 @@
+const { pathsToModuleNameMapper } = require('ts-jest');
+
+const {
+  compilerOptions: { paths = {}, baseUrl = './' },
+} = require('./tsconfig.json');
+const environment = require('./webpack/environment');
+
+module.exports = {
+  transformIgnorePatterns: ['node_modules/(?!.*\\.mjs$|dayjs/esm)'],
+  resolver: 'jest-preset-angular/build/resolvers/ng-jest-resolver.js',
+  globals: {
+    ...environment,
+  },
+  roots: ['<rootDir>', `<rootDir>/${baseUrl}`],
+  modulePaths: [`<rootDir>/${baseUrl}`],
+  setupFiles: ['jest-date-mock'],
+  cacheDirectory: '<rootDir>/target/jest-cache',
+  coverageDirectory: '<rootDir>/target/test-results/',
+  moduleNameMapper: pathsToModuleNameMapper(paths, { prefix: `<rootDir>/${baseUrl}/` }),
+  reporters: [
+    'default',
+    ['jest-junit', { outputDirectory: '<rootDir>/target/test-results/', outputName: 'TESTS-results-jest.xml' }],
+    ['jest-sonar', { outputDirectory: './target/test-results/jest', outputName: 'TESTS-results-sonar.xml' }],
+  ],
+  testMatch: ['<rootDir>/src/main/webapp/app/**/@(*.)@(spec.ts)'],
+  testEnvironmentOptions: {
+    url: 'https://jhipster.tech',
+  },
+};
--- a/316
+++ b/316
@ -0,0 +1,316 @@
+#!/bin/sh
+# ----------------------------------------------------------------------------
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+# ----------------------------------------------------------------------------
+
+# ----------------------------------------------------------------------------
+# Maven Start Up Batch script
+#
+# Required ENV vars:
+# ------------------
+#   JAVA_HOME - location of a JDK home dir
+#
+# Optional ENV vars
+# -----------------
+#   M2_HOME - location of maven2's installed home dir
+#   MAVEN_OPTS - parameters passed to the Java VM when running Maven
+#     e.g. to debug Maven itself, use
+#       set MAVEN_OPTS=-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=8000
+#   MAVEN_SKIP_RC - flag to disable loading of mavenrc files
+# ----------------------------------------------------------------------------
+
+if [ -z "$MAVEN_SKIP_RC" ] ; then
+
+  if [ -f /usr/local/etc/mavenrc ] ; then
+    . /usr/local/etc/mavenrc
+  fi
+
+  if [ -f /etc/mavenrc ] ; then
+    . /etc/mavenrc
+  fi
+
+  if [ -f "$HOME/.mavenrc" ] ; then
+    . "$HOME/.mavenrc"
+  fi
+
+fi
+
+# OS specific support.  $var _must_ be set to either true or false.
+cygwin=false;
+darwin=false;
+mingw=false
+case "`uname`" in
+  CYGWIN*) cygwin=true ;;
+  MINGW*) mingw=true;;
+  Darwin*) darwin=true
+    # Use /usr/libexec/java_home if available, otherwise fall back to /Library/Java/Home
+    # See https://developer.apple.com/library/mac/qa/qa1170/_index.html
+    if [ -z "$JAVA_HOME" ]; then
+      if [ -x "/usr/libexec/java_home" ]; then
+        export JAVA_HOME="`/usr/libexec/java_home`"
+      else
+        export JAVA_HOME="/Library/Java/Home"
+      fi
+    fi
+    ;;
+esac
+
+if [ -z "$JAVA_HOME" ] ; then
+  if [ -r /etc/gentoo-release ] ; then
+    JAVA_HOME=`java-config --jre-home`
+  fi
+fi
+
+if [ -z "$M2_HOME" ] ; then
+  ## resolve links - $0 may be a link to maven's home
+  PRG="$0"
+
+  # need this for relative symlinks
+  while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+      PRG="$link"
+    else
+      PRG="`dirname "$PRG"`/$link"
+    fi
+  done
+
+  saveddir=`pwd`
+
+  M2_HOME=`dirname "$PRG"`/..
+
+  # make it fully qualified
+  M2_HOME=`cd "$M2_HOME" && pwd`
+
+  cd "$saveddir"
+  # echo Using m2 at $M2_HOME
+fi
+
+# For Cygwin, ensure paths are in UNIX format before anything is touched
+if $cygwin ; then
+  [ -n "$M2_HOME" ] &&
+    M2_HOME=`cygpath --unix "$M2_HOME"`
+  [ -n "$JAVA_HOME" ] &&
+    JAVA_HOME=`cygpath --unix "$JAVA_HOME"`
+  [ -n "$CLASSPATH" ] &&
+    CLASSPATH=`cygpath --path --unix "$CLASSPATH"`
+fi
+
+# For Mingw, ensure paths are in UNIX format before anything is touched
+if $mingw ; then
+  [ -n "$M2_HOME" ] &&
+    M2_HOME="`(cd "$M2_HOME"; pwd)`"
+  [ -n "$JAVA_HOME" ] &&
+    JAVA_HOME="`(cd "$JAVA_HOME"; pwd)`"
+fi
+
+if [ -z "$JAVA_HOME" ]; then
+  javaExecutable="`which javac`"
+  if [ -n "$javaExecutable" ] && ! [ "`expr \"$javaExecutable\" : '\([^ ]*\)'`" = "no" ]; then
+    # readlink(1) is not available as standard on Solaris 10.
+    readLink=`which readlink`
+    if [ ! `expr "$readLink" : '\([^ ]*\)'` = "no" ]; then
+      if $darwin ; then
+        javaHome="`dirname \"$javaExecutable\"`"
+        javaExecutable="`cd \"$javaHome\" && pwd -P`/javac"
+      else
+        javaExecutable="`readlink -f \"$javaExecutable\"`"
+      fi
+      javaHome="`dirname \"$javaExecutable\"`"
+      javaHome=`expr "$javaHome" : '\(.*\)/bin'`
+      JAVA_HOME="$javaHome"
+      export JAVA_HOME
+    fi
+  fi
+fi
+
+if [ -z "$JAVACMD" ] ; then
+  if [ -n "$JAVA_HOME"  ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+      # IBM's JDK on AIX uses strange locations for the executables
+      JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+      JAVACMD="$JAVA_HOME/bin/java"
+    fi
+  else
+    JAVACMD="`\\unset -f command; \\command -v java`"
+  fi
+fi
+
+if [ ! -x "$JAVACMD" ] ; then
+  echo "Error: JAVA_HOME is not defined correctly." >&2
+  echo "  We cannot execute $JAVACMD" >&2
+  exit 1
+fi
+
+if [ -z "$JAVA_HOME" ] ; then
+  echo "Warning: JAVA_HOME environment variable is not set."
+fi
+
+CLASSWORLDS_LAUNCHER=org.codehaus.plexus.classworlds.launcher.Launcher
+
+# traverses directory structure from process work directory to filesystem root
+# first directory with .mvn subdirectory is considered project base directory
+find_maven_basedir() {
+
+  if [ -z "$1" ]
+  then
+    echo "Path not specified to find_maven_basedir"
+    return 1
+  fi
+
+  basedir="$1"
+  wdir="$1"
+  while [ "$wdir" != '/' ] ; do
+    if [ -d "$wdir"/.mvn ] ; then
+      basedir=$wdir
+      break
+    fi
+    # workaround for JBEAP-8937 (on Solaris 10/Sparc)
+    if [ -d "${wdir}" ]; then
+      wdir=`cd "$wdir/.."; pwd`
+    fi
+    # end of workaround
+  done
+  echo "${basedir}"
+}
+
+# concatenates all lines of a file
+concat_lines() {
+  if [ -f "$1" ]; then
+    echo "$(tr -s '\n' ' ' < "$1")"
+  fi
+}
+
+BASE_DIR=`find_maven_basedir "$(pwd)"`
+if [ -z "$BASE_DIR" ]; then
+  exit 1;
+fi
+
+##########################################################################################
+# Extension to allow automatically downloading the maven-wrapper.jar from Maven-central
+# This allows using the maven wrapper in projects that prohibit checking in binary data.
+##########################################################################################
+if [ -r "$BASE_DIR/.mvn/wrapper/maven-wrapper.jar" ]; then
+    if [ "$MVNW_VERBOSE" = true ]; then
+      echo "Found .mvn/wrapper/maven-wrapper.jar"
+    fi
+else
+    if [ "$MVNW_VERBOSE" = true ]; then
+      echo "Couldn't find .mvn/wrapper/maven-wrapper.jar, downloading it ..."
+    fi
+    if [ -n "$MVNW_REPOURL" ]; then
+      jarUrl="$MVNW_REPOURL/org/apache/maven/wrapper/maven-wrapper/3.1.0/maven-wrapper-3.1.0.jar"
+    else
+      jarUrl="https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.1.0/maven-wrapper-3.1.0.jar"
+    fi
+    while IFS="=" read key value; do
+      case "$key" in (wrapperUrl) jarUrl="$value"; break ;;
+      esac
+    done < "$BASE_DIR/.mvn/wrapper/maven-wrapper.properties"
+    if [ "$MVNW_VERBOSE" = true ]; then
+      echo "Downloading from: $jarUrl"
+    fi
+    wrapperJarPath="$BASE_DIR/.mvn/wrapper/maven-wrapper.jar"
+    if $cygwin; then
+      wrapperJarPath=`cygpath --path --windows "$wrapperJarPath"`
+    fi
+
+    if command -v wget > /dev/null; then
+        if [ "$MVNW_VERBOSE" = true ]; then
+          echo "Found wget ... using wget"
+        fi
+        if [ -z "$MVNW_USERNAME" ] || [ -z "$MVNW_PASSWORD" ]; then
+            wget "$jarUrl" -O "$wrapperJarPath" || rm -f "$wrapperJarPath"
+        else
+            wget --http-user=$MVNW_USERNAME --http-password=$MVNW_PASSWORD "$jarUrl" -O "$wrapperJarPath" || rm -f "$wrapperJarPath"
+        fi
+    elif command -v curl > /dev/null; then
+        if [ "$MVNW_VERBOSE" = true ]; then
+          echo "Found curl ... using curl"
+        fi
+        if [ -z "$MVNW_USERNAME" ] || [ -z "$MVNW_PASSWORD" ]; then
+            curl -o "$wrapperJarPath" "$jarUrl" -f
+        else
+            curl --user $MVNW_USERNAME:$MVNW_PASSWORD -o "$wrapperJarPath" "$jarUrl" -f
+        fi
+
+    else
+        if [ "$MVNW_VERBOSE" = true ]; then
+          echo "Falling back to using Java to download"
+        fi
+        javaClass="$BASE_DIR/.mvn/wrapper/MavenWrapperDownloader.java"
+        # For Cygwin, switch paths to Windows format before running javac
+        if $cygwin; then
+          javaClass=`cygpath --path --windows "$javaClass"`
+        fi
+        if [ -e "$javaClass" ]; then
+            if [ ! -e "$BASE_DIR/.mvn/wrapper/MavenWrapperDownloader.class" ]; then
+                if [ "$MVNW_VERBOSE" = true ]; then
+                  echo " - Compiling MavenWrapperDownloader.java ..."
+                fi
+                # Compiling the Java class
+                ("$JAVA_HOME/bin/javac" "$javaClass")
+            fi
+            if [ -e "$BASE_DIR/.mvn/wrapper/MavenWrapperDownloader.class" ]; then
+                # Running the downloader
+                if [ "$MVNW_VERBOSE" = true ]; then
+                  echo " - Running MavenWrapperDownloader.java ..."
+                fi
+                ("$JAVA_HOME/bin/java" -cp .mvn/wrapper MavenWrapperDownloader "$MAVEN_PROJECTBASEDIR")
+            fi
+        fi
+    fi
+fi
+##########################################################################################
+# End of extension
+##########################################################################################
+
+export MAVEN_PROJECTBASEDIR=${MAVEN_BASEDIR:-"$BASE_DIR"}
+if [ "$MVNW_VERBOSE" = true ]; then
+  echo $MAVEN_PROJECTBASEDIR
+fi
+MAVEN_OPTS="$(concat_lines "$MAVEN_PROJECTBASEDIR/.mvn/jvm.config") $MAVEN_OPTS"
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin; then
+  [ -n "$M2_HOME" ] &&
+    M2_HOME=`cygpath --path --windows "$M2_HOME"`
+  [ -n "$JAVA_HOME" ] &&
+    JAVA_HOME=`cygpath --path --windows "$JAVA_HOME"`
+  [ -n "$CLASSPATH" ] &&
+    CLASSPATH=`cygpath --path --windows "$CLASSPATH"`
+  [ -n "$MAVEN_PROJECTBASEDIR" ] &&
+    MAVEN_PROJECTBASEDIR=`cygpath --path --windows "$MAVEN_PROJECTBASEDIR"`
+fi
+
+# Provide a "standardized" way to retrieve the CLI args that will
+# work with both Windows and non-Windows executions.
+MAVEN_CMD_LINE_ARGS="$MAVEN_CONFIG $@"
+export MAVEN_CMD_LINE_ARGS
+
+WRAPPER_LAUNCHER=org.apache.maven.wrapper.MavenWrapperMain
+
+exec "$JAVACMD" \
+  $MAVEN_OPTS \
+  $MAVEN_DEBUG_OPTS \
+  -classpath "$MAVEN_PROJECTBASEDIR/.mvn/wrapper/maven-wrapper.jar" \
+  "-Dmaven.home=${M2_HOME}" \
+  "-Dmaven.multiModuleProjectDirectory=${MAVEN_PROJECTBASEDIR}" \
+  ${WRAPPER_LAUNCHER} $MAVEN_CONFIG "$@"
--- a/mvnw.cmd
+++ b/mvnw.cmd
@ -0,0 +1,188 @@
+@REM ----------------------------------------------------------------------------
+@REM Licensed to the Apache Software Foundation (ASF) under one
+@REM or more contributor license agreements.  See the NOTICE file
+@REM distributed with this work for additional information
+@REM regarding copyright ownership.  The ASF licenses this file
+@REM to you under the Apache License, Version 2.0 (the
+@REM "License"); you may not use this file except in compliance
+@REM with the License.  You may obtain a copy of the License at
+@REM
+@REM    http://www.apache.org/licenses/LICENSE-2.0
+@REM
+@REM Unless required by applicable law or agreed to in writing,
+@REM software distributed under the License is distributed on an
+@REM "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+@REM KIND, either express or implied.  See the License for the
+@REM specific language governing permissions and limitations
+@REM under the License.
+@REM ----------------------------------------------------------------------------
+
+@REM ----------------------------------------------------------------------------
+@REM Maven Start Up Batch script
+@REM
+@REM Required ENV vars:
+@REM JAVA_HOME - location of a JDK home dir
+@REM
+@REM Optional ENV vars
+@REM M2_HOME - location of maven2's installed home dir
+@REM MAVEN_BATCH_ECHO - set to 'on' to enable the echoing of the batch commands
+@REM MAVEN_BATCH_PAUSE - set to 'on' to wait for a keystroke before ending
+@REM MAVEN_OPTS - parameters passed to the Java VM when running Maven
+@REM     e.g. to debug Maven itself, use
+@REM set MAVEN_OPTS=-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=8000
+@REM MAVEN_SKIP_RC - flag to disable loading of mavenrc files
+@REM ----------------------------------------------------------------------------
+
+@REM Begin all REM lines with '@' in case MAVEN_BATCH_ECHO is 'on'
+@echo off
+@REM set title of command window
+title %0
+@REM enable echoing by setting MAVEN_BATCH_ECHO to 'on'
+@if "%MAVEN_BATCH_ECHO%" == "on"  echo %MAVEN_BATCH_ECHO%
+
+@REM set %HOME% to equivalent of $HOME
+if "%HOME%" == "" (set "HOME=%HOMEDRIVE%%HOMEPATH%")
+
+@REM Execute a user defined script before this one
+if not "%MAVEN_SKIP_RC%" == "" goto skipRcPre
+@REM check for pre script, once with legacy .bat ending and once with .cmd ending
+if exist "%USERPROFILE%\mavenrc_pre.bat" call "%USERPROFILE%\mavenrc_pre.bat" %*
+if exist "%USERPROFILE%\mavenrc_pre.cmd" call "%USERPROFILE%\mavenrc_pre.cmd" %*
+:skipRcPre
+
+@setlocal
+
+set ERROR_CODE=0
+
+@REM To isolate internal variables from possible post scripts, we use another setlocal
+@setlocal
+
+@REM ==== START VALIDATION ====
+if not "%JAVA_HOME%" == "" goto OkJHome
+
+echo.
+echo Error: JAVA_HOME not found in your environment. >&2
+echo Please set the JAVA_HOME variable in your environment to match the >&2
+echo location of your Java installation. >&2
+echo.
+goto error
+
+:OkJHome
+if exist "%JAVA_HOME%\bin\java.exe" goto init
+
+echo.
+echo Error: JAVA_HOME is set to an invalid directory. >&2
+echo JAVA_HOME = "%JAVA_HOME%" >&2
+echo Please set the JAVA_HOME variable in your environment to match the >&2
+echo location of your Java installation. >&2
+echo.
+goto error
+
+@REM ==== END VALIDATION ====
+
+:init
+
+@REM Find the project base dir, i.e. the directory that contains the folder ".mvn".
+@REM Fallback to current working directory if not found.
+
+set MAVEN_PROJECTBASEDIR=%MAVEN_BASEDIR%
+IF NOT "%MAVEN_PROJECTBASEDIR%"=="" goto endDetectBaseDir
+
+set EXEC_DIR=%CD%
+set WDIR=%EXEC_DIR%
+:findBaseDir
+IF EXIST "%WDIR%"\.mvn goto baseDirFound
+cd ..
+IF "%WDIR%"=="%CD%" goto baseDirNotFound
+set WDIR=%CD%
+goto findBaseDir
+
+:baseDirFound
+set MAVEN_PROJECTBASEDIR=%WDIR%
+cd "%EXEC_DIR%"
+goto endDetectBaseDir
+
+:baseDirNotFound
+set MAVEN_PROJECTBASEDIR=%EXEC_DIR%
+cd "%EXEC_DIR%"
+
+:endDetectBaseDir
+
+IF NOT EXIST "%MAVEN_PROJECTBASEDIR%\.mvn\jvm.config" goto endReadAdditionalConfig
+
+@setlocal EnableExtensions EnableDelayedExpansion
+for /F "usebackq delims=" %%a in ("%MAVEN_PROJECTBASEDIR%\.mvn\jvm.config") do set JVM_CONFIG_MAVEN_PROPS=!JVM_CONFIG_MAVEN_PROPS! %%a
+@endlocal & set JVM_CONFIG_MAVEN_PROPS=%JVM_CONFIG_MAVEN_PROPS%
+
+:endReadAdditionalConfig
+
+SET MAVEN_JAVA_EXE="%JAVA_HOME%\bin\java.exe"
+set WRAPPER_JAR="%MAVEN_PROJECTBASEDIR%\.mvn\wrapper\maven-wrapper.jar"
+set WRAPPER_LAUNCHER=org.apache.maven.wrapper.MavenWrapperMain
+
+set DOWNLOAD_URL="https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.1.0/maven-wrapper-3.1.0.jar"
+
+FOR /F "usebackq tokens=1,2 delims==" %%A IN ("%MAVEN_PROJECTBASEDIR%\.mvn\wrapper\maven-wrapper.properties") DO (
+    IF "%%A"=="wrapperUrl" SET DOWNLOAD_URL=%%B
+)
+
+@REM Extension to allow automatically downloading the maven-wrapper.jar from Maven-central
+@REM This allows using the maven wrapper in projects that prohibit checking in binary data.
+if exist %WRAPPER_JAR% (
+    if "%MVNW_VERBOSE%" == "true" (
+        echo Found %WRAPPER_JAR%
+    )
+) else (
+    if not "%MVNW_REPOURL%" == "" (
+        SET DOWNLOAD_URL="%MVNW_REPOURL%/org/apache/maven/wrapper/maven-wrapper/3.1.0/maven-wrapper-3.1.0.jar"
+    )
+    if "%MVNW_VERBOSE%" == "true" (
+        echo Couldn't find %WRAPPER_JAR%, downloading it ...
+        echo Downloading from: %DOWNLOAD_URL%
+    )
+
+    powershell -Command "&{"^
+		"$webclient = new-object System.Net.WebClient;"^
+		"if (-not ([string]::IsNullOrEmpty('%MVNW_USERNAME%') -and [string]::IsNullOrEmpty('%MVNW_PASSWORD%'))) {"^
+		"$webclient.Credentials = new-object System.Net.NetworkCredential('%MVNW_USERNAME%', '%MVNW_PASSWORD%');"^
+		"}"^
+		"[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12; $webclient.DownloadFile('%DOWNLOAD_URL%', '%WRAPPER_JAR%')"^
+		"}"
+    if "%MVNW_VERBOSE%" == "true" (
+        echo Finished downloading %WRAPPER_JAR%
+    )
+)
+@REM End of extension
+
+@REM Provide a "standardized" way to retrieve the CLI args that will
+@REM work with both Windows and non-Windows executions.
+set MAVEN_CMD_LINE_ARGS=%*
+
+%MAVEN_JAVA_EXE% ^
+  %JVM_CONFIG_MAVEN_PROPS% ^
+  %MAVEN_OPTS% ^
+  %MAVEN_DEBUG_OPTS% ^
+  -classpath %WRAPPER_JAR% ^
+  "-Dmaven.multiModuleProjectDirectory=%MAVEN_PROJECTBASEDIR%" ^
+  %WRAPPER_LAUNCHER% %MAVEN_CONFIG% %*
+if ERRORLEVEL 1 goto error
+goto end
+
+:error
+set ERROR_CODE=1
+
+:end
+@endlocal & set ERROR_CODE=%ERROR_CODE%
+
+if not "%MAVEN_SKIP_RC%"=="" goto skipRcPost
+@REM check for post script, once with legacy .bat ending and once with .cmd ending
+if exist "%USERPROFILE%\mavenrc_post.bat" call "%USERPROFILE%\mavenrc_post.bat"
+if exist "%USERPROFILE%\mavenrc_post.cmd" call "%USERPROFILE%\mavenrc_post.cmd"
+:skipRcPost
+
+@REM pause the script if MAVEN_BATCH_PAUSE is set to 'on'
+if "%MAVEN_BATCH_PAUSE%"=="on" pause
+
+if "%MAVEN_TERMINATE_CMD%"=="on" exit %ERROR_CODE%
+
+cmd /C exit /B %ERROR_CODE%
--- a/ngsw-config.json
+++ b/ngsw-config.json
@ -0,0 +1,21 @@
+{
+  "$schema": "./node_modules/@angular/service-worker/config/schema.json",
+  "index": "/index.html",
+  "assetGroups": [
+    {
+      "name": "app",
+      "installMode": "prefetch",
+      "resources": {
+        "files": ["/favicon.ico", "/index.html", "/manifest.webapp", "/*.css", "/*.js"]
+      }
+    },
+    {
+      "name": "assets",
+      "installMode": "lazy",
+      "updateMode": "prefetch",
+      "resources": {
+        "files": ["/content/**", "/*.(eot|svg|cur|jpg|png|webp|gif|otf|ttf|woff|woff2|ani)"]
+      }
+    }
+  ]
+}
--- a/42
+++ b/42
@ -0,0 +1,42 @@
+#!/bin/sh
+
+basedir=`dirname "$0"`
+
+if [ -f "$basedir/mvnw" ]; then
+  bindir="$basedir/target/node"
+  repodir="$basedir/target/node/node_modules"
+  installCommand="$basedir/mvnw -Pwebapp frontend:install-node-and-npm@install-node-and-npm"
+
+  PATH="$basedir/$builddir/:$PATH"
+  NPM_EXE="$basedir/$builddir/node_modules/npm/bin/npm-cli.js"
+  NODE_EXE="$basedir/$builddir/node"
+elif [ -f "$basedir/gradlew" ]; then
+  bindir="$basedir/build/node/bin"
+  repodir="$basedir/build/node/lib/node_modules"
+  installCommand="$basedir/gradlew npmSetup"
+else
+  echo "Using npm installed globally"
+  exec npm "$@"
+fi
+
+NPM_EXE="$repodir/npm/bin/npm-cli.js"
+NODE_EXE="$bindir/node"
+
+if [ ! -x "$NPM_EXE" ] || [ ! -x "$NODE_EXE" ]; then
+  $installCommand || true
+fi
+
+if [ -x "$NODE_EXE" ]; then
+  echo "Using node installed locally $($NODE_EXE --version)"
+  PATH="$bindir:$PATH"
+else
+  NODE_EXE='node'
+fi
+
+if [ ! -x "$NPM_EXE" ]; then
+  echo "Local npm not found, using npm installed globally"
+  npm "$@"
+else
+  echo "Using npm installed locally $($NODE_EXE $NPM_EXE --version)"
+  $NODE_EXE $NPM_EXE "$@"
+fi
--- a/npmw.cmd
+++ b/npmw.cmd
@ -0,0 +1,31 @@
+@echo off
+
+setlocal
+
+set NPMW_DIR=%~dp0
+
+if exist "%NPMW_DIR%mvnw.cmd" (
+  set NODE_EXE=^"^"
+  set NODE_PATH=%NPMW_DIR%target\node\
+  set NPM_EXE=^"%NPMW_DIR%target\node\npm.cmd^"
+  set INSTALL_NPM_COMMAND=^"%NPMW_DIR%mvnw.cmd^" -Pwebapp frontend:install-node-and-npm@install-node-and-npm
+) else (
+  set NODE_EXE=^"%NPMW_DIR%build\node\bin\node.exe^"
+  set NODE_PATH=%NPMW_DIR%build\node\bin\
+  set NPM_EXE=^"%NPMW_DIR%build\node\lib\node_modules\npm\bin\npm-cli.js^"
+  set INSTALL_NPM_COMMAND=^"%NPMW_DIR%gradlew.bat^" npmSetup
+)
+
+if not exist %NPM_EXE% (
+  call %INSTALL_NPM_COMMAND% 
+)
+
+if exist %NODE_EXE% (
+  Rem execute local npm with local node, whilst adding local node location to the PATH for this CMD session
+  endlocal & echo "%PATH%"|find /i "%NODE_PATH%;">nul || set "PATH=%NODE_PATH%;%PATH%" & call %NODE_EXE% %NPM_EXE% %*
+) else if exist %NPM_EXE% (
+  Rem execute local npm, whilst adding local npm location to the PATH for this CMD session
+  endlocal & echo "%PATH%"|find /i "%NODE_PATH%;">nul || set "PATH=%NODE_PATH%;%PATH%" & call %NPM_EXE% %*
+) else (
+  call npm %*
+)
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@ -0,0 +1,150 @@
+{
+  "name": "informationsystemmonitor",
+  "version": "0.0.1-SNAPSHOT",
+  "private": true,
+  "description": "Description for informationsystemmonitor",
+  "license": "UNLICENSED",
+  "scripts": {
+    "app:start": "./mvnw",
+    "backend:build-cache": "./mvnw dependency:go-offline",
+    "backend:debug": "./mvnw -Dspring-boot.run.jvmArguments=\"-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:8000\"",
+    "backend:doc:test": "./mvnw -ntp javadoc:javadoc --batch-mode",
+    "backend:info": "./mvnw -ntp enforcer:display-info --batch-mode",
+    "backend:nohttp:test": "./mvnw -ntp checkstyle:check --batch-mode",
+    "backend:start": "./mvnw -Dskip.installnodenpm -Dskip.npm",
+    "backend:unit:test": "./mvnw -ntp -Dskip.installnodenpm -Dskip.npm verify --batch-mode -Dlogging.level.ROOT=OFF -Dlogging.level.org.zalando=OFF -Dlogging.level.tech.jhipster=OFF -Dlogging.level.org.gcube.fullstackapps.informationsystemmonitor=OFF -Dlogging.level.org.springframework=OFF -Dlogging.level.org.springframework.web=OFF -Dlogging.level.org.springframework.security=OFF",
+    "build": "npm run webapp:prod --",
+    "build-watch": "concurrently 'npm run webapp:build:dev -- --watch' npm:backend:start",
+    "ci:backend:test": "npm run backend:info && npm run backend:doc:test && npm run backend:nohttp:test && npm run backend:unit:test -- -P$npm_package_config_default_environment",
+    "ci:e2e:package": "npm run java:$npm_package_config_packaging:$npm_package_config_default_environment -- -Pe2e -Denforcer.skip=true",
+    "ci:e2e:prepare": "npm run ci:e2e:prepare:docker",
+    "ci:e2e:prepare:docker": "npm run docker:db:up && npm run docker:others:up && docker ps -a",
+    "preci:e2e:server:start": "npm run docker:db:await --if-present && npm run docker:others:await --if-present",
+    "ci:e2e:server:start": "java -jar target/e2e.$npm_package_config_packaging --spring.profiles.active=e2e,$npm_package_config_default_environment -Dlogging.level.ROOT=OFF -Dlogging.level.org.zalando=OFF -Dlogging.level.tech.jhipster=OFF -Dlogging.level.org.gcube.fullstackapps.informationsystemmonitor=OFF -Dlogging.level.org.springframework=OFF -Dlogging.level.org.springframework.web=OFF -Dlogging.level.org.springframework.security=OFF --logging.level.org.springframework.web=ERROR",
+    "ci:e2e:teardown": "npm run ci:e2e:teardown:docker",
+    "ci:e2e:teardown:docker": "npm run docker:db:down --if-present && npm run docker:others:down && docker ps -a",
+    "ci:frontend:build": "npm run webapp:build:$npm_package_config_default_environment",
+    "ci:frontend:test": "npm run ci:frontend:build && npm test",
+    "clean-www": "rimraf target/classes/static/app/{src,target/}",
+    "cleanup": "rimraf target/classes/static/",
+    "docker:app:up": "docker-compose -f src/main/docker/app.yml up -d",
+    "docker:db:up": "echo \"Docker for db no not configured for application informationsystemmonitor\"",
+    "docker:keycloak:await": "echo \"Waiting for keycloak to start\" && wait-on -t 180000 http-get://localhost:9080/realms/jhipster && echo \"keycloak started\" || echo \"keycloak not running, make sure oauth2 server is running\"",
+    "docker:keycloak:down": "docker-compose -f src/main/docker/keycloak.yml down -v",
+    "docker:keycloak:up": "docker-compose -f src/main/docker/keycloak.yml up -d",
+    "docker:others:await": "npm run docker:keycloak:await",
+    "docker:others:down": "npm run docker:keycloak:down",
+    "predocker:others:up": "",
+    "docker:others:up": "npm run docker:keycloak:up",
+    "java:docker": "./mvnw -ntp verify -DskipTests -Pprod jib:dockerBuild",
+    "java:docker:arm64": "npm run java:docker -- -Djib-maven-plugin.architecture=arm64",
+    "java:docker:dev": "npm run java:docker -- -Pdev,webapp",
+    "java:docker:prod": "npm run java:docker -- -Pprod",
+    "java:jar": "./mvnw -ntp verify -DskipTests --batch-mode",
+    "java:jar:dev": "npm run java:jar -- -Pdev,webapp",
+    "java:jar:prod": "npm run java:jar -- -Pprod",
+    "java:war": "./mvnw -ntp verify -DskipTests --batch-mode -Pwar",
+    "java:war:dev": "npm run java:war -- -Pdev,webapp",
+    "java:war:prod": "npm run java:war -- -Pprod",
+    "jest": "jest --coverage --logHeapUsage --maxWorkers=2 --config jest.conf.js",
+    "lint": "eslint . --ext .js,.ts",
+    "lint:fix": "npm run lint -- --fix",
+    "prettier:check": "prettier --check \"{,src/**/,webpack/,.blueprint/**/}*.{md,json,yml,html,cjs,mjs,js,ts,tsx,css,scss,java}\"",
+    "prettier:format": "prettier --write \"{,src/**/,webpack/,.blueprint/**/}*.{md,json,yml,html,cjs,mjs,js,ts,tsx,css,scss,java}\"",
+    "serve": "npm run start --",
+    "start": "ng serve --hmr",
+    "start-tls": "npm run webapp:dev-ssl",
+    "pretest": "npm run lint",
+    "test": "ng test --coverage --log-heap-usage -w=2",
+    "test:watch": "npm run test -- --watch",
+    "watch": "concurrently npm:start npm:backend:start",
+    "webapp:build": "npm run clean-www && npm run webapp:build:dev",
+    "webapp:build:dev": "ng build --configuration development",
+    "webapp:build:prod": "ng build --configuration production",
+    "webapp:dev": "ng serve",
+    "webapp:dev-ssl": "ng serve --ssl",
+    "webapp:dev-verbose": "ng serve --verbose",
+    "webapp:prod": "npm run clean-www && npm run webapp:build:prod",
+    "webapp:test": "npm run test --"
+  },
+  "config": {
+    "backend_port": "8080",
+    "default_environment": "prod",
+    "packaging": "jar"
+  },
+  "dependencies": {
+    "@angular/common": "14.2.0",
+    "@angular/compiler": "14.2.0",
+    "@angular/core": "14.2.0",
+    "@angular/forms": "14.2.0",
+    "@angular/localize": "14.2.0",
+    "@angular/platform-browser": "14.2.0",
+    "@angular/platform-browser-dynamic": "14.2.0",
+    "@angular/router": "14.2.0",
+    "@fortawesome/angular-fontawesome": "0.11.1",
+    "@fortawesome/fontawesome-svg-core": "6.2.0",
+    "@fortawesome/free-solid-svg-icons": "6.2.0",
+    "@ng-bootstrap/ng-bootstrap": "13.0.0",
+    "@ngx-translate/core": "14.0.0",
+    "@ngx-translate/http-loader": "7.0.0",
+    "@popperjs/core": "2.11.6",
+    "bootstrap": "5.2.0",
+    "cytoscape": "3.25.0",
+    "dayjs": "1.11.5",
+    "ngx-infinite-scroll": "14.0.0",
+    "ngx-webstorage": "10.0.1",
+    "rxjs": "7.5.6",
+    "tslib": "2.4.0",
+    "zone.js": "0.11.6"
+  },
+  "devDependencies": {
+    "@angular-builders/custom-webpack": "14.0.1",
+    "@angular-builders/jest": "14.0.1",
+    "@angular-devkit/build-angular": "14.2.1",
+    "@angular-eslint/eslint-plugin": "14.0.3",
+    "@angular/cli": "14.2.1",
+    "@angular/compiler-cli": "14.2.0",
+    "@angular/service-worker": "14.2.0",
+    "@types/cytoscape": "3.19.10",
+    "@types/jest": "28.1.8",
+    "@types/node": "16.11.56",
+    "@typescript-eslint/eslint-plugin": "5.36.1",
+    "@typescript-eslint/parser": "5.36.1",
+    "browser-sync": "2.27.10",
+    "browser-sync-webpack-plugin": "2.3.0",
+    "concurrently": "7.3.0",
+    "copy-webpack-plugin": "11.0.0",
+    "eslint": "8.23.0",
+    "eslint-config-prettier": "8.5.0",
+    "eslint-webpack-plugin": "3.2.0",
+    "folder-hash": "4.0.2",
+    "generator-jhipster": "7.9.3",
+    "jest": "28.1.3",
+    "jest-date-mock": "1.0.8",
+    "jest-environment-jsdom": "28.1.3",
+    "jest-junit": "14.0.1",
+    "jest-preset-angular": "12.2.2",
+    "jest-sonar": "0.2.12",
+    "merge-jsons-webpack-plugin": "2.0.1",
+    "prettier": "2.7.1",
+    "prettier-plugin-java": "1.6.2",
+    "prettier-plugin-packagejson": "2.2.18",
+    "rimraf": "3.0.2",
+    "swagger-ui-dist": "4.14.0",
+    "ts-jest": "28.0.8",
+    "typescript": "4.8.2",
+    "wait-on": "6.0.1",
+    "webpack-bundle-analyzer": "4.6.1",
+    "webpack-merge": "5.8.0",
+    "webpack-notifier": "1.15.0"
+  },
+  "engines": {
+    "node": ">=16.17.0"
+  },
+  "cacheDirectories": [
+    "node_modules"
+  ],
+  "overrides": {
+    "webpack": "5.74.0"
+  }
+}
--- a/pom.xml
+++ b/pom.xml
--- a/sonar-project.properties
+++ b/sonar-project.properties
@ -0,0 +1,31 @@
+sonar.projectKey=informationsystemmonitor
+sonar.projectName=informationsystemmonitor generated by jhipster
+
+# Typescript tests files must be inside sources and tests, othewise `INFO: Test execution data ignored for 80 unknown files, including:` is shown.
+sonar.sources=src
+sonar.tests=src
+sonar.host.url=http://localhost:9001
+
+sonar.test.inclusions=src/test/**/*.*, src/main/webapp/app/**/*.spec.ts
+sonar.coverage.jacoco.xmlReportPaths=target/site/**/jacoco*.xml
+sonar.java.codeCoveragePlugin=jacoco
+sonar.junit.reportPaths=target/surefire-reports,target/failsafe-reports
+sonar.testExecutionReportPaths=target/test-results/jest/TESTS-results-sonar.xml
+sonar.javascript.lcov.reportPaths=target/test-results/lcov.info
+
+sonar.sourceEncoding=UTF-8
+sonar.exclusions=src/main/webapp/content/**/*.*, src/main/webapp/i18n/*.js, target/classes/static/**/*.*
+
+sonar.issue.ignore.multicriteria=S3437,S4684,S5145,UndocumentedApi
+# Rule https://rules.sonarsource.com/java/RSPEC-3437 is ignored, as a JPA-managed field cannot be transient
+sonar.issue.ignore.multicriteria.S3437.resourceKey=src/main/java/**/*
+sonar.issue.ignore.multicriteria.S3437.ruleKey=squid:S3437
+# Rule https://rules.sonarsource.com/java/RSPEC-4684
+sonar.issue.ignore.multicriteria.S4684.resourceKey=src/main/java/**/*
+sonar.issue.ignore.multicriteria.S4684.ruleKey=java:S4684
+# Rule https://rules.sonarsource.com/java/RSPEC-5145 log filter is applied
+sonar.issue.ignore.multicriteria.S5145.resourceKey=src/main/java/**/*
+sonar.issue.ignore.multicriteria.S5145.ruleKey=javasecurity:S5145
+# Rule https://rules.sonarsource.com/java/RSPEC-1176 is ignored, as we want to follow "clean code" guidelines and classes, methods and arguments names should be self-explanatory
+sonar.issue.ignore.multicriteria.UndocumentedApi.resourceKey=src/main/java/**/*
+sonar.issue.ignore.multicriteria.UndocumentedApi.ruleKey=squid:UndocumentedApi
--- a/src/main/docker/app.yml
+++ b/src/main/docker/app.yml
@ -0,0 +1,34 @@
+# This configuration is intended for development purpose, it's **your** responsibility to harden it for production
+version: '3.8'
+services:
+  informationsystemmonitor-app:
+    image: informationsystemmonitor
+    environment:
+      - _JAVA_OPTIONS=-Xmx512m -Xms256m
+      - SPRING_PROFILES_ACTIVE=prod,api-docs
+      - MANAGEMENT_METRICS_EXPORT_PROMETHEUS_ENABLED=true
+      - SPRING_SECURITY_OAUTH2_CLIENT_PROVIDER_OIDC_ISSUER_URI=http://keycloak:9080/realms/jhipster
+      - SPRING_SECURITY_OAUTH2_CLIENT_REGISTRATION_OIDC_CLIENT_ID=web_app
+      - SPRING_SECURITY_OAUTH2_CLIENT_REGISTRATION_OIDC_CLIENT_SECRET=web_app
+      - JHIPSTER_SLEEP=30 # gives time for other services to boot before the application
+    # If you want to expose these ports outside your dev PC,
+    # remove the "127.0.0.1:" prefix
+    ports:
+      - 127.0.0.1:8080:8080
+  keycloak:
+    image: quay.io/keycloak/keycloak:19.0.1
+    command: ['start-dev --import-realm']
+    volumes:
+      - ./realm-config:/opt/keycloak/data/import
+    environment:
+      - KC_DB=dev-file
+      - KEYCLOAK_ADMIN=admin
+      - KEYCLOAK_ADMIN_PASSWORD=admin
+      - KC_FEATURES=scripts
+      - KC_HTTP_PORT=9080
+      - KC_HTTPS_PORT=9443
+    # If you want to expose these ports outside your dev PC,
+    # remove the "127.0.0.1:" prefix
+    ports:
+      - 127.0.0.1:9080:9080
+      - 127.0.0.1:9443:9443
--- a/src/main/docker/central-server-config/README.md
+++ b/src/main/docker/central-server-config/README.md
@ -0,0 +1 @@
+# Central configuration sources details
--- a/src/main/docker/grafana/provisioning/dashboards/JVM.json
+++ b/src/main/docker/grafana/provisioning/dashboards/JVM.json
--- a/src/main/docker/grafana/provisioning/dashboards/dashboard.yml
+++ b/src/main/docker/grafana/provisioning/dashboards/dashboard.yml
@ -0,0 +1,11 @@
+apiVersion: 1
+
+providers:
+  - name: 'Prometheus'
+    orgId: 1
+    folder: ''
+    type: file
+    disableDeletion: false
+    editable: true
+    options:
+      path: /etc/grafana/provisioning/dashboards
--- a/src/main/docker/grafana/provisioning/datasources/datasource.yml
+++ b/src/main/docker/grafana/provisioning/datasources/datasource.yml
@ -0,0 +1,50 @@
+apiVersion: 1
+
+# list of datasources that should be deleted from the database
+deleteDatasources:
+  - name: Prometheus
+    orgId: 1
+
+# list of datasources to insert/update depending
+# whats available in the database
+datasources:
+  # <string, required> name of the datasource. Required
+  - name: Prometheus
+    # <string, required> datasource type. Required
+    type: prometheus
+    # <string, required> access mode. direct or proxy. Required
+    access: proxy
+    # <int> org id. will default to orgId 1 if not specified
+    orgId: 1
+    # <string> url
+    # On MacOS, replace localhost by host.docker.internal
+    url: http://localhost:9090
+    # <string> database password, if used
+    password:
+    # <string> database user, if used
+    user:
+    # <string> database name, if used
+    database:
+    # <bool> enable/disable basic auth
+    basicAuth: false
+    # <string> basic auth username
+    basicAuthUser: admin
+    # <string> basic auth password
+    basicAuthPassword: admin
+    # <bool> enable/disable with credentials headers
+    withCredentials:
+    # <bool> mark as default datasource. Max one per org
+    isDefault: true
+    # <map> fields that will be converted to json and stored in json_data
+    jsonData:
+      graphiteVersion: '1.1'
+      tlsAuth: false
+      tlsAuthWithCACert: false
+    # <string> json object of data that will be encrypted.
+    secureJsonData:
+      tlsCACert: '...'
+      tlsClientCert: '...'
+      tlsClientKey: '...'
+    version: 1
+    # <bool> allow users to edit datasources from the UI.
+    editable: true
--- a/src/main/docker/jhipster-control-center.yml
+++ b/src/main/docker/jhipster-control-center.yml
@ -0,0 +1,53 @@
+## How to use JHCC docker compose
+# To allow JHCC to reach JHipster application from a docker container note that we set the host as host.docker.internal
+# To reach the application from a browser, you need to add '127.0.0.1 host.docker.internal' to your hosts file.
+### Discovery mode
+# JHCC support 3 kinds of discovery mode: Consul, Eureka and static
+# In order to use one, please set SPRING_PROFILES_ACTIVE to one (and only one) of this values: consul,eureka,static
+### Discovery properties
+# According to the discovery mode choose as Spring profile, you have to set the right properties
+# please note that current properties are set to run JHCC with default values, personalize them if needed
+# and remove those from other modes. You can only have one mode active.
+#### Eureka
+#       - EUREKA_CLIENT_SERVICE_URL_DEFAULTZONE=http://admin:admin@host.docker.internal:8761/eureka/
+#### Consul
+#       - SPRING_CLOUD_CONSUL_HOST=host.docker.internal
+#       - SPRING_CLOUD_CONSUL_PORT=8500
+#### Static
+# Add instances to "MyApp"
+#       - SPRING_CLOUD_DISCOVERY_CLIENT_SIMPLE_INSTANCES_MYAPP_0_URI=http://host.docker.internal:8081
+#       - SPRING_CLOUD_DISCOVERY_CLIENT_SIMPLE_INSTANCES_MYAPP_1_URI=http://host.docker.internal:8082
+# Or add a new application named MyNewApp
+#       - SPRING_CLOUD_DISCOVERY_CLIENT_SIMPLE_INSTANCES_MYNEWAPP_0_URI=http://host.docker.internal:8080
+# This configuration is intended for development purpose, it's **your** responsibility to harden it for production
+
+#### IMPORTANT
+# If you choose Consul or Eureka mode:
+# Do not forget to remove the prefix "127.0.0.1" in front of their port in order to expose them.
+# This is required because JHCC need to communicate with Consul or Eureka.
+# - In Consul mode, the ports are in the consul.yml file.
+# - In Eureka mode, the ports are in the jhipster-registry.yml file.
+
+version: '3.8'
+services:
+  jhipster-control-center:
+    image: 'jhipster/jhipster-control-center:v0.5.0'
+    command:
+      - /bin/sh
+      - -c
+      # Patch /etc/hosts to support resolving host.docker.internal to the internal IP address used by the host in all OSes
+      - echo "`ip route | grep default | cut -d ' ' -f3` host.docker.internal" | tee -a /etc/hosts > /dev/null && java -jar /jhipster-control-center.jar
+    environment:
+      - _JAVA_OPTIONS=-Xmx512m -Xms256m
+      - SPRING_PROFILES_ACTIVE=prod,api-docs,static,oauth2
+      - JHIPSTER_SLEEP=30 # gives time for other services to boot before the application
+      # For keycloak to work, you need to add '127.0.0.1 keycloak' to your hosts file
+      - SPRING_SECURITY_OAUTH2_CLIENT_PROVIDER_OIDC_ISSUER_URI=http://keycloak:9080/realms/jhipster
+      - SPRING_SECURITY_OAUTH2_CLIENT_REGISTRATION_OIDC_CLIENT_ID=jhipster-control-center
+      - SPRING_SECURITY_OAUTH2_CLIENT_REGISTRATION_OIDC_CLIENT_SECRET=jhipster-control-center
+      - SPRING_CLOUD_DISCOVERY_CLIENT_SIMPLE_INSTANCES_INFORMATIONSYSTEMMONITOR_0_URI=http://host.docker.internal:8080
+      - LOGGING_FILE_NAME=/tmp/jhipster-control-center.log
+    # If you want to expose these ports outside your dev PC,
+    # remove the "127.0.0.1:" prefix
+    ports:
+      - 127.0.0.1:7419:7419
--- a/src/main/docker/jib/entrypoint.sh
+++ b/src/main/docker/jib/entrypoint.sh
@ -0,0 +1,39 @@
+#!/bin/bash
+
+echo "The application will start in ${JHIPSTER_SLEEP}s..." && sleep ${JHIPSTER_SLEEP}
+
+# usage: file_env VAR [DEFAULT]
+#    ie: file_env 'XYZ_DB_PASSWORD' 'example'
+# (will allow for "$XYZ_DB_PASSWORD_FILE" to fill in the value of
+#  "$XYZ_DB_PASSWORD" from a file, especially for Docker's secrets feature)
+file_env() {
+    local var="$1"
+    local fileVar="${var}_FILE"
+    local def="${2:-}"
+    if [[ ${!var:-} && ${!fileVar:-} ]]; then
+        echo >&2 "error: both $var and $fileVar are set (but are exclusive)"
+        exit 1
+    fi
+    local val="$def"
+    if [[ ${!var:-} ]]; then
+        val="${!var}"
+    elif [[ ${!fileVar:-} ]]; then
+        val="$(< "${!fileVar}")"
+    fi
+
+    if [[ -n $val ]]; then
+        export "$var"="$val"
+    fi
+
+    unset "$fileVar"
+}
+
+file_env 'SPRING_DATASOURCE_URL'
+file_env 'SPRING_DATASOURCE_USERNAME'
+file_env 'SPRING_DATASOURCE_PASSWORD'
+file_env 'SPRING_LIQUIBASE_URL'
+file_env 'SPRING_LIQUIBASE_USER'
+file_env 'SPRING_LIQUIBASE_PASSWORD'
+file_env 'JHIPSTER_REGISTRY_PASSWORD'
+
+exec java ${JAVA_OPTS} -noverify -XX:+AlwaysPreTouch -Djava.security.egd=file:/dev/./urandom -cp /app/resources/:/app/classes/:/app/libs/* "org.gcube.fullstackapps.informationsystemmonitor.InformationsystemmonitorApp"  "$@"
--- a/src/main/docker/keycloak.yml
+++ b/src/main/docker/keycloak.yml
@ -0,0 +1,20 @@
+# This configuration is intended for development purpose, it's **your** responsibility to harden it for production
+version: '3.8'
+services:
+  keycloak:
+    image: quay.io/keycloak/keycloak:19.0.1
+    command: ['start-dev --import-realm']
+    volumes:
+      - ./realm-config:/opt/keycloak/data/import
+    environment:
+      - KC_DB=dev-file
+      - KEYCLOAK_ADMIN=admin
+      - KEYCLOAK_ADMIN_PASSWORD=admin
+      - KC_FEATURES=scripts
+      - KC_HTTP_PORT=9080
+      - KC_HTTPS_PORT=9443
+    # If you want to expose these ports outside your dev PC,
+    # remove the "127.0.0.1:" prefix
+    ports:
+      - 127.0.0.1:9080:9080
+      - 127.0.0.1:9443:9443
--- a/src/main/docker/monitoring.yml
+++ b/src/main/docker/monitoring.yml
@ -0,0 +1,31 @@
+# This configuration is intended for development purpose, it's **your** responsibility to harden it for production
+version: '3.8'
+services:
+  informationsystemmonitor-prometheus:
+    image: prom/prometheus:v2.38.0
+    volumes:
+      - ./prometheus/:/etc/prometheus/
+    command:
+      - '--config.file=/etc/prometheus/prometheus.yml'
+    # If you want to expose these ports outside your dev PC,
+    # remove the "127.0.0.1:" prefix
+    ports:
+      - 127.0.0.1:9090:9090
+    # On MacOS, remove next line and replace localhost by host.docker.internal in prometheus/prometheus.yml and
+    # grafana/provisioning/datasources/datasource.yml
+    network_mode: 'host' # to test locally running service
+  informationsystemmonitor-grafana:
+    image: grafana/grafana:9.1.0
+    volumes:
+      - ./grafana/provisioning/:/etc/grafana/provisioning/
+    environment:
+      - GF_SECURITY_ADMIN_PASSWORD=admin
+      - GF_USERS_ALLOW_SIGN_UP=false
+      - GF_INSTALL_PLUGINS=grafana-piechart-panel
+    # If you want to expose these ports outside your dev PC,
+    # remove the "127.0.0.1:" prefix
+    ports:
+      - 127.0.0.1:3000:3000
+    # On MacOS, remove next line and replace localhost by host.docker.internal in prometheus/prometheus.yml and
+    # grafana/provisioning/datasources/datasource.yml
+    network_mode: 'host' # to test locally running service
--- a/src/main/docker/prometheus/prometheus.yml
+++ b/src/main/docker/prometheus/prometheus.yml
@ -0,0 +1,31 @@
+# Sample global config for monitoring JHipster applications
+global:
+  scrape_interval: 15s # By default, scrape targets every 15 seconds.
+  evaluation_interval: 15s # By default, scrape targets every 15 seconds.
+  # scrape_timeout is set to the global default (10s).
+
+  # Attach these labels to any time series or alerts when communicating with
+  # external systems (federation, remote storage, Alertmanager).
+  external_labels:
+    monitor: 'jhipster'
+
+# A scrape configuration containing exactly one endpoint to scrape:
+# Here it's Prometheus itself.
+scrape_configs:
+  # The job name is added as a label `job=<job_name>` to any timeseries scraped from this config.
+  - job_name: 'prometheus'
+
+    # Override the global default and scrape targets from this job every 5 seconds.
+    scrape_interval: 5s
+
+    # scheme defaults to 'http' enable https in case your application is server via https
+    #scheme: https
+    # basic auth is not needed by default. See https://www.jhipster.tech/monitoring/#configuring-metrics-forwarding for details
+    #basic_auth:
+    # username: admin
+    # password: admin
+    metrics_path: /management/prometheus
+    static_configs:
+      - targets:
+          # On MacOS, replace localhost by host.docker.internal
+          - localhost:8080
--- a/src/main/docker/realm-config/jhipster-realm.json
+++ b/src/main/docker/realm-config/jhipster-realm.json
--- a/src/main/docker/sonar.yml
+++ b/src/main/docker/sonar.yml
@ -0,0 +1,13 @@
+# This configuration is intended for development purpose, it's **your** responsibility to harden it for production
+version: '3.8'
+services:
+  informationsystemmonitor-sonar:
+    image: sonarqube:9.6.0-community
+    # Authentication is turned off for out of the box experience while trying out SonarQube
+    # For real use cases delete sonar.forceAuthentication variable or set sonar.forceAuthentication=true
+    environment:
+      - sonar.forceAuthentication=false
+    # If you want to expose these ports outside your dev PC,
+    # remove the "127.0.0.1:" prefix
+    ports:
+      - 127.0.0.1:9001:9000
--- a/src/main/docker/swagger-editor.yml
+++ b/src/main/docker/swagger-editor.yml
@ -0,0 +1,7 @@
+# This configuration is intended for development purpose, it's **your** responsibility to harden it for production
+version: '3.8'
+services:
+  swagger-editor:
+    image: swaggerapi/swagger-editor:latest
+    ports:
+      - 127.0.0.1:7742:8080
--- a/src/main/docker/zipkin.yml
+++ b/src/main/docker/zipkin.yml
@ -0,0 +1,7 @@
+# This configuration is intended for development purpose, it's **your** responsibility to harden it for production
+version: '3.8'
+services:
+  zipkin:
+    image: openzipkin/zipkin:2.23
+    ports:
+      - 127.0.0.1:9411:9411
--- a/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/ApplicationWebXml.java
+++ b/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/ApplicationWebXml.java
@ -0,0 +1,19 @@
+package org.gcube.fullstackapps.informationsystemmonitor;
+
+import org.springframework.boot.builder.SpringApplicationBuilder;
+import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
+import tech.jhipster.config.DefaultProfileUtil;
+
+/**
+ * This is a helper Java class that provides an alternative to creating a {@code web.xml}.
+ * This will be invoked only when the application is deployed to a Servlet container like Tomcat, JBoss etc.
+ */
+public class ApplicationWebXml extends SpringBootServletInitializer {
+
+    @Override
+    protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
+        // set a default to use when no profile is configured.
+        DefaultProfileUtil.addDefaultProfile(application.application());
+        return application.sources(InformationsystemmonitorApp.class);
+    }
+}
--- a/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/GeneratedByJHipster.java
+++ b/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/GeneratedByJHipster.java
@ -0,0 +1,13 @@
+package org.gcube.fullstackapps.informationsystemmonitor;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import javax.annotation.Generated;
+
+@Generated(value = "JHipster", comments = "Generated by JHipster 7.9.3")
+@Retention(RetentionPolicy.SOURCE)
+@Target({ ElementType.TYPE })
+public @interface GeneratedByJHipster {
+}
--- a/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/InformationsystemmonitorApp.java
+++ b/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/InformationsystemmonitorApp.java
@ -0,0 +1,104 @@
+package org.gcube.fullstackapps.informationsystemmonitor;
+
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Optional;
+import javax.annotation.PostConstruct;
+import org.apache.commons.lang3.StringUtils;
+import org.gcube.fullstackapps.informationsystemmonitor.config.ApplicationProperties;
+import org.gcube.fullstackapps.informationsystemmonitor.config.CRLFLogConverter;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.context.properties.EnableConfigurationProperties;
+import org.springframework.core.env.Environment;
+import tech.jhipster.config.DefaultProfileUtil;
+import tech.jhipster.config.JHipsterConstants;
+
+@SpringBootApplication
+@EnableConfigurationProperties({ ApplicationProperties.class })
+public class InformationsystemmonitorApp {
+
+    private static final Logger log = LoggerFactory.getLogger(InformationsystemmonitorApp.class);
+
+    private final Environment env;
+
+    public InformationsystemmonitorApp(Environment env) {
+        this.env = env;
+    }
+
+    /**
+     * Initializes informationsystemmonitor.
+     * <p>
+     * Spring profiles can be configured with a program argument --spring.profiles.active=your-active-profile
+     * <p>
+     * You can find more information on how profiles work with JHipster on <a href="https://www.jhipster.tech/profiles/">https://www.jhipster.tech/profiles/</a>.
+     */
+    @PostConstruct
+    public void initApplication() {
+        Collection<String> activeProfiles = Arrays.asList(env.getActiveProfiles());
+        if (
+            activeProfiles.contains(JHipsterConstants.SPRING_PROFILE_DEVELOPMENT) &&
+            activeProfiles.contains(JHipsterConstants.SPRING_PROFILE_PRODUCTION)
+        ) {
+            log.error(
+                "You have misconfigured your application! It should not run " + "with both the 'dev' and 'prod' profiles at the same time."
+            );
+        }
+        if (
+            activeProfiles.contains(JHipsterConstants.SPRING_PROFILE_DEVELOPMENT) &&
+            activeProfiles.contains(JHipsterConstants.SPRING_PROFILE_CLOUD)
+        ) {
+            log.error(
+                "You have misconfigured your application! It should not " + "run with both the 'dev' and 'cloud' profiles at the same time."
+            );
+        }
+    }
+
+    /**
+     * Main method, used to run the application.
+     *
+     * @param args the command line arguments.
+     */
+    public static void main(String[] args) {
+        SpringApplication app = new SpringApplication(InformationsystemmonitorApp.class);
+        DefaultProfileUtil.addDefaultProfile(app);
+        Environment env = app.run(args).getEnvironment();
+        logApplicationStartup(env);
+    }
+
+    private static void logApplicationStartup(Environment env) {
+        String protocol = Optional.ofNullable(env.getProperty("server.ssl.key-store")).map(key -> "https").orElse("http");
+        String serverPort = env.getProperty("server.port");
+        String contextPath = Optional
+            .ofNullable(env.getProperty("server.servlet.context-path"))
+            .filter(StringUtils::isNotBlank)
+            .orElse("/");
+        String hostAddress = "localhost";
+        try {
+            hostAddress = InetAddress.getLocalHost().getHostAddress();
+        } catch (UnknownHostException e) {
+            log.warn("The host name could not be determined, using `localhost` as fallback");
+        }
+        log.info(
+            CRLFLogConverter.CRLF_SAFE_MARKER,
+            "\n----------------------------------------------------------\n\t" +
+            "Application '{}' is running! Access URLs:\n\t" +
+            "Local: \t\t{}://localhost:{}{}\n\t" +
+            "External: \t{}://{}:{}{}\n\t" +
+            "Profile(s): \t{}\n----------------------------------------------------------",
+            env.getProperty("spring.application.name"),
+            protocol,
+            serverPort,
+            contextPath,
+            protocol,
+            hostAddress,
+            serverPort,
+            contextPath,
+            env.getActiveProfiles().length == 0 ? env.getDefaultProfiles() : env.getActiveProfiles()
+        );
+    }
+}
--- a/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/aop/logging/LoggingAspect.java
+++ b/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/aop/logging/LoggingAspect.java
@ -0,0 +1,115 @@
+package org.gcube.fullstackapps.informationsystemmonitor.aop.logging;
+
+import java.util.Arrays;
+import org.aspectj.lang.JoinPoint;
+import org.aspectj.lang.ProceedingJoinPoint;
+import org.aspectj.lang.annotation.AfterThrowing;
+import org.aspectj.lang.annotation.Around;
+import org.aspectj.lang.annotation.Aspect;
+import org.aspectj.lang.annotation.Pointcut;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.core.env.Environment;
+import org.springframework.core.env.Profiles;
+import tech.jhipster.config.JHipsterConstants;
+
+/**
+ * Aspect for logging execution of service and repository Spring components.
+ *
+ * By default, it only runs with the "dev" profile.
+ */
+@Aspect
+public class LoggingAspect {
+
+    private final Environment env;
+
+    public LoggingAspect(Environment env) {
+        this.env = env;
+    }
+
+    /**
+     * Pointcut that matches all repositories, services and Web REST endpoints.
+     */
+    @Pointcut(
+        "within(@org.springframework.stereotype.Repository *)" +
+        " || within(@org.springframework.stereotype.Service *)" +
+        " || within(@org.springframework.web.bind.annotation.RestController *)"
+    )
+    public void springBeanPointcut() {
+        // Method is empty as this is just a Pointcut, the implementations are in the advices.
+    }
+
+    /**
+     * Pointcut that matches all Spring beans in the application's main packages.
+     */
+    @Pointcut(
+        "within(org.gcube.fullstackapps.informationsystemmonitor.repository..*)" +
+        " || within(org.gcube.fullstackapps.informationsystemmonitor.service..*)" +
+        " || within(org.gcube.fullstackapps.informationsystemmonitor.web.rest..*)"
+    )
+    public void applicationPackagePointcut() {
+        // Method is empty as this is just a Pointcut, the implementations are in the advices.
+    }
+
+    /**
+     * Retrieves the {@link Logger} associated to the given {@link JoinPoint}.
+     *
+     * @param joinPoint join point we want the logger for.
+     * @return {@link Logger} associated to the given {@link JoinPoint}.
+     */
+    private Logger logger(JoinPoint joinPoint) {
+        return LoggerFactory.getLogger(joinPoint.getSignature().getDeclaringTypeName());
+    }
+
+    /**
+     * Advice that logs methods throwing exceptions.
+     *
+     * @param joinPoint join point for advice.
+     * @param e exception.
+     */
+    @AfterThrowing(pointcut = "applicationPackagePointcut() && springBeanPointcut()", throwing = "e")
+    public void logAfterThrowing(JoinPoint joinPoint, Throwable e) {
+        if (env.acceptsProfiles(Profiles.of(JHipsterConstants.SPRING_PROFILE_DEVELOPMENT))) {
+            logger(joinPoint)
+                .error(
+                    "Exception in {}() with cause = '{}' and exception = '{}'",
+                    joinPoint.getSignature().getName(),
+                    e.getCause() != null ? e.getCause() : "NULL",
+                    e.getMessage(),
+                    e
+                );
+        } else {
+            logger(joinPoint)
+                .error(
+                    "Exception in {}() with cause = {}",
+                    joinPoint.getSignature().getName(),
+                    e.getCause() != null ? e.getCause() : "NULL"
+                );
+        }
+    }
+
+    /**
+     * Advice that logs when a method is entered and exited.
+     *
+     * @param joinPoint join point for advice.
+     * @return result.
+     * @throws Throwable throws {@link IllegalArgumentException}.
+     */
+    @Around("applicationPackagePointcut() && springBeanPointcut()")
+    public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
+        Logger log = logger(joinPoint);
+        if (log.isDebugEnabled()) {
+            log.debug("Enter: {}() with argument[s] = {}", joinPoint.getSignature().getName(), Arrays.toString(joinPoint.getArgs()));
+        }
+        try {
+            Object result = joinPoint.proceed();
+            if (log.isDebugEnabled()) {
+                log.debug("Exit: {}() with result = {}", joinPoint.getSignature().getName(), result);
+            }
+            return result;
+        } catch (IllegalArgumentException e) {
+            log.error("Illegal argument: {} in {}()", Arrays.toString(joinPoint.getArgs()), joinPoint.getSignature().getName());
+            throw e;
+        }
+    }
+}
--- a/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/config/ApplicationProperties.java
+++ b/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/config/ApplicationProperties.java
@ -0,0 +1,16 @@
+package org.gcube.fullstackapps.informationsystemmonitor.config;
+
+import org.springframework.boot.context.properties.ConfigurationProperties;
+
+/**
+ * Properties specific to Informationsystemmonitor.
+ * <p>
+ * Properties are configured in the {@code application.yml} file.
+ * See {@link tech.jhipster.config.JHipsterProperties} for a good example.
+ */
+@ConfigurationProperties(prefix = "application", ignoreUnknownFields = false)
+public class ApplicationProperties {
+    // jhipster-needle-application-properties-property
+    // jhipster-needle-application-properties-property-getter
+    // jhipster-needle-application-properties-property-class
+}
--- a/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/config/AsyncConfiguration.java
+++ b/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/config/AsyncConfiguration.java
@ -0,0 +1,48 @@
+package org.gcube.fullstackapps.informationsystemmonitor.config;
+
+import java.util.concurrent.Executor;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;
+import org.springframework.aop.interceptor.SimpleAsyncUncaughtExceptionHandler;
+import org.springframework.boot.autoconfigure.task.TaskExecutionProperties;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Profile;
+import org.springframework.scheduling.annotation.AsyncConfigurer;
+import org.springframework.scheduling.annotation.EnableAsync;
+import org.springframework.scheduling.annotation.EnableScheduling;
+import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
+import tech.jhipster.async.ExceptionHandlingAsyncTaskExecutor;
+
+@Configuration
+@EnableAsync
+@EnableScheduling
+@Profile("!testdev & !testprod")
+public class AsyncConfiguration implements AsyncConfigurer {
+
+    private final Logger log = LoggerFactory.getLogger(AsyncConfiguration.class);
+
+    private final TaskExecutionProperties taskExecutionProperties;
+
+    public AsyncConfiguration(TaskExecutionProperties taskExecutionProperties) {
+        this.taskExecutionProperties = taskExecutionProperties;
+    }
+
+    @Override
+    @Bean(name = "taskExecutor")
+    public Executor getAsyncExecutor() {
+        log.debug("Creating Async Task Executor");
+        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
+        executor.setCorePoolSize(taskExecutionProperties.getPool().getCoreSize());
+        executor.setMaxPoolSize(taskExecutionProperties.getPool().getMaxSize());
+        executor.setQueueCapacity(taskExecutionProperties.getPool().getQueueCapacity());
+        executor.setThreadNamePrefix(taskExecutionProperties.getThreadNamePrefix());
+        return new ExceptionHandlingAsyncTaskExecutor(executor);
+    }
+
+    @Override
+    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
+        return new SimpleAsyncUncaughtExceptionHandler();
+    }
+}
--- a/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/config/CRLFLogConverter.java
+++ b/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/config/CRLFLogConverter.java
@ -0,0 +1,56 @@
+package org.gcube.fullstackapps.informationsystemmonitor.config;
+
+import ch.qos.logback.classic.spi.ILoggingEvent;
+import ch.qos.logback.core.pattern.CompositeConverter;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import org.slf4j.Marker;
+import org.slf4j.MarkerFactory;
+import org.springframework.boot.ansi.AnsiColor;
+import org.springframework.boot.ansi.AnsiElement;
+import org.springframework.boot.ansi.AnsiOutput;
+import org.springframework.boot.ansi.AnsiStyle;
+
+public class CRLFLogConverter extends CompositeConverter<ILoggingEvent> {
+
+    public static final Marker CRLF_SAFE_MARKER = MarkerFactory.getMarker("CRLF_SAFE");
+
+    private static final String[] SAFE_LOGGERS = { "org.hibernate" };
+    private static final Map<String, AnsiElement> ELEMENTS;
+
+    static {
+        Map<String, AnsiElement> ansiElements = new HashMap<>();
+        ansiElements.put("faint", AnsiStyle.FAINT);
+        ansiElements.put("red", AnsiColor.RED);
+        ansiElements.put("green", AnsiColor.GREEN);
+        ansiElements.put("yellow", AnsiColor.YELLOW);
+        ansiElements.put("blue", AnsiColor.BLUE);
+        ansiElements.put("magenta", AnsiColor.MAGENTA);
+        ansiElements.put("cyan", AnsiColor.CYAN);
+        ELEMENTS = Collections.unmodifiableMap(ansiElements);
+    }
+
+    @Override
+    protected String transform(ILoggingEvent event, String in) {
+        AnsiElement element = ELEMENTS.get(getFirstOption());
+        if ((event.getMarker() != null && event.getMarker().contains(CRLF_SAFE_MARKER)) || isLoggerSafe(event)) {
+            return in;
+        }
+        String replacement = element == null ? "_" : toAnsiString("_", element);
+        return in.replaceAll("[\n\r\t]", replacement);
+    }
+
+    protected boolean isLoggerSafe(ILoggingEvent event) {
+        for (String safeLogger : SAFE_LOGGERS) {
+            if (event.getLoggerName().startsWith(safeLogger)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    protected String toAnsiString(String in, AnsiElement element) {
+        return AnsiOutput.toString(element, in);
+    }
+}
--- a/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/config/Constants.java
+++ b/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/config/Constants.java
@ -0,0 +1,15 @@
+package org.gcube.fullstackapps.informationsystemmonitor.config;
+
+/**
+ * Application constants.
+ */
+public final class Constants {
+
+    // Regex for acceptable logins
+    public static final String LOGIN_REGEX = "^(?>[a-zA-Z0-9!$&*+=?^_`{|}~.-]+@[a-zA-Z0-9-]+(?:\\.[a-zA-Z0-9-]+)*)|(?>[_.@A-Za-z0-9-]+)$";
+
+    public static final String SYSTEM = "system";
+    public static final String DEFAULT_LANGUAGE = "en";
+
+    private Constants() {}
+}
--- a/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/config/DateTimeFormatConfiguration.java
+++ b/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/config/DateTimeFormatConfiguration.java
@ -0,0 +1,20 @@
+package org.gcube.fullstackapps.informationsystemmonitor.config;
+
+import org.springframework.context.annotation.Configuration;
+import org.springframework.format.FormatterRegistry;
+import org.springframework.format.datetime.standard.DateTimeFormatterRegistrar;
+import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
+
+/**
+ * Configure the converters to use the ISO format for dates by default.
+ */
+@Configuration
+public class DateTimeFormatConfiguration implements WebMvcConfigurer {
+
+    @Override
+    public void addFormatters(FormatterRegistry registry) {
+        DateTimeFormatterRegistrar registrar = new DateTimeFormatterRegistrar();
+        registrar.setUseIsoFormat(true);
+        registrar.registerFormatters(registry);
+    }
+}
--- a/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/config/JacksonConfiguration.java
+++ b/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/config/JacksonConfiguration.java
@ -0,0 +1,42 @@
+package org.gcube.fullstackapps.informationsystemmonitor.config;
+
+import com.fasterxml.jackson.datatype.jdk8.Jdk8Module;
+import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.zalando.problem.jackson.ProblemModule;
+import org.zalando.problem.violations.ConstraintViolationProblemModule;
+
+@Configuration
+public class JacksonConfiguration {
+
+    /**
+     * Support for Java date and time API.
+     * @return the corresponding Jackson module.
+     */
+    @Bean
+    public JavaTimeModule javaTimeModule() {
+        return new JavaTimeModule();
+    }
+
+    @Bean
+    public Jdk8Module jdk8TimeModule() {
+        return new Jdk8Module();
+    }
+
+    /*
+     * Module for serialization/deserialization of RFC7807 Problem.
+     */
+    @Bean
+    public ProblemModule problemModule() {
+        return new ProblemModule();
+    }
+
+    /*
+     * Module for serialization/deserialization of ConstraintViolationProblem.
+     */
+    @Bean
+    public ConstraintViolationProblemModule constraintViolationProblemModule() {
+        return new ConstraintViolationProblemModule();
+    }
+}
--- a/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/config/LocaleConfiguration.java
+++ b/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/config/LocaleConfiguration.java
@ -0,0 +1,26 @@
+package org.gcube.fullstackapps.informationsystemmonitor.config;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.servlet.LocaleResolver;
+import org.springframework.web.servlet.config.annotation.*;
+import org.springframework.web.servlet.i18n.LocaleChangeInterceptor;
+import tech.jhipster.config.locale.AngularCookieLocaleResolver;
+
+@Configuration
+public class LocaleConfiguration implements WebMvcConfigurer {
+
+    @Bean
+    public LocaleResolver localeResolver() {
+        AngularCookieLocaleResolver cookieLocaleResolver = new AngularCookieLocaleResolver();
+        cookieLocaleResolver.setCookieName("NG_TRANSLATE_LANG_KEY");
+        return cookieLocaleResolver;
+    }
+
+    @Override
+    public void addInterceptors(InterceptorRegistry registry) {
+        LocaleChangeInterceptor localeChangeInterceptor = new LocaleChangeInterceptor();
+        localeChangeInterceptor.setParamName("language");
+        registry.addInterceptor(localeChangeInterceptor);
+    }
+}
--- a/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/config/LoggingAspectConfiguration.java
+++ b/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/config/LoggingAspectConfiguration.java
@ -0,0 +1,17 @@
+package org.gcube.fullstackapps.informationsystemmonitor.config;
+
+import org.gcube.fullstackapps.informationsystemmonitor.aop.logging.LoggingAspect;
+import org.springframework.context.annotation.*;
+import org.springframework.core.env.Environment;
+import tech.jhipster.config.JHipsterConstants;
+
+@Configuration
+@EnableAspectJAutoProxy
+public class LoggingAspectConfiguration {
+
+    @Bean
+    @Profile(JHipsterConstants.SPRING_PROFILE_DEVELOPMENT)
+    public LoggingAspect loggingAspect(Environment env) {
+        return new LoggingAspect(env);
+    }
+}
--- a/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/config/LoggingConfiguration.java
+++ b/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/config/LoggingConfiguration.java
@ -0,0 +1,47 @@
+package org.gcube.fullstackapps.informationsystemmonitor.config;
+
+import static tech.jhipster.config.logging.LoggingUtils.*;
+
+import ch.qos.logback.classic.LoggerContext;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import java.util.HashMap;
+import java.util.Map;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Configuration;
+import tech.jhipster.config.JHipsterProperties;
+
+/*
+ * Configures the console and Logstash log appenders from the app properties
+ */
+@Configuration
+public class LoggingConfiguration {
+
+    public LoggingConfiguration(
+        @Value("${spring.application.name}") String appName,
+        @Value("${server.port}") String serverPort,
+        JHipsterProperties jHipsterProperties,
+        ObjectMapper mapper
+    ) throws JsonProcessingException {
+        LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory();
+
+        Map<String, String> map = new HashMap<>();
+        map.put("app_name", appName);
+        map.put("app_port", serverPort);
+        String customFields = mapper.writeValueAsString(map);
+
+        JHipsterProperties.Logging loggingProperties = jHipsterProperties.getLogging();
+        JHipsterProperties.Logging.Logstash logstashProperties = loggingProperties.getLogstash();
+
+        if (loggingProperties.isUseJsonFormat()) {
+            addJsonConsoleAppender(context, customFields);
+        }
+        if (logstashProperties.isEnabled()) {
+            addLogstashTcpSocketAppender(context, customFields, logstashProperties);
+        }
+        if (loggingProperties.isUseJsonFormat() || logstashProperties.isEnabled()) {
+            addContextListener(context, customFields, loggingProperties);
+        }
+    }
+}
--- a/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/config/OAuth2Configuration.java
+++ b/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/config/OAuth2Configuration.java
@ -0,0 +1,38 @@
+package org.gcube.fullstackapps.informationsystemmonitor.config;
+
+import java.time.Duration;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.security.oauth2.client.OAuth2AuthorizedClientManager;
+import org.springframework.security.oauth2.client.OAuth2AuthorizedClientProviderBuilder;
+import org.springframework.security.oauth2.client.registration.ClientRegistrationRepository;
+import org.springframework.security.oauth2.client.web.DefaultOAuth2AuthorizedClientManager;
+import org.springframework.security.oauth2.client.web.OAuth2AuthorizedClientRepository;
+
+@Configuration
+public class OAuth2Configuration {
+
+    @Bean
+    public OAuth2AuthorizedClientManager authorizedClientManager(
+        ClientRegistrationRepository clientRegistrationRepository,
+        OAuth2AuthorizedClientRepository authorizedClientRepository
+    ) {
+        DefaultOAuth2AuthorizedClientManager authorizedClientManager = new DefaultOAuth2AuthorizedClientManager(
+            clientRegistrationRepository,
+            authorizedClientRepository
+        );
+
+        authorizedClientManager.setAuthorizedClientProvider(
+            OAuth2AuthorizedClientProviderBuilder
+                .builder()
+                .authorizationCode()
+                .refreshToken(builder -> builder.clockSkew(Duration.ofMinutes(3)))
+                .clientCredentials()
+                .password()
+                .build()
+        );
+    
+
+        return authorizedClientManager;
+    }
+}
--- a/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/config/OpenApiConfiguration.java
+++ b/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/config/OpenApiConfiguration.java
@ -0,0 +1,33 @@
+package org.gcube.fullstackapps.informationsystemmonitor.config;
+
+import org.springdoc.core.GroupedOpenApi;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Profile;
+import tech.jhipster.config.JHipsterConstants;
+import tech.jhipster.config.JHipsterProperties;
+import tech.jhipster.config.apidoc.customizer.JHipsterOpenApiCustomizer;
+
+@Configuration
+@Profile(JHipsterConstants.SPRING_PROFILE_API_DOCS)
+public class OpenApiConfiguration {
+
+    public static final String API_FIRST_PACKAGE = "org.gcube.fullstackapps.informationsystemmonitor.web.api";
+
+    @Bean
+    @ConditionalOnMissingBean(name = "apiFirstGroupedOpenAPI")
+    public GroupedOpenApi apiFirstGroupedOpenAPI(
+        JHipsterOpenApiCustomizer jhipsterOpenApiCustomizer,
+        JHipsterProperties jHipsterProperties
+    ) {
+        JHipsterProperties.ApiDocs properties = jHipsterProperties.getApiDocs();
+        return GroupedOpenApi
+            .builder()
+            .group("openapi")
+            .addOpenApiCustomiser(jhipsterOpenApiCustomizer)
+            .packagesToScan(API_FIRST_PACKAGE)
+            .pathsToMatch(properties.getDefaultIncludePattern())
+            .build();
+    }
+}
--- a/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/config/SecurityConfiguration.java
+++ b/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/config/SecurityConfiguration.java
@ -0,0 +1,236 @@
+package org.gcube.fullstackapps.informationsystemmonitor.config;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import org.gcube.fullstackapps.informationsystemmonitor.security.AuthoritiesConstants;
+import org.gcube.fullstackapps.informationsystemmonitor.security.SecurityUtils;
+import org.gcube.fullstackapps.informationsystemmonitor.security.oauth2.AudienceValidator;
+import org.gcube.fullstackapps.informationsystemmonitor.security.oauth2.CustomClaimConverter;
+import org.gcube.fullstackapps.informationsystemmonitor.security.oauth2.JwtGrantedAuthorityConverter;
+import org.gcube.fullstackapps.informationsystemmonitor.web.filter.OAuth2RefreshTokensWebFilter;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.web.client.RestTemplateBuilder;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Import;
+import org.springframework.core.convert.converter.Converter;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.RequestEntity;
+import org.springframework.http.converter.FormHttpMessageConverter;
+import org.springframework.security.authentication.AbstractAuthenticationToken;
+import org.springframework.security.authorization.AuthorityAuthorizationManager;
+import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
+import org.springframework.security.config.annotation.web.builders.HttpSecurity;
+import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
+import org.springframework.security.core.GrantedAuthority;
+import org.springframework.security.core.authority.mapping.GrantedAuthoritiesMapper;
+import org.springframework.security.oauth2.client.InMemoryOAuth2AuthorizedClientService;
+import org.springframework.security.oauth2.client.OAuth2AuthorizedClientService;
+import org.springframework.security.oauth2.client.endpoint.DefaultAuthorizationCodeTokenResponseClient;
+import org.springframework.security.oauth2.client.endpoint.NimbusAuthorizationCodeTokenResponseClient;
+import org.springframework.security.oauth2.client.endpoint.OAuth2AccessTokenResponseClient;
+import org.springframework.security.oauth2.client.endpoint.OAuth2AuthorizationCodeGrantRequest;
+import org.springframework.security.oauth2.client.http.OAuth2ErrorResponseErrorHandler;
+import org.springframework.security.oauth2.client.oidc.userinfo.OidcUserRequest;
+import org.springframework.security.oauth2.client.oidc.userinfo.OidcUserService;
+import org.springframework.security.oauth2.client.registration.ClientRegistrationRepository;
+import org.springframework.security.oauth2.client.userinfo.OAuth2UserService;
+import org.springframework.security.oauth2.core.DelegatingOAuth2TokenValidator;
+import org.springframework.security.oauth2.core.OAuth2AccessToken;
+import org.springframework.security.oauth2.core.OAuth2TokenValidator;
+import org.springframework.security.oauth2.core.endpoint.OAuth2AccessTokenResponse;
+import org.springframework.security.oauth2.core.http.converter.OAuth2AccessTokenResponseHttpMessageConverter;
+import org.springframework.security.oauth2.core.oidc.user.DefaultOidcUser;
+import org.springframework.security.oauth2.core.oidc.user.OidcUser;
+import org.springframework.security.oauth2.core.oidc.user.OidcUserAuthority;
+import org.springframework.security.oauth2.jwt.Jwt;
+import org.springframework.security.oauth2.jwt.JwtDecoder;
+import org.springframework.security.oauth2.jwt.JwtDecoders;
+import org.springframework.security.oauth2.jwt.JwtValidators;
+import org.springframework.security.oauth2.jwt.NimbusJwtDecoder;
+import org.springframework.security.oauth2.server.resource.authentication.JwtAuthenticationConverter;
+import org.springframework.security.web.SecurityFilterChain;
+import org.springframework.security.web.csrf.CookieCsrfTokenRepository;
+import org.springframework.security.web.csrf.CsrfFilter;
+import org.springframework.security.web.header.writers.ReferrerPolicyHeaderWriter;
+import org.springframework.web.client.RestTemplate;
+import org.springframework.web.filter.CorsFilter;
+import org.zalando.problem.spring.web.advice.security.SecurityProblemSupport;
+
+import tech.jhipster.config.JHipsterProperties;
+
+
+@EnableWebSecurity
+@EnableGlobalMethodSecurity(prePostEnabled = true, securedEnabled = true)
+@Import(SecurityProblemSupport.class)
+public class SecurityConfiguration {
+
+	private static final Logger logger = LoggerFactory.getLogger(SecurityConfiguration.class);
+
+	private final JHipsterProperties jHipsterProperties;
+
+	private final CorsFilter corsFilter;
+
+	@Value("${spring.security.oauth2.client.provider.oidc.issuer-uri}")
+	private String issuerUri;
+
+	private final SecurityProblemSupport problemSupport;
+	
+	public SecurityConfiguration(CorsFilter corsFilter, JHipsterProperties jHipsterProperties,
+			SecurityProblemSupport problemSupport) {
+		this.corsFilter = corsFilter;
+		this.problemSupport = problemSupport;
+		this.jHipsterProperties = jHipsterProperties;
+		
+	}
+
+	@Bean
+	public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
+		// @formatter:off
+        http
+            .csrf()
+            	.csrfTokenRepository(CookieCsrfTokenRepository.withHttpOnlyFalse())
+        .and()
+            .addFilterBefore(corsFilter, CsrfFilter.class)
+            .exceptionHandling()
+               .authenticationEntryPoint(problemSupport)
+               .accessDeniedHandler(problemSupport)
+        .and()
+            .headers()
+                .contentSecurityPolicy(jHipsterProperties.getSecurity().getContentSecurityPolicy())
+            .and()
+                .referrerPolicy(ReferrerPolicyHeaderWriter.ReferrerPolicy.STRICT_ORIGIN_WHEN_CROSS_ORIGIN)
+            .and()
+                .permissionsPolicy().policy("camera=(), fullscreen=(self), geolocation=(), gyroscope=(), magnetometer=(), microphone=(), midi=(), payment=(), sync-xhr=()")
+            .and()
+                .frameOptions().sameOrigin()
+        .and()
+            .authorizeRequests()
+            .antMatchers(HttpMethod.OPTIONS, "/**").permitAll()
+            .antMatchers("/app/**/*.{js,html}").permitAll()
+            .antMatchers("/i18n/**").permitAll()
+            .antMatchers("/content/**").permitAll()
+            .antMatchers("/swagger-ui/**").permitAll()
+            .antMatchers("/test/**").permitAll()
+            .antMatchers("/login/oauth2/code/oidc").permitAll()
+            .antMatchers("/api/account").permitAll()
+            .antMatchers("/api/authenticate").permitAll()
+            .antMatchers("/api/auth-info").permitAll()
+            .antMatchers("/api/admin/**").hasAuthority(AuthoritiesConstants.ADMIN)
+            .antMatchers("/api/**").authenticated()
+            .antMatchers("/management/health").permitAll()
+            .antMatchers("/management/health/**").permitAll()
+            .antMatchers("/management/info").permitAll()
+            .antMatchers("/management/prometheus").permitAll()
+            .antMatchers("/management/**").hasAuthority(AuthoritiesConstants.ADMIN)
+        .and()
+            .oauth2Login()
+            	//.defaultSuccessUrl("/api/scopes/discovery").userInfoEndpoint(userInfo -> userInfo
+			    //    .oidcUserService(this.oidcUserService()))
+            //.defaultSuccessUrl(issuerUri, false)
+            //.defaultSuccessUrl("/api/login/oauth2/code/oidc")
+            //.addFilterAfter(new CustomAuthenticationFilter(), UsernamePasswordAuthenticationFilter.class)
+            //.logout(logout -> logout.logoutSuccessHandler(oidcLogoutSuccessHandler()))
+            //.tokenEndpoint()
+            //.accessTokenResponseClient(accessTokenResponseClient())
+        //.and()
+            //.oauth2ResourceServer()
+                //.jwt()
+                //.jwtAuthenticationConverter(authenticationConverter())
+                //.and()
+            .and()
+                .oauth2Client();			
+                //.authorizationCodeGrant();
+                
+        
+        return http.build();
+        // @formatter:on
+	}
+	
+	
+	
+	private OAuth2UserService<OidcUserRequest, OidcUser> oidcUserService() {
+		final OidcUserService delegate = new OidcUserService();
+
+		return (userRequest) -> {
+			// Delegate to the default implementation for loading a user
+			OidcUser oidcUser = delegate.loadUser(userRequest);
+			
+			OAuth2AccessToken accessToken = userRequest.getAccessToken();
+			
+			Set<GrantedAuthority> mappedAuthorities = new HashSet<>();
+			logger.debug("Fetch AccessToken: {}",accessToken.getTokenValue());
+			// TODO
+			// 1) Fetch the authority information from the protected resource using accessToken
+			// 2) Map the authority information to one or more GrantedAuthority's and add it to mappedAuthorities
+
+			// 3) Create a copy of oidcUser but use the mappedAuthorities instead
+			oidcUser = new DefaultOidcUser(mappedAuthorities, oidcUser.getIdToken(), oidcUser.getUserInfo());
+			logger.debug("OIDCUser: {}",oidcUser);
+			
+			return oidcUser;
+		};
+	}
+	
+
+
+	Converter<Jwt, AbstractAuthenticationToken> authenticationConverter() {
+		logger.debug("JWT AuthenticationConverter()");
+		JwtAuthenticationConverter jwtAuthenticationConverter = new JwtAuthenticationConverter();
+		jwtAuthenticationConverter.setJwtGrantedAuthoritiesConverter(new JwtGrantedAuthorityConverter());
+		return jwtAuthenticationConverter;
+	}
+
+	/**
+	 * Map authorities from "groups" or "roles" claim in ID Token.
+	 *
+	 * @return a {@link GrantedAuthoritiesMapper} that maps groups from the IdP to
+	 *         Spring Security Authorities.
+	 */
+	@Bean
+	public GrantedAuthoritiesMapper userAuthoritiesMapper() {
+		return authorities -> {
+			logger.debug("Authorities: {}", authorities);
+			Set<GrantedAuthority> mappedAuthorities = new HashSet<>();
+
+			authorities.forEach(authority -> {
+				// Check for OidcUserAuthority because Spring Security 5.2 returns
+				// each scope as a GrantedAuthority, which we don't care about.
+				logger.debug("Authority: {}", authority);
+				if (authority instanceof OidcUserAuthority) {
+					OidcUserAuthority oidcUserAuthority = (OidcUserAuthority) authority;
+					logger.debug("TokenValue: {}", oidcUserAuthority.getIdToken().getTokenValue());
+					logger.debug("oidcUserAuthority: {}", oidcUserAuthority);
+					mappedAuthorities.addAll(
+							SecurityUtils.extractAuthorityFromClaims(oidcUserAuthority.getUserInfo().getClaims()));
+				}
+			});
+			return mappedAuthorities;
+		};
+	}
+
+	@Bean
+	JwtDecoder jwtDecoder(ClientRegistrationRepository clientRegistrationRepository,
+			RestTemplateBuilder restTemplateBuilder) {
+		logger.debug("JWTDecoder: {}", restTemplateBuilder);
+
+		NimbusJwtDecoder jwtDecoder = JwtDecoders.fromOidcIssuerLocation(issuerUri);
+
+		OAuth2TokenValidator<Jwt> audienceValidator = new AudienceValidator(
+				jHipsterProperties.getSecurity().getOauth2().getAudience());
+		OAuth2TokenValidator<Jwt> withIssuer = JwtValidators.createDefaultWithIssuer(issuerUri);
+		OAuth2TokenValidator<Jwt> withAudience = new DelegatingOAuth2TokenValidator<>(withIssuer, audienceValidator);
+
+		jwtDecoder.setJwtValidator(withAudience);
+		jwtDecoder.setClaimSetConverter(new CustomClaimConverter(
+				clientRegistrationRepository.findByRegistrationId("oidc"), restTemplateBuilder.build()));
+
+		return jwtDecoder;
+	}
+
+}
--- a/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/config/StaticResourcesWebConfiguration.java
+++ b/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/config/StaticResourcesWebConfiguration.java
@ -0,0 +1,59 @@
+package org.gcube.fullstackapps.informationsystemmonitor.config;
+
+import java.util.concurrent.TimeUnit;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Profile;
+import org.springframework.http.CacheControl;
+import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistration;
+import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
+import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
+import tech.jhipster.config.JHipsterConstants;
+import tech.jhipster.config.JHipsterProperties;
+
+@Configuration
+@Profile({ JHipsterConstants.SPRING_PROFILE_PRODUCTION })
+public class StaticResourcesWebConfiguration implements WebMvcConfigurer {
+
+    protected static final String[] RESOURCE_LOCATIONS = new String[] {
+        "classpath:/static/",
+        "classpath:/static/content/",
+        "classpath:/static/i18n/",
+    };
+    protected static final String[] RESOURCE_PATHS = new String[] {
+        "/*.js",
+        "/*.css",
+        "/*.svg",
+        "/*.png",
+        "*.ico",
+        "/content/**",
+        "/i18n/*",
+    };
+
+    private final JHipsterProperties jhipsterProperties;
+
+    public StaticResourcesWebConfiguration(JHipsterProperties jHipsterProperties) {
+        this.jhipsterProperties = jHipsterProperties;
+    }
+
+    @Override
+    public void addResourceHandlers(ResourceHandlerRegistry registry) {
+        ResourceHandlerRegistration resourceHandlerRegistration = appendResourceHandler(registry);
+        initializeResourceHandler(resourceHandlerRegistration);
+    }
+
+    protected ResourceHandlerRegistration appendResourceHandler(ResourceHandlerRegistry registry) {
+        return registry.addResourceHandler(RESOURCE_PATHS);
+    }
+
+    protected void initializeResourceHandler(ResourceHandlerRegistration resourceHandlerRegistration) {
+        resourceHandlerRegistration.addResourceLocations(RESOURCE_LOCATIONS).setCacheControl(getCacheControl());
+    }
+
+    protected CacheControl getCacheControl() {
+        return CacheControl.maxAge(getJHipsterHttpCacheProperty(), TimeUnit.DAYS).cachePublic();
+    }
+
+    private int getJHipsterHttpCacheProperty() {
+        return jhipsterProperties.getHttp().getCache().getTimeToLiveInDays();
+    }
+}
--- a/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/config/TokenManager.java
+++ b/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/config/TokenManager.java
@ -0,0 +1,83 @@
+package org.gcube.fullstackapps.informationsystemmonitor.config;
+
+import org.gcube.fullstackapps.informationsystemmonitor.service.dto.UmaResponseDTO;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.http.HttpEntity;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.security.oauth2.client.OAuth2AuthorizedClient;
+import org.springframework.security.oauth2.client.OAuth2AuthorizedClientService;
+import org.springframework.security.oauth2.client.authentication.OAuth2AuthenticationToken;
+import org.springframework.stereotype.Component;
+import org.springframework.util.LinkedMultiValueMap;
+import org.springframework.util.MultiValueMap;
+import org.springframework.web.client.RestTemplate;
+
+
+
+@Component
+public class TokenManager {
+
+	private static final Logger log = LoggerFactory.getLogger(TokenManager.class);
+	@Value("${spring.security.oauth2.client.provider.oidc.token-uri}")
+	private String tokenUri;
+
+	@Autowired
+	private OAuth2AuthorizedClientService authorizedClientService;
+
+	
+
+	public String getUmaToken(String context) {
+		String accessToken=getAccessToken();
+		HttpHeaders headers = new HttpHeaders();
+		headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);
+		headers.set("Authorization", "Bearer " + accessToken);
+		log.debug("Headers: {}", headers);
+
+		MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
+		params.add("grant_type", "urn:ietf:params:oauth:grant-type:uma-ticket");
+		params.add("audience", context);
+		log.debug("Params: {}", params);
+
+		HttpEntity<MultiValueMap<String, String>> entity = new HttpEntity<>(params, headers);
+
+		RestTemplate restTemplate = new RestTemplate();
+
+		ResponseEntity<UmaResponseDTO> response = restTemplate.exchange(tokenUri, HttpMethod.POST, entity, UmaResponseDTO.class);
+		UmaResponseDTO umaResponceDTO = response.getBody();
+		log.debug("UmaResponceDTO: {}", umaResponceDTO);
+		String umaToken=umaResponceDTO.getAccess_token();
+		log.debug("UmaToken: {}", umaToken);
+		return umaToken;
+	}
+
+	public String getAccessToken() {
+		OAuth2AuthenticationToken oAuth2AuthenticationToken = (OAuth2AuthenticationToken) SecurityContextHolder
+				.getContext().getAuthentication();
+		log.debug("OAuth2AuthenticationToken: {}", oAuth2AuthenticationToken);
+
+		OAuth2AuthorizedClient client = authorizedClientService.loadAuthorizedClient(
+				oAuth2AuthenticationToken.getAuthorizedClientRegistrationId(), oAuth2AuthenticationToken.getName());
+		/*if(client.getAccessToken().getExpiresAt().compareTo(Instant.now())>0) {
+			
+		}*/
+		
+		String accessToken = client.getAccessToken().getTokenValue();
+		
+		log.debug("AccessToken: {}", accessToken);
+		return accessToken;
+	}
+	
+	public String getRootContext() {
+		String rootContext = "/gcube";
+		return rootContext;
+	}
+	
+
+}
--- a/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/config/WebConfigurer.java
+++ b/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/config/WebConfigurer.java
@ -0,0 +1,105 @@
+package org.gcube.fullstackapps.informationsystemmonitor.config;
+
+import static java.net.URLDecoder.decode;
+
+import java.io.File;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Paths;
+
+import javax.servlet.ServletContext;
+import javax.servlet.ServletException;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.boot.web.server.WebServerFactory;
+import org.springframework.boot.web.server.WebServerFactoryCustomizer;
+import org.springframework.boot.web.servlet.ServletContextInitializer;
+import org.springframework.boot.web.servlet.server.ConfigurableServletWebServerFactory;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.core.env.Environment;
+import org.springframework.util.CollectionUtils;
+import org.springframework.web.cors.CorsConfiguration;
+import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
+import org.springframework.web.filter.CorsFilter;
+
+import tech.jhipster.config.JHipsterProperties;
+
+/**
+ * Configuration of web application with Servlet 3.0 APIs.
+ */
+@Configuration
+public class WebConfigurer implements ServletContextInitializer, WebServerFactoryCustomizer<WebServerFactory> {
+
+    private final Logger log = LoggerFactory.getLogger(WebConfigurer.class);
+
+    private final Environment env;
+
+    private final JHipsterProperties jHipsterProperties;
+
+    public WebConfigurer(Environment env, JHipsterProperties jHipsterProperties) {
+        this.env = env;
+        this.jHipsterProperties = jHipsterProperties;
+    }
+
+    @Override
+    public void onStartup(ServletContext servletContext) throws ServletException {
+        if (env.getActiveProfiles().length != 0) {
+            log.info("Web application configuration, using profiles: {}", (Object[]) env.getActiveProfiles());
+        }
+
+        log.info("Web application fully configured");
+    }
+
+    /**
+     * Customize the Servlet engine: Mime types, the document root, the cache.
+     */
+    @Override
+    public void customize(WebServerFactory server) {
+        // When running in an IDE or with ./mvnw spring-boot:run, set location of the static web assets.
+        setLocationForStaticAssets(server);
+    }
+
+    private void setLocationForStaticAssets(WebServerFactory server) {
+        if (server instanceof ConfigurableServletWebServerFactory) {
+            ConfigurableServletWebServerFactory servletWebServer = (ConfigurableServletWebServerFactory) server;
+            File root;
+            String prefixPath = resolvePathPrefix();
+            root = new File(prefixPath + "target/classes/static/");
+            if (root.exists() && root.isDirectory()) {
+                servletWebServer.setDocumentRoot(root);
+            }
+        }
+    }
+
+    /**
+     * Resolve path prefix to static resources.
+     */
+    private String resolvePathPrefix() {
+        String fullExecutablePath = decode(this.getClass().getResource("").getPath(), StandardCharsets.UTF_8);
+        String rootPath = Paths.get(".").toUri().normalize().getPath();
+        String extractedPath = fullExecutablePath.replace(rootPath, "");
+        int extractionEndIndex = extractedPath.indexOf("target/");
+        if (extractionEndIndex <= 0) {
+            return "";
+        }
+        return extractedPath.substring(0, extractionEndIndex);
+    }
+
+    @Bean
+    public CorsFilter corsFilter() {
+        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
+        CorsConfiguration config = jHipsterProperties.getCors();
+        if (!CollectionUtils.isEmpty(config.getAllowedOrigins()) || !CollectionUtils.isEmpty(config.getAllowedOriginPatterns())) {
+            log.debug("Registering CORS filter");
+            source.registerCorsConfiguration("/login/**", config);
+            source.registerCorsConfiguration("/api/**", config);
+            source.registerCorsConfiguration("/management/**", config);
+            source.registerCorsConfiguration("/v3/api-docs", config);
+            source.registerCorsConfiguration("/swagger-ui/**", config);
+        }
+        return new CorsFilter(source);
+    }
+    
+    
+}
--- a/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/config/package-info.java
+++ b/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/config/package-info.java
@ -0,0 +1,4 @@
+/**
+ * Spring Framework configuration files.
+ */
+package org.gcube.fullstackapps.informationsystemmonitor.config;
--- a/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/domain/TestDialogDTO.java
+++ b/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/domain/TestDialogDTO.java
@ -0,0 +1,17 @@
+package org.gcube.fullstackapps.informationsystemmonitor.domain;
+
+import java.io.Serializable;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class TestDialogDTO implements Serializable {
+	
+	private static final long serialVersionUID = 1L;
+	private String status;
+}
+
--- a/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/domain/package-info.java
+++ b/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/domain/package-info.java
@ -0,0 +1,4 @@
+/**
+ * JPA domain objects.
+ */
+package org.gcube.fullstackapps.informationsystemmonitor.domain;
--- a/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/repository/package-info.java
+++ b/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/repository/package-info.java
@ -0,0 +1,4 @@
+/**
+ * Spring Data JPA repositories.
+ */
+package org.gcube.fullstackapps.informationsystemmonitor.repository;
--- a/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/security/AuthoritiesConstants.java
+++ b/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/security/AuthoritiesConstants.java
@ -0,0 +1,15 @@
+package org.gcube.fullstackapps.informationsystemmonitor.security;
+
+/**
+ * Constants for Spring Security authorities.
+ */
+public final class AuthoritiesConstants {
+
+    public static final String ADMIN = "ROLE_ADMIN";
+
+    public static final String USER = "ROLE_USER";
+
+    public static final String ANONYMOUS = "ROLE_ANONYMOUS";
+
+    private AuthoritiesConstants() {}
+}
--- a/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/security/SecurityUtils.java
+++ b/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/security/SecurityUtils.java
@ -0,0 +1,167 @@
+package org.gcube.fullstackapps.informationsystemmonitor.security;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.stream.Stream;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.GrantedAuthority;
+import org.springframework.security.core.authority.SimpleGrantedAuthority;
+import org.springframework.security.core.context.SecurityContext;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.security.core.userdetails.UserDetails;
+import org.springframework.security.oauth2.core.oidc.user.DefaultOidcUser;
+import org.springframework.security.oauth2.server.resource.authentication.JwtAuthenticationToken;
+
+/**
+ * Utility class for Spring Security.
+ */
+public final class SecurityUtils {
+
+	private static final Logger logger = LoggerFactory.getLogger(SecurityUtils.class);
+
+	public static final String CLAIMS_NAMESPACE = "https://www.jhipster.tech/";
+
+	private SecurityUtils() {
+	}
+
+	/**
+	 * Get the login of the current user.
+	 *
+	 * @return the login of the current user.
+	 */
+	public static Optional<String> getCurrentUserLogin() {
+		SecurityContext securityContext = SecurityContextHolder.getContext();
+		return Optional.ofNullable(extractPrincipal(securityContext.getAuthentication()));
+	}
+
+	private static String extractPrincipal(Authentication authentication) {
+		logger.debug("extractPrincipal: {}", authentication);
+		if (authentication == null) {
+			return null;
+		} else if (authentication.getPrincipal() instanceof UserDetails) {
+			UserDetails springSecurityUser = (UserDetails) authentication.getPrincipal();
+			return springSecurityUser.getUsername();
+		} else if (authentication instanceof JwtAuthenticationToken) {
+			return (String) ((JwtAuthenticationToken) authentication).getToken().getClaims().get("preferred_username");
+		} else if (authentication.getPrincipal() instanceof DefaultOidcUser) {
+			Map<String, Object> attributes = ((DefaultOidcUser) authentication.getPrincipal()).getAttributes();
+			if (attributes.containsKey("preferred_username")) {
+				return (String) attributes.get("preferred_username");
+			}
+		} else if (authentication.getPrincipal() instanceof String) {
+			return (String) authentication.getPrincipal();
+		}
+		return null;
+	}
+
+	/**
+	 * Check if a user is authenticated.
+	 *
+	 * @return true if the user is authenticated, false otherwise.
+	 */
+	public static boolean isAuthenticated() {
+		Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
+		return authentication != null
+				&& getAuthorities(authentication).noneMatch(AuthoritiesConstants.ANONYMOUS::equals);
+	}
+
+	/**
+	 * Checks if the current user has any of the authorities.
+	 *
+	 * @param authorities the authorities to check.
+	 * @return true if the current user has any of the authorities, false otherwise.
+	 */
+	public static boolean hasCurrentUserAnyOfAuthorities(String... authorities) {
+		Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
+		return (authentication != null && getAuthorities(authentication)
+				.anyMatch(authority -> Arrays.asList(authorities).contains(authority)));
+	}
+
+	/**
+	 * Checks if the current user has none of the authorities.
+	 *
+	 * @param authorities the authorities to check.
+	 * @return true if the current user has none of the authorities, false
+	 *         otherwise.
+	 */
+	public static boolean hasCurrentUserNoneOfAuthorities(String... authorities) {
+		return !hasCurrentUserAnyOfAuthorities(authorities);
+	}
+
+	/**
+	 * Checks if the current user has a specific authority.
+	 *
+	 * @param authority the authority to check.
+	 * @return true if the current user has the authority, false otherwise.
+	 */
+	public static boolean hasCurrentUserThisAuthority(String authority) {
+		return hasCurrentUserAnyOfAuthorities(authority);
+	}
+
+	private static Stream<String> getAuthorities(Authentication authentication) {
+		logger.debug("getAuthorities: {}", authentication);
+		Collection<? extends GrantedAuthority> authorities = authentication instanceof JwtAuthenticationToken
+				? extractAuthorityFromClaims(((JwtAuthenticationToken) authentication).getToken().getClaims())
+				: authentication.getAuthorities();
+		return authorities.stream().map(GrantedAuthority::getAuthority);
+	}
+
+	public static List<GrantedAuthority> extractAuthorityFromClaims(Map<String, Object> claims) {
+		logger.debug("extractAuthorityFromClaims: {}", claims);
+		return mapRolesToGrantedAuthorities(getRolesFromClaims(claims));
+	}
+
+	
+	@SuppressWarnings("unchecked")
+	private static Collection<String> getRolesFromClaims(Map<String, Object> claims) {
+		logger.debug("getRolesFromClaims(): {}", claims);
+		// return (Collection<String>) claims.getOrDefault(
+		// "groups",
+		// claims.getOrDefault("roles", claims.getOrDefault(CLAIMS_NAMESPACE + "roles",
+		// new ArrayList<>()))
+		// );
+		if (claims.get("resource_access") != null) {
+			logger.debug("ResourceAccess: {}",claims.get("resource_access").getClass());
+			Map<String,Object> scope=(Map<String,Object>)claims.get("resource_access");
+			ArrayList<String> roles = new ArrayList<>();
+			for (String key : scope.keySet()) {
+				logger.info("Default Scope: {}",key);
+				roles=((Map<String, ArrayList<String>>)scope.get(key)).get("roles");
+				break;
+			}
+			logger.info("D4Science Roles: {}",roles);
+			return roles;
+		} else {
+			logger.debug("D4Science Roles: {}");
+			return new ArrayList<String>();
+		}
+
+	}
+
+	private static List<GrantedAuthority> mapRolesToGrantedAuthorities(Collection<String> roles) {
+		logger.debug("mapRolesToGrantedAuthorities(): {}", roles);
+		List<GrantedAuthority> ga = new ArrayList<>();
+		boolean isAdmin = false;
+		for (String role : roles) {
+			if (role.compareTo("Member") == 0) {
+				isAdmin = true;
+				break;
+			}
+		}
+		if (isAdmin) {
+			ga.add(new SimpleGrantedAuthority(AuthoritiesConstants.ADMIN));
+		} else {
+			ga.add(new SimpleGrantedAuthority(AuthoritiesConstants.USER));
+
+		}
+		logger.info("GrantedAuthority: {}",ga);
+		return ga;
+	}
+}
--- a/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/security/oauth2/AudienceValidator.java
+++ b/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/security/oauth2/AudienceValidator.java
@ -0,0 +1,33 @@
+package org.gcube.fullstackapps.informationsystemmonitor.security.oauth2;
+
+import java.util.List;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.security.oauth2.core.OAuth2Error;
+import org.springframework.security.oauth2.core.OAuth2TokenValidator;
+import org.springframework.security.oauth2.core.OAuth2TokenValidatorResult;
+import org.springframework.security.oauth2.jwt.Jwt;
+import org.springframework.util.Assert;
+
+public class AudienceValidator implements OAuth2TokenValidator<Jwt> {
+
+    private final Logger log = LoggerFactory.getLogger(AudienceValidator.class);
+    private final OAuth2Error error = new OAuth2Error("invalid_token", "The required audience is missing", null);
+
+    private final List<String> allowedAudience;
+
+    public AudienceValidator(List<String> allowedAudience) {
+        Assert.notEmpty(allowedAudience, "Allowed audience should not be null or empty.");
+        this.allowedAudience = allowedAudience;
+    }
+
+    public OAuth2TokenValidatorResult validate(Jwt jwt) {
+        List<String> audience = jwt.getAudience();
+        if (audience.stream().anyMatch(allowedAudience::contains)) {
+            return OAuth2TokenValidatorResult.success();
+        } else {
+            log.warn("Invalid audience: {}", audience);
+            return OAuth2TokenValidatorResult.failure(error);
+        }
+    }
+}
--- a/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/security/oauth2/CustomClaimConverter.java
+++ b/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/security/oauth2/CustomClaimConverter.java
@ -0,0 +1,136 @@
+package org.gcube.fullstackapps.informationsystemmonitor.security.oauth2;
+
+import java.time.Duration;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import java.util.stream.StreamSupport;
+
+import org.gcube.fullstackapps.informationsystemmonitor.security.SecurityUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.core.convert.converter.Converter;
+import org.springframework.http.HttpEntity;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.oauth2.client.registration.ClientRegistration;
+import org.springframework.security.oauth2.jwt.MappedJwtClaimSetConverter;
+import org.springframework.security.oauth2.server.resource.web.BearerTokenResolver;
+import org.springframework.security.oauth2.server.resource.web.DefaultBearerTokenResolver;
+import org.springframework.web.client.RestTemplate;
+import org.springframework.web.context.request.RequestAttributes;
+import org.springframework.web.context.request.RequestContextHolder;
+import org.springframework.web.context.request.ServletRequestAttributes;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import com.github.benmanes.caffeine.cache.Cache;
+import com.github.benmanes.caffeine.cache.Caffeine;
+
+/**
+ * Claim converter to add custom claims by retrieving the user from the userinfo endpoint.
+ */
+public class CustomClaimConverter implements Converter<Map<String, Object>, Map<String, Object>> {
+	
+	private static final Logger logger = LoggerFactory.getLogger(CustomClaimConverter.class);
+	
+    private final BearerTokenResolver bearerTokenResolver = new DefaultBearerTokenResolver();
+
+    private final MappedJwtClaimSetConverter delegate = MappedJwtClaimSetConverter.withDefaults(Collections.emptyMap());
+
+    private final RestTemplate restTemplate;
+
+    private final ClientRegistration registration;
+
+    // See https://github.com/jhipster/generator-jhipster/issues/18868
+    // We don't use a distributed cache or the user selected cache implementation here on purpose
+    private final Cache<String, ObjectNode> users = Caffeine
+        .newBuilder()
+        .maximumSize(10_000)
+        .expireAfterWrite(Duration.ofHours(1))
+        .recordStats()
+        .build();
+
+    public CustomClaimConverter(ClientRegistration registration, RestTemplate restTemplate) {
+        this.registration = registration;
+        this.restTemplate = restTemplate;
+    }
+
+    public Map<String, Object> convert(Map<String, Object> claims) {
+        logger.debug("convert()");
+    	Map<String, Object> convertedClaims = this.delegate.convert(claims);
+        // Only look up user information if identity claims are missing
+        if (claims.containsKey("given_name") && claims.containsKey("family_name")) {
+            return convertedClaims;
+        }
+        RequestAttributes attributes = RequestContextHolder.getRequestAttributes();
+        if (attributes instanceof ServletRequestAttributes) {
+            // Retrieve and set the token
+            String token = bearerTokenResolver.resolve(((ServletRequestAttributes) attributes).getRequest());
+            logger.debug("Token: {}",token);
+            HttpHeaders headers = new HttpHeaders();
+            headers.set("Authorization", buildBearer(token));
+
+            // Retrieve user info from OAuth provider if not already loaded
+            ObjectNode user = users.get(
+                claims.get("sub").toString(),
+                s -> {
+                    ResponseEntity<ObjectNode> userInfo = restTemplate.exchange(
+                        registration.getProviderDetails().getUserInfoEndpoint().getUri(),
+                        HttpMethod.GET,
+                        new HttpEntity<String>(headers),
+                        ObjectNode.class
+                    );
+                    return userInfo.getBody();
+                }
+            );
+            
+            logger.debug("User Info: {}",user);
+            
+            // Add custom claims
+            if (user != null) {
+                convertedClaims.put("preferred_username", user.get("preferred_username").asText());
+                if (user.has("given_name")) {
+                    convertedClaims.put("given_name", user.get("given_name").asText());
+                }
+                if (user.has("family_name")) {
+                    convertedClaims.put("family_name", user.get("family_name").asText());
+                }
+                if (user.has("email")) {
+                    convertedClaims.put("email", user.get("email").asText());
+                }
+                // Allow full name in a name claim - happens with Auth0
+                if (user.has("name")) {
+                    String[] name = user.get("name").asText().split("\\s+");
+                    if (name.length > 0) {
+                        convertedClaims.put("given_name", name[0]);
+                        convertedClaims.put("family_name", String.join(" ", Arrays.copyOfRange(name, 1, name.length)));
+                    }
+                }
+                if (user.has("groups")) {
+                    List<String> groups = StreamSupport
+                        .stream(user.get("groups").spliterator(), false)
+                        .map(JsonNode::asText)
+                        .collect(Collectors.toList());
+                    convertedClaims.put("groups", groups);
+                }
+                if (user.has(SecurityUtils.CLAIMS_NAMESPACE + "roles")) {
+                    List<String> roles = StreamSupport
+                        .stream(user.get(SecurityUtils.CLAIMS_NAMESPACE + "roles").spliterator(), false)
+                        .map(JsonNode::asText)
+                        .collect(Collectors.toList());
+                    convertedClaims.put("roles", roles);
+                }
+            }
+        }
+        logger.debug("Claims: "+convertedClaims.toString());
+        return convertedClaims;
+    }
+
+    private String buildBearer(String token) {
+        return "Bearer " + token;
+    }
+}
--- a/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/security/oauth2/JwtGrantedAuthorityConverter.java
+++ b/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/security/oauth2/JwtGrantedAuthorityConverter.java
@ -0,0 +1,25 @@
+package org.gcube.fullstackapps.informationsystemmonitor.security.oauth2;
+
+import java.util.Collection;
+import org.gcube.fullstackapps.informationsystemmonitor.security.SecurityUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.core.convert.converter.Converter;
+import org.springframework.security.core.GrantedAuthority;
+import org.springframework.security.oauth2.jwt.Jwt;
+import org.springframework.stereotype.Component;
+
+@Component
+public class JwtGrantedAuthorityConverter implements Converter<Jwt, Collection<GrantedAuthority>> {
+
+	private static final Logger logger = LoggerFactory.getLogger(JwtGrantedAuthorityConverter.class);
+	public JwtGrantedAuthorityConverter() {
+        logger.debug("New JwtGrantedAuthorityConverter: created");
+    }
+
+    @Override
+    public Collection<GrantedAuthority> convert(Jwt jwt) {
+    	logger.debug("convert(): {}",jwt);
+        return SecurityUtils.extractAuthorityFromClaims(jwt.getClaims());
+    }
+}
--- a/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/security/oauth2/OAuthIdpTokenResponseDTO.java
+++ b/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/security/oauth2/OAuthIdpTokenResponseDTO.java
@ -0,0 +1,155 @@
+package org.gcube.fullstackapps.informationsystemmonitor.security.oauth2;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import java.io.Serializable;
+import java.util.UUID;
+
+public class OAuthIdpTokenResponseDTO implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+	@JsonProperty("token_type")
+    private String tokenType;
+
+    private String scope;
+
+    @JsonProperty("expires_in")
+    private Long expiresIn;
+
+    @JsonProperty("ext_expires_in")
+    private Long extExpiresIn;
+
+    @JsonProperty("expires_on")
+    private Long expiresOn;
+
+    @JsonProperty("not-before-policy")
+    private Long notBefore;
+
+    private UUID resource;
+
+    @JsonProperty("access_token")
+    private String accessToken;
+
+    @JsonProperty("refresh_token")
+    private String refreshToken;
+
+    @JsonProperty("id_token")
+    private String idToken;
+
+    @JsonProperty("session_state")
+    private String sessionState;
+
+    @JsonProperty("refresh_expires_in")
+    private String refreshExpiresIn;
+
+    public OAuthIdpTokenResponseDTO() {
+        // Empty constructor for serialization.
+    }
+
+    public String getRefreshExpiresIn() {
+        return refreshExpiresIn;
+    }
+
+    public void setRefreshExpiresIn(String refreshExpiresIn) {
+        this.refreshExpiresIn = refreshExpiresIn;
+    }
+
+    public String getSessionState() {
+        return sessionState;
+    }
+
+    public void setSessionState(String sessionState) {
+        this.sessionState = sessionState;
+    }
+
+    public String getTokenType() {
+        return tokenType;
+    }
+
+    public void setTokenType(String tokenType) {
+        this.tokenType = tokenType;
+    }
+
+    public String getScope() {
+        return scope;
+    }
+
+    public void setScope(String scope) {
+        this.scope = scope;
+    }
+
+    public Long getExpiresIn() {
+        return expiresIn;
+    }
+
+    public void setExpiresIn(Long expiresIn) {
+        this.expiresIn = expiresIn;
+    }
+
+    public Long getExtExpiresIn() {
+        return extExpiresIn;
+    }
+
+    public void setExtExpiresIn(Long extExpiresIn) {
+        this.extExpiresIn = extExpiresIn;
+    }
+
+    public Long getExpiresOn() {
+        return expiresOn;
+    }
+
+    public void setExpiresOn(Long expiresOn) {
+        this.expiresOn = expiresOn;
+    }
+
+    public Long getNotBefore() {
+        return notBefore;
+    }
+
+    public void setNotBefore(Long notBefore) {
+        this.notBefore = notBefore;
+    }
+
+    public UUID getResource() {
+        return resource;
+    }
+
+    public void setResource(UUID resource) {
+        this.resource = resource;
+    }
+
+    public String getAccessToken() {
+        return accessToken;
+    }
+
+    public void setAccessToken(String accessToken) {
+        this.accessToken = accessToken;
+    }
+
+    public String getRefreshToken() {
+        return refreshToken;
+    }
+
+    public void setRefreshToken(String refreshToken) {
+        this.refreshToken = refreshToken;
+    }
+
+    public String getIdToken() {
+        return idToken;
+    }
+
+    public void setIdToken(String idToken) {
+        this.idToken = idToken;
+    }
+
+	@Override
+	public String toString() {
+		return "OAuthIdpTokenResponseDTO [tokenType=" + tokenType + ", scope=" + scope + ", expiresIn=" + expiresIn
+				+ ", extExpiresIn=" + extExpiresIn + ", expiresOn=" + expiresOn + ", notBefore=" + notBefore
+				+ ", resource=" + resource + ", accessToken=" + accessToken + ", refreshToken=" + refreshToken
+				+ ", idToken=" + idToken + ", sessionState=" + sessionState + ", refreshExpiresIn=" + refreshExpiresIn
+				+ "]";
+	}
+    
+    
+}
--- a/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/security/package-info.java
+++ b/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/security/package-info.java
@ -0,0 +1,4 @@
+/**
+ * Spring Security configuration.
+ */
+package org.gcube.fullstackapps.informationsystemmonitor.security;
--- a/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/service/ContextService.java
+++ b/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/service/ContextService.java
@ -0,0 +1,46 @@
+package org.gcube.fullstackapps.informationsystemmonitor.service;
+
+import java.util.ArrayList;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.security.oauth2.client.AuthorizedClientServiceOAuth2AuthorizedClientManager;
+import org.springframework.security.oauth2.core.oidc.user.DefaultOidcUser;
+import org.springframework.security.web.authentication.WebAuthenticationDetails;
+import org.springframework.stereotype.Service;
+import org.springframework.web.context.request.RequestContextHolder;
+
+@Service
+public class ContextService {
+
+    private final Logger log = LoggerFactory.getLogger(ContextService.class);
+    
+   
+    
+    
+    public ArrayList<String> all(){
+    	ArrayList<String> scopes=new ArrayList<>();
+    	scopes.add("gcube");
+    	scopes.add("gcube/devsec");
+    	scopes.add("gcube/devsec/devVRE");
+    	log.debug("Scopes found: {}", scopes);
+    	
+    	Authentication auth=SecurityContextHolder.getContext().getAuthentication();
+    	DefaultOidcUser userDetails = (DefaultOidcUser) auth.getPrincipal();
+    	log.debug("UserDetails: {}",userDetails.toString());
+    	
+   
+    	WebAuthenticationDetails details=(WebAuthenticationDetails)auth.getDetails();
+    	 log.debug("Provaci: {}",details);
+    		        
+    	String sessionId=RequestContextHolder.currentRequestAttributes().getSessionId();
+    	log.debug("SessionId: {}",sessionId);
+    	
+    	
+    	
+    	return scopes;
+    }
+
+}
--- a/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/service/InformationSystemService.java
+++ b/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/service/InformationSystemService.java
@ -0,0 +1,51 @@
+package org.gcube.fullstackapps.informationsystemmonitor.service;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.gcube.common.authorization.utils.manager.SecretManager;
+import org.gcube.common.authorization.utils.manager.SecretManagerProvider;
+import org.gcube.common.authorization.utils.secret.JWTSecret;
+import org.gcube.common.authorization.utils.secret.Secret;
+import org.gcube.informationsystem.contexts.impl.entities.ContextImpl;
+import org.gcube.informationsystem.contexts.reference.entities.Context;
+import org.gcube.informationsystem.resourceregistry.client.ResourceRegistryClient;
+import org.gcube.informationsystem.resourceregistry.client.ResourceRegistryClientFactory;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Service;
+
+/**
+ * Service class for managing InformationSystem resources.
+ */
+@Service
+public class InformationSystemService {
+
+	private static final Logger log = LoggerFactory.getLogger(InformationSystemService.class);
+
+	
+	public void setUma(String umaToken) throws Exception {
+		log.debug("Set Uma: [umaToken={}]",umaToken);
+		SecretManagerProvider.instance.reset();
+		SecretManager secretManager = new SecretManager();
+		Secret secret = new JWTSecret(umaToken);
+		secretManager.addSecret(secret);
+		secretManager.set();
+		SecretManagerProvider.instance.set(secretManager);
+		
+	}
+	
+	
+	public List<Context> getAllContext(String context) throws Exception {
+		log.debug("GetAllContext: [context={}]",context);
+		ResourceRegistryClient resourceRegistryClient= ResourceRegistryClientFactory.create(context);
+		//List<Context> contexts=new ArrayList<>();
+		//contexts.add(new ContextImpl("/gcube"));
+				
+		List<Context>contexts=resourceRegistryClient.getAllContext();
+		log.debug("AllContext: {}",contexts);
+		return contexts;
+	}
+
+
+}
--- a/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/service/UserService.java
+++ b/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/service/UserService.java
@ -0,0 +1,151 @@
+package org.gcube.fullstackapps.informationsystemmonitor.service;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+
+import org.gcube.fullstackapps.informationsystemmonitor.config.Constants;
+import org.gcube.fullstackapps.informationsystemmonitor.security.AuthoritiesConstants;
+import org.gcube.fullstackapps.informationsystemmonitor.service.dto.AdminUserDTO;
+import org.gcube.fullstackapps.informationsystemmonitor.service.dto.RealmAccessDTO;
+import org.gcube.fullstackapps.informationsystemmonitor.service.dto.ResourceAccessDTO;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.security.authentication.AbstractAuthenticationToken;
+import org.springframework.security.oauth2.client.authentication.OAuth2AuthenticationToken;
+import org.springframework.security.oauth2.server.resource.authentication.JwtAuthenticationToken;
+import org.springframework.stereotype.Service;
+
+import com.nimbusds.jose.shaded.json.JSONArray;
+import com.nimbusds.jose.shaded.json.JSONObject;
+
+/**
+ * Service class for managing users.
+ */
+@Service
+public class UserService {
+
+	private static final Logger logger = LoggerFactory.getLogger(UserService.class);
+
+	/**
+	 * Returns the user from an OAuth 2.0 login or resource server with JWT.
+	 *
+	 * @param authToken the authentication token.
+	 * @return the user from the authentication.
+	 */
+	public AdminUserDTO getUserFromAuthentication(AbstractAuthenticationToken authToken) {
+		Map<String, Object> attributes;
+		if (authToken instanceof JwtAuthenticationToken) {
+			logger.debug("AuthToken is a JwtAuthenticationToken");
+			attributes = ((JwtAuthenticationToken) authToken).getTokenAttributes();
+		} else if (authToken instanceof OAuth2AuthenticationToken) {
+			logger.debug("AuthToken is a OAuth2AuthenticationToken");
+			OAuth2AuthenticationToken oauth2Token = ((OAuth2AuthenticationToken) authToken);
+			attributes = oauth2Token.getPrincipal().getAttributes();
+		} else {
+			throw new IllegalArgumentException("AuthenticationToken is not OAuth2 or JWT!");
+		}
+		logger.debug("Attributes: {}", attributes);
+		AdminUserDTO user = getUser(attributes);
+		Set<String> authorities= new HashSet<>();
+		authorities.add(AuthoritiesConstants.ADMIN);
+		user.setAuthorities(authorities);
+		//user.setAuthorities(
+		//   authToken.getAuthorities().stream().map(GrantedAuthority::getAuthority).collect(Collectors.toSet()));
+		return user;
+	}
+
+	private static AdminUserDTO getUser(Map<String, Object> details) {
+		AdminUserDTO user = new AdminUserDTO();
+		Boolean activated = Boolean.TRUE;
+		String sub = String.valueOf(details.get("sub"));
+		String username = null;
+		if (details.get("preferred_username") != null) {
+			username = ((String) details.get("preferred_username")).toLowerCase();
+		}
+		// handle resource server JWT, where sub claim is email and uid is ID
+		if (details.get("uid") != null) {
+			user.setId((String) details.get("uid"));
+			user.setLogin(sub);
+		} else {
+			user.setId(sub);
+		}
+		if (username != null) {
+			user.setLogin(username);
+		} else if (user.getLogin() == null) {
+			user.setLogin(user.getId());
+		}
+		if (details.get("given_name") != null) {
+			user.setFirstName((String) details.get("given_name"));
+		} else if (details.get("name") != null) {
+			user.setFirstName((String) details.get("name"));
+		}
+		if (details.get("family_name") != null) {
+			user.setLastName((String) details.get("family_name"));
+		}
+		if (details.get("email_verified") != null) {
+			activated = (Boolean) details.get("email_verified");
+		}
+		if (details.get("email") != null) {
+			user.setEmail(((String) details.get("email")).toLowerCase());
+		} else if (sub.contains("|") && (username != null && username.contains("@"))) {
+			// special handling for Auth0
+			user.setEmail(username);
+		} else {
+			user.setEmail(sub);
+		}
+		if (details.get("langKey") != null) {
+			user.setLangKey((String) details.get("langKey"));
+		} else if (details.get("locale") != null) {
+			// trim off country code if it exists
+			String locale = (String) details.get("locale");
+			if (locale.contains("_")) {
+				locale = locale.substring(0, locale.indexOf('_'));
+			} else if (locale.contains("-")) {
+				locale = locale.substring(0, locale.indexOf('-'));
+			}
+			user.setLangKey(locale.toLowerCase());
+		} else {
+			// set langKey to default if not specified by IdP
+			user.setLangKey(Constants.DEFAULT_LANGUAGE);
+		}
+		if (details.get("picture") != null) {
+			user.setImageUrl((String) details.get("picture"));
+		}
+
+		if (details.get("realm_access") != null) {
+			//com.nimbusds.jose.shaded.json.
+			JSONObject realmAccessJSON=(JSONObject)details.get("realm_access");
+			JSONArray rolesJSON=(JSONArray)realmAccessJSON.get("roles");
+			ArrayList<String> roles=new ArrayList<>();
+			for(int i=0;i<rolesJSON.size();i++) {
+				roles.add((String)rolesJSON.get(i));
+			}
+			
+			RealmAccessDTO realmAccessDTO=new RealmAccessDTO(roles);
+			user.setRealmAccessDTO(realmAccessDTO);
+		}
+
+		if (details.get("resource_access") != null) {
+			JSONObject resourceAccessJSON=(JSONObject)details.get("resource_access");
+			logger.debug("ResourceAccess KeySet: {}",resourceAccessJSON.keySet());
+			LinkedHashMap<String, ArrayList<String>> resourceAccess=new LinkedHashMap<>();
+			for(String key: resourceAccessJSON.keySet()) {
+				JSONObject valueJSON=(JSONObject)resourceAccessJSON.get(key);
+				JSONArray rolesJSON=(JSONArray) valueJSON.get("roles");
+				ArrayList<String> roles=new ArrayList<>();
+				for(int i=0;i<rolesJSON.size();i++) {
+					roles.add((String)rolesJSON.get(i));
+				}
+				resourceAccess.put(key, roles);
+			}
+			ResourceAccessDTO resourceAccessDTO=new ResourceAccessDTO(resourceAccess);
+			user.setResourceAccessDTO(resourceAccessDTO);
+		}
+
+		user.setActivated(activated);
+		return user;
+	}
+}
--- a/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/service/dto/AdminUserDTO.java
+++ b/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/service/dto/AdminUserDTO.java
@ -0,0 +1,154 @@
+package org.gcube.fullstackapps.informationsystemmonitor.service.dto;
+
+import java.io.Serializable;
+import java.util.Arrays;
+import java.util.Set;
+
+import javax.validation.constraints.Email;
+import javax.validation.constraints.NotBlank;
+import javax.validation.constraints.Pattern;
+import javax.validation.constraints.Size;
+
+import org.gcube.fullstackapps.informationsystemmonitor.config.Constants;
+
+/**
+ * A DTO representing a user, with his authorities.
+ */
+public class AdminUserDTO implements Serializable {
+
+	private static final long serialVersionUID = 1L;
+
+	private String id;
+
+	private Set<String> authorities;
+
+	@NotBlank
+	@Pattern(regexp = Constants.LOGIN_REGEX)
+	@Size(min = 1, max = 50)
+	private String login;
+
+	@Size(max = 50)
+	private String firstName;
+
+	@Size(max = 50)
+	private String lastName;
+
+	@Email
+	@Size(min = 5, max = 254)
+	private String email;
+
+	@Size(max = 256)
+	private String imageUrl;
+
+	private boolean activated = false;
+
+	@Size(min = 2, max = 10)
+	private String langKey;
+
+	private RealmAccessDTO realmAccessDTO;
+
+	private ResourceAccessDTO resourceAccessDTO;
+
+	// private Set<String> authorities;
+
+	public String getId() {
+		return id;
+	}
+
+	public void setId(String id) {
+		this.id = id;
+	}
+
+	public Set<String> getAuthorities() {
+		return authorities;
+	}
+
+	public void setAuthorities(Set<String> authorities) {
+		this.authorities = authorities;
+	}
+
+	public String getLogin() {
+		return login;
+	}
+
+	public void setLogin(String login) {
+		this.login = login;
+	}
+
+	public String getFirstName() {
+		return firstName;
+	}
+
+	public void setFirstName(String firstName) {
+		this.firstName = firstName;
+	}
+
+	public String getLastName() {
+		return lastName;
+	}
+
+	public void setLastName(String lastName) {
+		this.lastName = lastName;
+	}
+
+	public String getEmail() {
+		return email;
+	}
+
+	public void setEmail(String email) {
+		this.email = email;
+	}
+
+	public String getImageUrl() {
+		return imageUrl;
+	}
+
+	public void setImageUrl(String imageUrl) {
+		this.imageUrl = imageUrl;
+	}
+
+	public boolean isActivated() {
+		return activated;
+	}
+
+	public void setActivated(boolean activated) {
+		this.activated = activated;
+	}
+
+	public String getLangKey() {
+		return langKey;
+	}
+
+	public void setLangKey(String langKey) {
+		this.langKey = langKey;
+	}
+
+	public static long getSerialversionuid() {
+		return serialVersionUID;
+	}
+
+	public RealmAccessDTO getRealmAccessDTO() {
+		return realmAccessDTO;
+	}
+
+	public void setRealmAccessDTO(RealmAccessDTO realmAccessDTO) {
+		this.realmAccessDTO = realmAccessDTO;
+	}
+
+	public ResourceAccessDTO getResourceAccessDTO() {
+		return resourceAccessDTO;
+	}
+
+	public void setResourceAccessDTO(ResourceAccessDTO resourceAccessDTO) {
+		this.resourceAccessDTO = resourceAccessDTO;
+	}
+
+	@Override
+	public String toString() {
+		return "AdminUserDTO [id=" + id + ", authorities=" + authorities + ", login=" + login + ", firstName="
+				+ firstName + ", lastName=" + lastName + ", email=" + email + ", imageUrl=" + imageUrl + ", activated="
+				+ activated + ", langKey=" + langKey + ", realmAccessDTO=" + realmAccessDTO + ", resourceAccessDTO="
+				+ resourceAccessDTO + "]";
+	}
+
+}
--- a/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/service/dto/RealmAccessDTO.java
+++ b/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/service/dto/RealmAccessDTO.java
@ -0,0 +1,20 @@
+package org.gcube.fullstackapps.informationsystemmonitor.service.dto;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class RealmAccessDTO implements Serializable {
+
+	private static final long serialVersionUID = 1L;
+
+	private ArrayList<String> roles;
+
+}
--- a/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/service/dto/ResourceAccessDTO.java
+++ b/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/service/dto/ResourceAccessDTO.java
@ -0,0 +1,20 @@
+package org.gcube.fullstackapps.informationsystemmonitor.service.dto;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class ResourceAccessDTO implements Serializable {
+
+	private static final long serialVersionUID = 1L;
+
+	private LinkedHashMap<String, ArrayList<String>> resourceAccess;
+
+}
--- a/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/service/dto/TestDialogDTO.java
+++ b/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/service/dto/TestDialogDTO.java
@ -0,0 +1,17 @@
+package org.gcube.fullstackapps.informationsystemmonitor.service.dto;
+
+import java.io.Serializable;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class TestDialogDTO implements Serializable {
+	
+	private static final long serialVersionUID = 1L;
+	private String status;
+}
+
--- a/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/service/dto/UmaResponseDTO.java
+++ b/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/service/dto/UmaResponseDTO.java
@ -0,0 +1,25 @@
+package org.gcube.fullstackapps.informationsystemmonitor.service.dto;
+
+import java.io.Serializable;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class UmaResponseDTO implements Serializable {
+
+	private static final long serialVersionUID = 1L;
+
+	private boolean upgraded;
+	private String access_token;
+	private int expires_in;
+	private int refresh_expires_in;
+	private String refresh_token;
+	private String token_type;
+	private int not_before_policy;	
+	
+}
--- a/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/service/dto/UserDTO.java
+++ b/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/service/dto/UserDTO.java
@ -0,0 +1,40 @@
+package org.gcube.fullstackapps.informationsystemmonitor.service.dto;
+
+import java.io.Serializable;
+
+/**
+ * A DTO representing a user, with only the public attributes.
+ */
+public class UserDTO implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    private String id;
+
+    private String login;
+
+    public String getId() {
+        return id;
+    }
+
+    public void setId(String id) {
+        this.id = id;
+    }
+
+    public String getLogin() {
+        return login;
+    }
+
+    public void setLogin(String login) {
+        this.login = login;
+    }
+
+    // prettier-ignore
+    @Override
+    public String toString() {
+        return "UserDTO{" +
+            "id='" + id + '\'' +
+            ", login='" + login + '\'' +
+            "}";
+    }
+}
--- a/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/service/dto/package-info.java
+++ b/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/service/dto/package-info.java
@ -0,0 +1,4 @@
+/**
+ * Data Transfer Objects.
+ */
+package org.gcube.fullstackapps.informationsystemmonitor.service.dto;
--- a/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/service/package-info.java
+++ b/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/service/package-info.java
@ -0,0 +1,4 @@
+/**
+ * Service layer beans.
+ */
+package org.gcube.fullstackapps.informationsystemmonitor.service;
--- a/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/web/filter/OAuth2RefreshTokensWebFilter.java
+++ b/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/web/filter/OAuth2RefreshTokensWebFilter.java
@ -0,0 +1,87 @@
+package org.gcube.fullstackapps.informationsystemmonitor.web.filter;
+
+import java.io.IOException;
+import javax.servlet.FilterChain;
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.security.oauth2.client.OAuth2AuthorizeRequest;
+import org.springframework.security.oauth2.client.OAuth2AuthorizedClient;
+import org.springframework.security.oauth2.client.OAuth2AuthorizedClientManager;
+import org.springframework.security.oauth2.client.authentication.OAuth2AuthenticationToken;
+import org.springframework.security.oauth2.client.registration.ClientRegistrationRepository;
+import org.springframework.security.oauth2.client.web.DefaultOAuth2AuthorizationRequestResolver;
+import org.springframework.security.oauth2.client.web.OAuth2AuthorizationRequestRedirectFilter;
+import org.springframework.security.oauth2.client.web.OAuth2AuthorizationRequestResolver;
+import org.springframework.security.oauth2.client.web.OAuth2AuthorizedClientRepository;
+import org.springframework.security.oauth2.core.endpoint.OAuth2AuthorizationRequest;
+import org.springframework.security.web.DefaultRedirectStrategy;
+import org.springframework.security.web.RedirectStrategy;
+import org.springframework.stereotype.Component;
+import org.springframework.web.filter.OncePerRequestFilter;
+
+/**
+ * Refresh oauth2 tokens.
+ */
+@Component
+public class OAuth2RefreshTokensWebFilter extends OncePerRequestFilter {
+
+    private final OAuth2AuthorizedClientManager clientManager;
+    private final OAuth2AuthorizedClientRepository authorizedClientRepository;
+    private final OAuth2AuthorizationRequestResolver authorizationRequestResolver;
+    private final RedirectStrategy authorizationRedirectStrategy = new DefaultRedirectStrategy();
+
+    public OAuth2RefreshTokensWebFilter(
+        OAuth2AuthorizedClientManager clientManager,
+        OAuth2AuthorizedClientRepository authorizedClientRepository,
+        ClientRegistrationRepository clientRegistrationRepository
+    ) {
+        this.clientManager = clientManager;
+        this.authorizedClientRepository = authorizedClientRepository;
+        this.authorizationRequestResolver =
+            new DefaultOAuth2AuthorizationRequestResolver(
+                clientRegistrationRepository,
+                OAuth2AuthorizationRequestRedirectFilter.DEFAULT_AUTHORIZATION_REQUEST_BASE_URI
+            );
+    }
+
+    @Override
+    public void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
+        throws IOException, ServletException {
+        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
+        
+        
+        if ((authentication instanceof OAuth2AuthenticationToken)) {
+            try {
+                OAuth2AuthorizedClient authorizedClient = authorizedClient((OAuth2AuthenticationToken) authentication);
+                //logger.debug("Oauth2RefreshTokensWebFilter: "+authorizedClient.getRefreshToken().getTokenValue());
+                this.authorizedClientRepository.saveAuthorizedClient(authorizedClient, authentication, request, response);
+            } catch (Exception e) {
+                OAuth2AuthorizationRequest authorizationRequest = this.authorizationRequestResolver.resolve(request);
+                if (authorizationRequest != null) {
+                    this.authorizationRedirectStrategy.sendRedirect(request, response, authorizationRequest.getAuthorizationRequestUri());
+                    return;
+                }
+            }
+        }
+
+        filterChain.doFilter(request, response);
+    }
+
+    private OAuth2AuthorizedClient authorizedClient(OAuth2AuthenticationToken oauth2Authentication) {
+        String clientRegistrationId = oauth2Authentication.getAuthorizedClientRegistrationId();
+        OAuth2AuthorizeRequest request = OAuth2AuthorizeRequest
+            .withClientRegistrationId(clientRegistrationId)
+            .principal(oauth2Authentication)
+            .build();
+        if (clientManager == null) {
+            throw new IllegalStateException(
+                "No OAuth2AuthorizedClientManager bean was found. Did you include the " +
+                "org.springframework.boot:spring-boot-starter-oauth2-client dependency?"
+            );
+        }
+        return clientManager.authorize(request);
+    }
+}
--- a/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/web/rest/AccountResource.java
+++ b/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/web/rest/AccountResource.java
@ -0,0 +1,97 @@
+package org.gcube.fullstackapps.informationsystemmonitor.web.rest;
+
+import java.security.Principal;
+
+import javax.servlet.http.HttpServletRequest;
+
+import org.gcube.fullstackapps.informationsystemmonitor.config.TokenManager;
+import org.gcube.fullstackapps.informationsystemmonitor.service.UserService;
+import org.gcube.fullstackapps.informationsystemmonitor.service.dto.AdminUserDTO;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.security.authentication.AbstractAuthenticationToken;
+import org.springframework.security.oauth2.client.authentication.OAuth2AuthenticationToken;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.util.UriUtils;
+
+import lombok.RequiredArgsConstructor;
+
+/**
+ * REST controller for managing the current user's account.
+ */
+@RestController
+@RequestMapping("/api")
+@RequiredArgsConstructor
+public class AccountResource {
+
+    private static class AccountResourceException extends RuntimeException {
+
+        private static final long serialVersionUID = 1L;
+
+        private AccountResourceException(String message) {
+            super(message);
+        }
+    }
+
+	
+    private final Logger log = LoggerFactory.getLogger(AccountResource.class);
+
+    private final TokenManager umaManager;
+    private final UserService userService;    
+    
+    /**
+     * {@code GET  /account} : get the current user.
+     *
+     * @param principal the current user; resolves to {@code null} if not authenticated.
+     * @return the current user.
+     * @throws AccountResourceException {@code 500 (Internal Server Error)} if the user couldn't be returned.
+     */
+    @GetMapping("/account")
+    public AdminUserDTO getAccount(Principal principal) {   	
+    	if (principal instanceof AbstractAuthenticationToken) {
+            return userService.getUserFromAuthentication((AbstractAuthenticationToken) principal);
+        } else {
+            throw new AccountResourceException("User could not be found");
+        }
+    }
+
+    /**
+     * {@code GET  /authenticate} : check if the user is authenticated, and return its login.
+     *
+     * @param request the HTTP request.
+     * @return the login if the user is authenticated.
+     */
+    @GetMapping("/authenticate")
+    public String isAuthenticated(HttpServletRequest request) {
+        log.debug("REST request to check if the current user is authenticated");
+        return request.getRemoteUser();
+    }
+    
+  
+    @GetMapping("/idtoken")
+    public String idtoken(OAuth2AuthenticationToken token) {
+        log.debug("REST request to check token: {}",token);
+        return token.toString();
+    }
+    
+    @GetMapping("/accesstoken")
+    public String accesstoken() {
+    	log.debug("Request access token");
+    	String accessToken=umaManager.getAccessToken();
+        return accessToken;
+    }
+    
+
+    @GetMapping("/umatoken")
+    public String umatoken() {
+    	log.debug("Request uma token");
+    	String context=UriUtils.encode("/gcube", "UTF-8");
+    	String umaToken=umaManager.getUmaToken(context);   	
+    	return umaToken;
+    }
+
+  
+     
+}
--- a/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/web/rest/AuthInfoResource.java
+++ b/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/web/rest/AuthInfoResource.java
@ -0,0 +1,52 @@
+package org.gcube.fullstackapps.informationsystemmonitor.web.rest;
+
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * Resource to return information about OIDC properties
+ */
+@RestController
+@RequestMapping("/api")
+public class AuthInfoResource {
+
+    @Value("${spring.security.oauth2.client.provider.oidc.issuer-uri:}")
+    private String issuer;
+
+    @Value("${spring.security.oauth2.client.registration.oidc.client-id:}")
+    private String clientId;
+
+    @GetMapping("/auth-info")
+    public AuthInfoVM getAuthInfo() {
+        return new AuthInfoVM(issuer, clientId);
+    }
+
+    class AuthInfoVM {
+
+        private String issuer;
+        private String clientId;
+
+        AuthInfoVM(String issuer, String clientId) {
+            this.issuer = issuer;
+            this.clientId = clientId;
+        }
+
+        public String getIssuer() {
+            return this.issuer;
+        }
+
+        public void setIssuer(String issuer) {
+            this.issuer = issuer;
+        }
+
+        public String getClientId() {
+            return clientId;
+        }
+
+        public void setClientId(String clientId) {
+            this.clientId = clientId;
+        }
+    }
+}
--- a/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/web/rest/ClientForwardController.java
+++ b/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/web/rest/ClientForwardController.java
@ -0,0 +1,17 @@
+package org.gcube.fullstackapps.informationsystemmonitor.web.rest;
+
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.GetMapping;
+
+@Controller
+public class ClientForwardController {
+
+    /**
+     * Forwards any unmapped paths (except those containing a period) to the client {@code index.html}.
+     * @return forward to client {@code index.html}.
+     */
+    @GetMapping(value = "/**/{path:[^\\.]*}")
+    public String forward() {
+        return "forward:/";
+    }
+}
--- a/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/web/rest/ContextResource.java
+++ b/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/web/rest/ContextResource.java
@ -0,0 +1,79 @@
+package org.gcube.fullstackapps.informationsystemmonitor.web.rest;
+
+import java.util.ArrayList;
+
+import org.gcube.fullstackapps.informationsystemmonitor.service.ContextService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.security.oauth2.client.OAuth2AuthorizedClient;
+import org.springframework.security.oauth2.client.OAuth2AuthorizedClientService;
+import org.springframework.security.oauth2.client.authentication.OAuth2AuthenticationToken;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.util.UriUtils;
+
+import lombok.RequiredArgsConstructor;
+
+/**
+ * ScopesDiscoveryResource controller
+ */
+@RestController
+@RequestMapping("/api/context")
+@RequiredArgsConstructor
+public class ContextResource {
+
+    private final Logger log = LoggerFactory.getLogger(ContextResource.class);
+
+    private final ContextService contextService;
+
+    private final OAuth2AuthorizedClientService authorizedClientService;
+
+    
+   
+    /**
+     * GET all
+     */
+    @GetMapping("/all")
+    public ArrayList<String> all() {
+    	log.debug("Request Scope Discovery");
+    	OAuth2AuthenticationToken oAuth2AuthenticationToken=(OAuth2AuthenticationToken) SecurityContextHolder.getContext().getAuthentication();
+    	log.debug("OAuth2AuthenticationToken: {}",oAuth2AuthenticationToken);
+    	
+    	OAuth2AuthorizedClient client = authorizedClientService
+                  .loadAuthorizedClient(oAuth2AuthenticationToken.getAuthorizedClientRegistrationId(), oAuth2AuthenticationToken.getName());
+    	log.debug("AccessToken: {}",client.getAccessToken().getTokenValue());
+    	
+        /*String userInfoEndpointUri = client.getClientRegistration().getProviderDetails().getUserInfoEndpoint().getUri();
+
+          if (!StringUtils.isEmpty(userInfoEndpointUri)) {
+              HttpHeaders headers = new HttpHeaders();
+              headers.add(HttpHeaders.AUTHORIZATION, "Bearer " + client.getAccessToken().getTokenValue());
+              HttpEntity entity = new HttpEntity("", headers);
+
+              RestTemplate restTemplate = new RestTemplate();
+              ResponseEntity<Map> response = restTemplate.exchange(userInfoEndpointUri, HttpMethod.GET, entity, Map.class);
+              Map userAttributes = response.getBody();
+
+              model.addAttribute("name", userAttributes.get("name"));
+          }*/
+
+    	
+    	
+    	return contextService.all();
+    }
+    
+    @GetMapping("/encode")
+    public String encodeContext() {
+    	String contextEncoded=UriUtils.encode("/gcube", "UTF-8");
+    	return contextEncoded;
+    }
+    
+    @GetMapping("/decode")
+    public String decodeContext() {
+    	String contextEncoded=UriUtils.decode("%2Fgcube", "UTF-8");
+    	return contextEncoded;
+    }
+    
+}
--- a/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/web/rest/InformationSystemResource.java
+++ b/src/main/java/org/gcube/fullstackapps/informationsystemmonitor/web/rest/InformationSystemResource.java
@ -0,0 +1,60 @@
+package org.gcube.fullstackapps.informationsystemmonitor.web.rest;
+
+import java.util.List;
+
+import org.gcube.com.fasterxml.jackson.databind.ObjectMapper;
+import org.gcube.fullstackapps.informationsystemmonitor.config.TokenManager;
+import org.gcube.fullstackapps.informationsystemmonitor.service.InformationSystemService;
+import org.gcube.informationsystem.contexts.reference.entities.Context;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.util.UriUtils;
+
+import lombok.RequiredArgsConstructor;
+import tech.jhipster.web.util.HeaderUtil;
+
+/**
+ * REST controller for managing the current user's account.
+ */
+@RestController
+@RequestMapping("/api/is")
+@RequiredArgsConstructor
+public class InformationSystemResource {
+
+	private final Logger log = LoggerFactory.getLogger(InformationSystemResource.class);
+
+	@Value("${jhipster.clientApp.name}")
+	private String applicationName;
+
+	private final TokenManager tokenManager;
+	private final InformationSystemService informationSystemService;
+
+	@GetMapping("/allcontext")
+	public ResponseEntity<String> allcontext() {
+		log.debug("Request uma token");
+		String rootContext = tokenManager.getRootContext();
+		String contextEncoded = UriUtils.encode(rootContext, "UTF-8");
+		String umaToken = tokenManager.getUmaToken(contextEncoded);
+
+		try {
+			informationSystemService.setUma(umaToken);
+			List<Context> contexts = informationSystemService.getAllContext(rootContext);
+			ObjectMapper om = new ObjectMapper();
+		    String sc =  om.writeValueAsString(contexts);
+			return ResponseEntity.ok().body(sc);		
+			
+			//return new ResponseEntity<List<Context>>(contexts, HttpStatus.OK);
+		} catch (Exception e) {
+			log.error(e.getLocalizedMessage(), e);
+			return ResponseEntity.noContent()
+					.headers(HeaderUtil.createAlert(applicationName, e.getLocalizedMessage(), "")).build();
+		}
+
+	}
+
+}
--- a/Show More
+++ b/Show More