add notification microservice

dmp-backend/notification-service/Dockerfile

@@ -0,0 +1,27 @@
+####################################### Build stage #######################################
+FROM maven:3.9-eclipse-temurin-17-alpine AS build-stage
+
+ARG CITE_MAVEN_ACCOUNT_USR
+ARG CITE_MAVEN_ACCOUNT_PSW
+
+COPY pom.xml /build/
+COPY notification /build/notification/
+COPY notification-web /build/notification-web/
+COPY settings.xml /root/.m2/settings.xml
+RUN rm -f /build/notification-web/src/main/resources/config/app.env
+RUN rm -f /build/notification-web/src/main/resources/config/*-dev.yml
+RUN rm -f /build/notification-web/src/main/resources/logging/*.xml
+RUN rm -f /build/notification-web/src/main/resources/certificates/*.crt
+
+WORKDIR /build/
+
+RUN mvn -Dserver.username=${CITE_MAVEN_ACCOUNT_USR} -Dserver.password=${CITE_MAVEN_ACCOUNT_PSW} dependency:go-offline 
+# Build project
+RUN mvn -Dserver.username=${CITE_MAVEN_ACCOUNT_USR} -Dserver.password=${CITE_MAVEN_ACCOUNT_PSW} clean package
+
+######################################## Run Stage ########################################
+FROM eclipse-temurin:17-jre-ubi9-minimal
+
+COPY --from=build-stage /build/notification-web/target/sti-viewer-notification-web.jar /app/sti-viewer-notification-web.jar
+
+ENTRYPOINT ["java","-Dspring.config.additional-location=file:/config/","-Dspring.profiles.active=${PROFILE}","-Djava.security.egd=file:/dev/./urandom","-jar","/app/sti-viewer-notification-web.jar"]

dmp-backend/notification-service/notification-web/pom.xml

@@ -0,0 +1,88 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+		 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+		 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+
+	<parent>
+		<groupId>gr.cite</groupId>
+		<artifactId>notification-service-parent</artifactId>
+		<version>1.0.0</version>
+		<relativePath>../pom.xml</relativePath>
+	</parent>
+
+	<artifactId>notification-web</artifactId>
+	<packaging>jar</packaging>
+
+	<properties>
+		<maven.compiler.source>11</maven.compiler.source>
+		<maven.compiler.target>11</maven.compiler.target>
+	</properties>
+
+	<dependencies>
+		<dependency>
+			<groupId>org.springframework.boot</groupId>
+			<artifactId>spring-boot-starter-web</artifactId>
+		</dependency>
+		<dependency>
+			<groupId>org.springframework.boot</groupId>
+			<artifactId>spring-boot-starter-validation</artifactId>
+			<version>2.6.4</version>
+		</dependency>
+
+		<dependency>
+			<groupId>org.postgresql</groupId>
+			<artifactId>postgresql</artifactId>
+		</dependency>
+		<dependency>
+			<groupId>org.hibernate</groupId>
+			<artifactId>hibernate-core</artifactId>
+		</dependency>
+
+		<dependency>
+			<groupId>gr.cite</groupId>
+			<artifactId>notification</artifactId>
+			<version>1.0.0</version>
+		</dependency>
+		<dependency>
+			<groupId>gr.cite</groupId>
+			<artifactId>oidc-authz</artifactId>
+			<version>1.0.0</version>
+		</dependency>
+		<dependency>
+			<groupId>gr.cite</groupId>
+			<artifactId>cache</artifactId>
+			<version>1.0.0</version>
+		</dependency>
+		<dependency>
+			<groupId>gr.cite</groupId>
+			<artifactId>exceptions-web</artifactId>
+			<version>1.0.0</version>
+		</dependency>
+		<dependency>
+			<groupId>gr.cite</groupId>
+			<artifactId>cors-web</artifactId>
+			<version>1.0.0</version>
+		</dependency>
+		<dependency>
+			<groupId>org.springframework.boot</groupId>
+			<artifactId>spring-boot</artifactId>
+			<version>2.6.4</version>
+		</dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-web</artifactId>
+        </dependency>
+    </dependencies>
+
+	<build>
+		<finalName>argos-notification-web</finalName>
+		<plugins>
+			<plugin>
+				<groupId>org.springframework.boot</groupId>
+				<artifactId>spring-boot-maven-plugin</artifactId>
+			</plugin>
+		</plugins>
+	</build>
+
+</project>

dmp-backend/notification-service/notification-web/src/main/java/gr/cite/notification/web/NotificationApplication.java

@@ -0,0 +1,21 @@
+package gr.cite.notification.web;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.autoconfigure.domain.EntityScan;
+import org.springframework.context.annotation.ComponentScan;
+
+@SpringBootApplication
+@ComponentScan({
+		"gr.cite.notification",
+		"gr.cite.tools",
+		"gr.cite.commons"})
+@EntityScan({
+		"gr.cite.notification.data"})
+public class NotificationApplication {
+
+	public static void main(String[] args) {
+		SpringApplication.run(NotificationApplication.class, args);
+	}
+
+}

dmp-backend/notification-service/notification-web/src/main/java/gr/cite/notification/web/WebConfiguration.java

@@ -0,0 +1,40 @@
+package gr.cite.notification.web;
+
+import gr.cite.notification.web.scope.tenant.TenantInterceptor;
+import gr.cite.notification.web.scope.tenant.TenantScopeClaimInterceptor;
+import gr.cite.notification.web.scope.tenant.TenantScopeHeaderInterceptor;
+import gr.cite.notification.web.scope.user.UserInterceptor;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
+import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
+
+@Configuration
+public class WebConfiguration implements WebMvcConfigurer {
+    private final TenantInterceptor tenantInterceptor;
+    private final TenantScopeHeaderInterceptor scopeHeaderInterceptor;
+    private final TenantScopeClaimInterceptor scopeClaimInterceptor;
+    private final UserInterceptor userInterceptor;
+
+    @Autowired
+    public WebConfiguration(
+            TenantInterceptor tenantInterceptor,
+            TenantScopeHeaderInterceptor scopeHeaderInterceptor,
+            TenantScopeClaimInterceptor scopeClaimInterceptor,
+            UserInterceptor userInterceptor
+    ) {
+        this.tenantInterceptor = tenantInterceptor;
+        this.scopeHeaderInterceptor = scopeHeaderInterceptor;
+        this.scopeClaimInterceptor = scopeClaimInterceptor;
+        this.userInterceptor = userInterceptor;
+    }
+
+    @Override
+    public void addInterceptors(InterceptorRegistry registry) {
+        int order = 1;
+        registry.addWebRequestInterceptor(scopeHeaderInterceptor).order(order++);
+        registry.addWebRequestInterceptor(scopeClaimInterceptor).order(order++);
+        registry.addWebRequestInterceptor(userInterceptor).order(order++);
+        registry.addWebRequestInterceptor(tenantInterceptor).order(order++);
+    }
+}

dmp-backend/notification-service/notification-web/src/main/java/gr/cite/notification/web/authorization/OwnedAuthorizationHandler.java

@@ -0,0 +1,44 @@
+package gr.cite.notification.web.authorization;
+
+import gr.cite.commons.web.authz.handler.AuthorizationHandler;
+import gr.cite.commons.web.authz.handler.AuthorizationHandlerContext;
+import gr.cite.commons.web.authz.policy.AuthorizationRequirement;
+import gr.cite.commons.web.oidc.principal.MyPrincipal;
+import gr.cite.notification.authorization.OwnedAuthorizationRequirement;
+import gr.cite.notification.authorization.OwnedResource;
+import gr.cite.notification.common.scope.user.UserScope;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+@Component("ownedAuthorizationHandler")
+public class OwnedAuthorizationHandler extends AuthorizationHandler<OwnedAuthorizationRequirement> {
+
+	private final UserScope userScope;
+
+	@Autowired
+	public OwnedAuthorizationHandler(UserScope userScope) {
+		this.userScope = userScope;
+	}
+
+	@Override
+	public int handleRequirement(AuthorizationHandlerContext context, Object resource, AuthorizationRequirement requirement) {
+		OwnedAuthorizationRequirement req = (OwnedAuthorizationRequirement) requirement;
+
+		OwnedResource rs = (OwnedResource) resource;
+
+		boolean isAuthenticated = ((MyPrincipal) context.getPrincipal()).isAuthenticated();
+		if (!isAuthenticated) return ACCESS_NOT_DETERMINED;
+
+		if (this.userScope.getUserIdSafe() == null) return ACCESS_NOT_DETERMINED;
+
+		if (rs != null && rs.getUserIds() != null && rs.getUserIds().contains(this.userScope.getUserIdSafe())) return ACCESS_GRANTED;
+
+		return ACCESS_NOT_DETERMINED;
+	}
+
+	@Override
+	public Class<? extends AuthorizationRequirement> supporting() {
+		return OwnedAuthorizationRequirement.class;
+	}
+
+}

dmp-backend/notification-service/notification-web/src/main/java/gr/cite/notification/web/config/AppMessageSourceConfiguration.java

@@ -0,0 +1,25 @@
+package gr.cite.notification.web.config;
+
+import org.springframework.context.MessageSource;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.support.ReloadableResourceBundleMessageSource;
+import org.springframework.validation.beanvalidation.LocalValidatorFactoryBean;
+
+@Configuration
+public class AppMessageSourceConfiguration {
+	@Bean
+	public MessageSource messageSource() {
+		ReloadableResourceBundleMessageSource messageSource = new ReloadableResourceBundleMessageSource();
+		messageSource.setBasename("classpath:messages/messages");
+		messageSource.setDefaultEncoding("UTF-8");
+		return messageSource;
+	}
+
+	@Bean
+	public LocalValidatorFactoryBean getValidator() {
+		LocalValidatorFactoryBean bean = new LocalValidatorFactoryBean();
+		bean.setValidationMessageSource(messageSource());
+		return bean;
+	}
+}

dmp-backend/notification-service/notification-web/src/main/java/gr/cite/notification/web/config/SecurityConfiguration.java

@@ -0,0 +1,141 @@
+package gr.cite.notification.web.config;
+
+import gr.cite.commons.web.authz.handler.AuthorizationHandler;
+import gr.cite.commons.web.authz.handler.PermissionClientAuthorizationHandler;
+import gr.cite.commons.web.authz.policy.AuthorizationRequirement;
+import gr.cite.commons.web.authz.policy.AuthorizationRequirementMapper;
+import gr.cite.commons.web.authz.policy.AuthorizationResource;
+import gr.cite.commons.web.authz.policy.resolver.AuthorizationPolicyConfigurer;
+import gr.cite.commons.web.authz.policy.resolver.AuthorizationPolicyResolverStrategy;
+import gr.cite.commons.web.oidc.configuration.WebSecurityProperties;
+import gr.cite.notification.authorization.OwnedAuthorizationRequirement;
+import gr.cite.notification.authorization.OwnedResource;
+import gr.cite.notification.web.authorization.OwnedAuthorizationHandler;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.security.authentication.AuthenticationManagerResolver;
+import org.springframework.security.config.annotation.web.builders.HttpSecurity;
+import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
+import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
+import org.springframework.security.config.http.SessionCreationPolicy;
+import org.springframework.security.web.authentication.preauth.AbstractPreAuthenticatedProcessingFilter;
+
+import javax.servlet.Filter;
+import javax.servlet.http.HttpServletRequest;
+import java.util.List;
+import java.util.Set;
+
+@Configuration
+@EnableWebSecurity
+public class SecurityConfiguration extends WebSecurityConfigurerAdapter {
+
+	private final WebSecurityProperties webSecurityProperties;
+	private final AuthenticationManagerResolver<HttpServletRequest> authenticationManagerResolver;
+	private final Filter apiKeyFilter;
+	private final OwnedAuthorizationHandler ownedAuthorizationHandler;
+
+	@Autowired
+	public SecurityConfiguration(WebSecurityProperties webSecurityProperties,
+	                             @Qualifier("tokenAuthenticationResolver") AuthenticationManagerResolver<HttpServletRequest> authenticationManagerResolver,
+	                             @Qualifier("apiKeyFilter") Filter apiKeyFilter,
+	                             @Qualifier("ownedAuthorizationHandler") OwnedAuthorizationHandler ownedAuthorizationHandler) {
+		this.webSecurityProperties = webSecurityProperties;
+		this.authenticationManagerResolver = authenticationManagerResolver;
+		this.apiKeyFilter = apiKeyFilter;
+		this.ownedAuthorizationHandler = ownedAuthorizationHandler;
+	}
+
+	@Override
+	protected void configure(HttpSecurity http) throws Exception {
+		http
+				.csrf().disable()
+				.cors()
+				.and()
+				.addFilterBefore(apiKeyFilter, AbstractPreAuthenticatedProcessingFilter.class)
+				.authorizeRequests()
+				.antMatchers(buildAntPatterns(webSecurityProperties.getAllowedEndpoints())).anonymous()
+				.antMatchers(buildAntPatterns(webSecurityProperties.getAuthorizedEndpoints())).authenticated()
+				.and()
+				.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.NEVER)
+				.and()
+				.oauth2ResourceServer(oauth2 -> oauth2.authenticationManagerResolver(authenticationManagerResolver));
+	}
+
+	@Bean
+	AuthorizationPolicyConfigurer authorizationPolicyConfigurer() {
+		return new AuthorizationPolicyConfigurer() {
+
+			@Override
+			public AuthorizationPolicyResolverStrategy strategy() {
+				return AuthorizationPolicyResolverStrategy.STRICT_CONSENSUS_BASED;
+			}
+
+			//Here you can register your custom authorization handlers, which will get used as well as the existing ones
+			//This is optional and can be omitted
+			//If not set / set to null, only the default authorization handlers will be used
+			@Override
+			public List<AuthorizationHandler<? extends AuthorizationRequirement>> addCustomHandlers() {
+				return List.of(ownedAuthorizationHandler);
+			}
+
+			//Here you can register your custom authorization requirements (if any)
+			//This is optional and can be omitted
+			//If not set / set to null, only the default authorization requirements will be used
+			@Override
+			public List<? extends AuthorizationRequirement> extendRequirements() {
+				return List.of(
+//                        new TimeOfDayAuthorizationRequirement(new TimeOfDay("08:00","16:00"), true)
+				);
+			}
+
+			//Here you can select handlers you want to disable by providing the classes they are implemented by
+			//You can disable any handler (including any custom one)
+			//This is optional and can be omitted
+			//If not set / set to null, all the handlers will be invoked, based on their requirement support
+			//In the example below, the default client handler will be ignored by the resolver
+			@Override
+			public List<Class<? extends AuthorizationHandler<? extends AuthorizationRequirement>>> disableHandlers() {
+				return List.of(PermissionClientAuthorizationHandler.class);
+			}
+		};
+	}
+
+	@Bean
+	AuthorizationRequirementMapper authorizationRequirementMapper() {
+		return new AuthorizationRequirementMapper() {
+			@Override
+			public AuthorizationRequirement map(AuthorizationResource resource, boolean matchAll, String[] permissions) {
+				Class<?> type = resource.getClass();
+				if (!AuthorizationResource.class.isAssignableFrom(type)) throw new IllegalArgumentException("resource");
+
+				if (OwnedResource.class.equals(type)) {
+					return new OwnedAuthorizationRequirement();
+				}
+				throw new IllegalArgumentException("resource");
+			}
+		};
+	}
+
+	private String[] buildAntPatterns(Set<String> endpoints) {
+		if (endpoints == null) {
+			return new String[0];
+		}
+		return endpoints.stream()
+				.filter(endpoint -> endpoint != null && !endpoint.isBlank())
+				.map(endpoint -> "/" + stripUnnecessaryCharacters(endpoint) + "/**")
+				.toArray(String[]::new);
+	}
+
+	private String stripUnnecessaryCharacters(String endpoint) {
+		endpoint = endpoint.strip();
+		if (endpoint.startsWith("/")) {
+			endpoint = endpoint.substring(1);
+		}
+		if (endpoint.endsWith("/")) {
+			endpoint = endpoint.substring(0, endpoint.length() - 1);
+		}
+		return endpoint;
+	}
+}

dmp-backend/notification-service/notification-web/src/main/java/gr/cite/notification/web/controllers/InAppNotificationController.java

@@ -0,0 +1,169 @@
+package gr.cite.notification.web.controllers;
+
+import gr.cite.notification.audit.AuditableAction;
+import gr.cite.notification.authorization.AuthorizationFlags;
+import gr.cite.notification.common.enums.IsActive;
+import gr.cite.notification.common.enums.NotificationInAppTracking;
+import gr.cite.notification.common.scope.user.UserScope;
+import gr.cite.notification.data.InAppNotificationEntity;
+import gr.cite.notification.errorcode.ErrorThesaurusProperties;
+import gr.cite.notification.model.InAppNotification;
+import gr.cite.notification.model.Notification;
+import gr.cite.notification.model.builder.InAppNotificationBuilder;
+import gr.cite.notification.model.censorship.InAppNotificationCensor;
+import gr.cite.notification.query.InAppNotificationQuery;
+import gr.cite.notification.query.lookup.InAppNotificationLookup;
+import gr.cite.notification.service.inappnotification.InAppNotificationService;
+import gr.cite.notification.service.notification.NotificationService;
+import gr.cite.notification.web.model.QueryResult;
+import gr.cite.tools.auditing.AuditService;
+import gr.cite.tools.data.builder.BuilderFactory;
+import gr.cite.tools.data.censor.CensorFactory;
+import gr.cite.tools.data.query.QueryFactory;
+import gr.cite.tools.exception.MyApplicationException;
+import gr.cite.tools.exception.MyForbiddenException;
+import gr.cite.tools.exception.MyNotFoundException;
+import gr.cite.tools.fieldset.BaseFieldSet;
+import gr.cite.tools.fieldset.FieldSet;
+import gr.cite.tools.logging.LoggerService;
+import gr.cite.tools.logging.MapLogEntry;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.MessageSource;
+import org.springframework.context.i18n.LocaleContextHolder;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import javax.management.InvalidApplicationException;
+import javax.transaction.Transactional;
+import java.util.*;
+
+@RestController
+@RequestMapping(path = "api/notification/inapp-notification")
+public class InAppNotificationController {
+	private static final LoggerService logger = new LoggerService(LoggerFactory.getLogger(InAppNotificationController.class));
+
+	private final BuilderFactory builderFactory;
+	private final AuditService auditService;
+	private final NotificationService notificationService;
+	private final CensorFactory censorFactory;
+	private final QueryFactory queryFactory;
+	private final MessageSource messageSource;
+	private final InAppNotificationService inAppNotificationService;
+	private final UserScope userScope;
+	private final ErrorThesaurusProperties errors;
+
+	@Autowired
+	public InAppNotificationController(BuilderFactory builderFactory,
+									   AuditService auditService,
+									   NotificationService notificationService, CensorFactory censorFactory,
+									   QueryFactory queryFactory,
+									   MessageSource messageSource,
+									   InAppNotificationService inAppNotificationService, UserScope userScope, ErrorThesaurusProperties errors) {
+		this.builderFactory = builderFactory;
+		this.auditService = auditService;
+		this.notificationService = notificationService;
+		this.censorFactory = censorFactory;
+		this.queryFactory = queryFactory;
+		this.messageSource = messageSource;
+		this.inAppNotificationService = inAppNotificationService;
+		this.userScope = userScope;
+		this.errors = errors;
+	}
+
+	@PostMapping("query")
+	public QueryResult<InAppNotification> Query(@RequestBody InAppNotificationLookup lookup) throws MyApplicationException, MyForbiddenException, InvalidApplicationException {
+		logger.debug("querying {}", InAppNotification.class.getSimpleName());
+
+		this.censorFactory.censor(InAppNotificationCensor.class).censor(lookup.getProject());
+
+		UUID userId = this.userScope.getUserId();
+		if (userId == null) throw new MyForbiddenException(this.errors.getNonPersonPrincipal().getCode(), this.errors.getNonPersonPrincipal().getMessage());
+		InAppNotificationQuery query = lookup.enrich(this.queryFactory).userId(userId);
+		List<InAppNotificationEntity> data = query.collectAs(lookup.getProject());
+		List<InAppNotification> models = this.builderFactory.builder(InAppNotificationBuilder.class).build(lookup.getProject(), data);
+		long count = (lookup.getMetadata() != null && lookup.getMetadata().getCountAll()) ? query.count() : models.size();
+
+		this.auditService.track(AuditableAction.InApp_Notification_Query, "lookup", lookup);
+
+		return new QueryResult<>(models, count);
+	}
+
+	@GetMapping("{id}")
+	@Transactional
+	public InAppNotification Get(@PathVariable UUID id, FieldSet fieldSet, Locale locale) throws MyApplicationException, MyForbiddenException, MyNotFoundException {
+		logger.debug(new MapLogEntry("retrieving" + InAppNotification.class.getSimpleName()).And("id", id).And("fields", fieldSet));
+
+		this.censorFactory.censor(InAppNotificationCensor.class).censor(fieldSet);
+
+		InAppNotificationQuery query = this.queryFactory.query(InAppNotificationQuery.class).authorize(AuthorizationFlags.OwnerOrPermission).ids(id);
+		InAppNotification model = this.builderFactory.builder(InAppNotificationBuilder.class).authorize(AuthorizationFlags.OwnerOrPermission).build(fieldSet, query.firstAs(fieldSet));
+		if (model == null)
+			throw new MyNotFoundException(messageSource.getMessage("General_ItemNotFound", new Object[]{id, Notification.class.getSimpleName()}, LocaleContextHolder.getLocale()));
+
+		this.auditService.track(AuditableAction.InApp_Notification_Lookup, Map.ofEntries(
+				new AbstractMap.SimpleEntry<String, Object>("id", id),
+				new AbstractMap.SimpleEntry<String, Object>("fields", fieldSet)
+		));
+		//this.auditService.trackIdentity(AuditableAction.IdentityTracking_Action);
+
+		return model;
+	}
+
+	@PostMapping("{id}/read")
+	@Transactional
+	public ResponseEntity<String> persist(@PathVariable UUID id)
+	{
+		logger.debug(new MapLogEntry("marking as read").And("id", id));
+
+		this.inAppNotificationService.markAsRead(id);
+
+		this.auditService.track(AuditableAction.InApp_Notification_Read, Map.of("id", id));
+		//this.auditService.trackIdentity(AuditableAction.IdentityTracking_Action);
+		return ResponseEntity.ok("ok");
+	}
+
+	@PostMapping("read-all")
+	@Transactional
+	public ResponseEntity<String> MarkAsReadAllUserInAppNotification() throws InvalidApplicationException {
+		logger.debug(new MapLogEntry("marking as read all"));
+
+		UUID userId = this.userScope.getUserId();
+		if (userId == null) throw new MyForbiddenException(this.errors.getNonPersonPrincipal().getCode(), this.errors.getNonPersonPrincipal().getMessage());
+
+		this.inAppNotificationService.markAsReadAllUserNotification(userId);
+
+		this.auditService.track(AuditableAction.InApp_Notification_Read_All, Map.of("userId", userId));
+		return ResponseEntity.ok("ok");
+	}
+
+	@GetMapping("count-unread")
+	@Transactional
+	public ResponseEntity<Integer> CountUnread() throws InvalidApplicationException {
+		logger.debug("count-unread");
+
+		UUID userId = this.userScope.getUserId();
+		if (userId == null) throw new MyForbiddenException(this.errors.getNonPersonPrincipal().getCode(), this.errors.getNonPersonPrincipal().getMessage());
+
+		this.censorFactory.censor(InAppNotificationCensor.class).censor(new BaseFieldSet(InAppNotification.Field.ID));
+
+		InAppNotificationQuery query = this.queryFactory.query(InAppNotificationQuery.class).isActive(IsActive.Active).trackingState(NotificationInAppTracking.STORED).userId(userId);
+		int count = Math.toIntExact(query.count());
+
+		//this.auditService.trackIdentity(AuditableAction.IdentityTracking_Action);
+
+		return ResponseEntity.ok(count);
+	}
+
+	@DeleteMapping("{id}")
+	@Transactional
+	public void Delete(@PathVariable("id") UUID id) throws MyForbiddenException, InvalidApplicationException {
+		logger.debug(new MapLogEntry("deleting" + Notification.class.getSimpleName()).And("id", id));
+
+		this.notificationService.deleteAndSave(id);
+
+		this.auditService.track(AuditableAction.InApp_Notification_Delete, "id", id);
+
+		//this.auditService.trackIdentity(AuditableAction.IdentityTracking_Action);
+	}
+}

dmp-backend/notification-service/notification-web/src/main/java/gr/cite/notification/web/controllers/NotificationController.java

@@ -0,0 +1,127 @@
+package gr.cite.notification.web.controllers;
+
+import gr.cite.notification.audit.AuditableAction;
+import gr.cite.notification.authorization.AuthorizationFlags;
+import gr.cite.notification.data.NotificationEntity;
+import gr.cite.notification.model.Notification;
+import gr.cite.notification.model.SendNotificationResult;
+import gr.cite.notification.model.builder.NotificationBuilder;
+import gr.cite.notification.model.censorship.NotificationCensor;
+import gr.cite.notification.model.persist.NotificationPersist;
+import gr.cite.notification.query.NotificationQuery;
+import gr.cite.notification.query.lookup.NotificationLookup;
+import gr.cite.notification.service.notification.NotificationService;
+import gr.cite.notification.web.model.QueryResult;
+import gr.cite.tools.auditing.AuditService;
+import gr.cite.tools.data.builder.BuilderFactory;
+import gr.cite.tools.data.censor.CensorFactory;
+import gr.cite.tools.data.query.QueryFactory;
+import gr.cite.tools.exception.MyApplicationException;
+import gr.cite.tools.exception.MyForbiddenException;
+import gr.cite.tools.exception.MyNotFoundException;
+import gr.cite.tools.fieldset.FieldSet;
+import gr.cite.tools.logging.LoggerService;
+import gr.cite.tools.logging.MapLogEntry;
+import gr.cite.tools.validation.MyValidate;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.MessageSource;
+import org.springframework.context.i18n.LocaleContextHolder;
+import org.springframework.web.bind.annotation.*;
+
+import javax.management.InvalidApplicationException;
+import javax.transaction.Transactional;
+import java.util.*;
+
+@RestController
+@RequestMapping(path = "api/notification/notification")
+public class NotificationController {
+	private static final LoggerService logger = new LoggerService(LoggerFactory.getLogger(NotificationController.class));
+
+	private final BuilderFactory builderFactory;
+	private final AuditService auditService;
+	private final NotificationService notificationService;
+	private final CensorFactory censorFactory;
+	private final QueryFactory queryFactory;
+	private final MessageSource messageSource;
+
+	@Autowired
+	public NotificationController(BuilderFactory builderFactory,
+								  AuditService auditService,
+								  NotificationService notificationService, CensorFactory censorFactory,
+								  QueryFactory queryFactory,
+								  MessageSource messageSource) {
+		this.builderFactory = builderFactory;
+		this.auditService = auditService;
+		this.notificationService = notificationService;
+		this.censorFactory = censorFactory;
+		this.queryFactory = queryFactory;
+		this.messageSource = messageSource;
+	}
+
+	@PostMapping("query")
+	public QueryResult<Notification> Query(@RequestBody NotificationLookup lookup) throws MyApplicationException, MyForbiddenException {
+		logger.debug("querying {}", Notification.class.getSimpleName());
+
+		this.censorFactory.censor(NotificationCensor.class).censor(lookup.getProject());
+
+		NotificationQuery query = lookup.enrich(this.queryFactory).authorize(AuthorizationFlags.OwnerOrPermission);
+		List<NotificationEntity> data = query.collectAs(lookup.getProject());
+		List<Notification> models = this.builderFactory.builder(NotificationBuilder.class).authorize(AuthorizationFlags.OwnerOrPermission).build(lookup.getProject(), data);
+		long count = (lookup.getMetadata() != null && lookup.getMetadata().getCountAll()) ? query.count() : models.size();
+
+		this.auditService.track(AuditableAction.Notification_Query, "lookup", lookup);
+
+		return new QueryResult<>(models, count);
+	}
+
+	@GetMapping("{id}")
+	@Transactional
+	public Notification Get(@PathVariable UUID id, FieldSet fieldSet, Locale locale) throws MyApplicationException, MyForbiddenException, MyNotFoundException {
+		logger.debug(new MapLogEntry("retrieving" + Notification.class.getSimpleName()).And("id", id).And("fields", fieldSet));
+
+		this.censorFactory.censor(NotificationCensor.class).censor(fieldSet);
+
+		NotificationQuery query = this.queryFactory.query(NotificationQuery.class).authorize(AuthorizationFlags.OwnerOrPermission).ids(id);
+		Notification model = this.builderFactory.builder(NotificationBuilder.class).authorize(AuthorizationFlags.OwnerOrPermission).build(fieldSet, query.firstAs(fieldSet));
+		if (model == null)
+			throw new MyNotFoundException(messageSource.getMessage("General_ItemNotFound", new Object[]{id, Notification.class.getSimpleName()}, LocaleContextHolder.getLocale()));
+
+		this.auditService.track(AuditableAction.Notification_Lookup, Map.ofEntries(
+				new AbstractMap.SimpleEntry<String, Object>("id", id),
+				new AbstractMap.SimpleEntry<String, Object>("fields", fieldSet)
+		));
+		//this.auditService.trackIdentity(AuditableAction.IdentityTracking_Action);
+
+		return model;
+	}
+
+	@PostMapping("persist")
+	@Transactional
+	public Notification Persist(@MyValidate @RequestBody NotificationPersist model, FieldSet fieldSet) throws MyApplicationException, MyForbiddenException, MyNotFoundException, InvalidApplicationException {
+		logger.debug(new MapLogEntry("persisting" + Notification.class.getSimpleName()).And("model", model).And("fieldSet", fieldSet));
+
+		Notification persisted = this.notificationService.persist(model, fieldSet);
+
+		this.auditService.track(AuditableAction.Notification_Persist, Map.ofEntries(
+				new AbstractMap.SimpleEntry<String, Object>("model", model),
+				new AbstractMap.SimpleEntry<String, Object>("fields", fieldSet)
+		));
+		//this.auditService.trackIdentity(AuditableAction.IdentityTracking_Action);
+
+		return persisted;
+	}
+
+	@DeleteMapping("{id}")
+	@Transactional
+	public void Delete(@PathVariable("id") UUID id) throws MyForbiddenException, InvalidApplicationException {
+		logger.debug(new MapLogEntry("deleting" + Notification.class.getSimpleName()).And("id", id));
+
+		this.notificationService.deleteAndSave(id);
+
+		this.auditService.track(AuditableAction.InApp_Notification_Delete, "id", id);
+
+		//this.auditService.trackIdentity(AuditableAction.IdentityTracking_Action);
+	}
+
+}

dmp-backend/notification-service/notification-web/src/main/java/gr/cite/notification/web/controllers/PrincipalController.java

@@ -0,0 +1,91 @@
+package gr.cite.notification.web.controllers;
+
+import gr.cite.commons.web.oidc.principal.CurrentPrincipalResolver;
+import gr.cite.commons.web.oidc.principal.MyPrincipal;
+import gr.cite.commons.web.oidc.principal.extractor.ClaimExtractor;
+import gr.cite.notification.audit.AuditableAction;
+import gr.cite.notification.common.scope.tenant.TenantScope;
+import gr.cite.notification.web.model.Account;
+import gr.cite.notification.web.model.AccountBuilder;
+import gr.cite.tools.auditing.AuditService;
+import gr.cite.tools.fieldset.BaseFieldSet;
+import gr.cite.tools.fieldset.FieldSet;
+import gr.cite.tools.logging.LoggerService;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.MediaType;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+@RestController
+@RequestMapping(path = "api/principal", produces = MediaType.APPLICATION_JSON_VALUE)
+public class PrincipalController {
+	private static final LoggerService logger = new LoggerService(LoggerFactory.getLogger(PrincipalController.class));
+	private final AuditService auditService;
+
+	private final CurrentPrincipalResolver currentPrincipalResolver;
+	private final AccountBuilder accountBuilder;
+	private final ClaimExtractor claimExtractor;
+
+	@Autowired
+	public PrincipalController(
+			CurrentPrincipalResolver currentPrincipalResolver,
+			AccountBuilder accountBuilder,
+			AuditService auditService,
+			ClaimExtractor claimExtractor) {
+		this.currentPrincipalResolver = currentPrincipalResolver;
+		this.accountBuilder = accountBuilder;
+		this.auditService = auditService;
+		this.claimExtractor = claimExtractor;
+	}
+
+	@GetMapping("me")
+	public Account me(FieldSet fieldSet) {
+		logger.debug("me");
+
+
+		if (fieldSet == null || fieldSet.isEmpty()) {
+			fieldSet = new BaseFieldSet(
+					Account._isAuthenticated,
+					BaseFieldSet.asIndexer(Account._principal, Account.PrincipalInfo._subject),
+					BaseFieldSet.asIndexer(Account._principal, Account.PrincipalInfo._userId),
+					BaseFieldSet.asIndexer(Account._principal, Account.PrincipalInfo._name),
+					BaseFieldSet.asIndexer(Account._principal, Account.PrincipalInfo._scope),
+					BaseFieldSet.asIndexer(Account._principal, Account.PrincipalInfo._client),
+					BaseFieldSet.asIndexer(Account._principal, Account.PrincipalInfo._issuedAt),
+					BaseFieldSet.asIndexer(Account._principal, Account.PrincipalInfo._notBefore),
+					BaseFieldSet.asIndexer(Account._principal, Account.PrincipalInfo._authenticatedAt),
+					BaseFieldSet.asIndexer(Account._principal, Account.PrincipalInfo._expiresAt),
+					BaseFieldSet.asIndexer(Account._principal, Account.PrincipalInfo._more),
+					Account._permissions);
+		}
+
+		MyPrincipal principal = this.currentPrincipalResolver.currentPrincipal();
+
+		Account me = this.accountBuilder.build(fieldSet, principal);
+
+		this.auditService.track(AuditableAction.Principal_Lookup);
+		//auditService.trackIdentity(AuditableAction.IdentityTracking_Action);
+
+		return me;
+
+	}
+
+	@GetMapping("my-tenants")
+	public List<String> myTenants() {
+		logger.debug("my-tenants");
+
+		MyPrincipal principal = this.currentPrincipalResolver.currentPrincipal();
+		List<String> tenants = this.claimExtractor.asStrings(principal, TenantScope.TenantCodesClaimName);
+
+		this.auditService.track(AuditableAction.Tenants_Lookup);
+		//auditService.trackIdentity(AuditableAction.IdentityTracking_Action);
+
+		return tenants == null ? null : tenants.stream().distinct().collect(Collectors.toList());
+	}
+
+}

dmp-backend/notification-service/notification-web/src/main/java/gr/cite/notification/web/controllers/TenantConfigurationController.java

@@ -0,0 +1,164 @@
+package gr.cite.notification.web.controllers;
+
+import gr.cite.notification.audit.AuditableAction;
+import gr.cite.notification.authorization.AuthorizationFlags;
+import gr.cite.notification.common.enums.TenantConfigurationType;
+import gr.cite.notification.common.types.tenantconfiguration.NotifierListConfigurationDataContainer;
+import gr.cite.notification.data.TenantConfigurationEntity;
+import gr.cite.notification.model.TenantConfiguration;
+import gr.cite.notification.model.builder.TenantConfigurationBuilder;
+import gr.cite.notification.model.censorship.TenantConfigurationCensor;
+import gr.cite.notification.model.persist.tenantconfiguration.TenantConfigurationEmailClientPersist;
+import gr.cite.notification.model.persist.tenantconfiguration.TenantConfigurationNotifierListPersist;
+import gr.cite.notification.query.TenantConfigurationQuery;
+import gr.cite.notification.query.lookup.NotifierListLookup;
+import gr.cite.notification.query.lookup.TenantConfigurationLookup;
+import gr.cite.notification.service.tenantconfiguration.TenantConfigurationService;
+import gr.cite.notification.web.model.QueryResult;
+import gr.cite.tools.auditing.AuditService;
+import gr.cite.tools.data.builder.BuilderFactory;
+import gr.cite.tools.data.censor.CensorFactory;
+import gr.cite.tools.data.query.QueryFactory;
+import gr.cite.tools.exception.MyApplicationException;
+import gr.cite.tools.exception.MyForbiddenException;
+import gr.cite.tools.exception.MyNotFoundException;
+import gr.cite.tools.fieldset.FieldSet;
+import gr.cite.tools.logging.LoggerService;
+import gr.cite.tools.logging.MapLogEntry;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.MessageSource;
+import org.springframework.context.i18n.LocaleContextHolder;
+import org.springframework.web.bind.annotation.*;
+
+import javax.management.InvalidApplicationException;
+import javax.transaction.Transactional;
+import javax.validation.Valid;
+import java.util.*;
+
+@RestController
+@RequestMapping(path = "api/notification/tenant-configuration")
+public class TenantConfigurationController {
+	private static final LoggerService logger = new LoggerService(LoggerFactory.getLogger(TenantConfigurationController.class));
+
+	private final BuilderFactory builderFactory;
+	private final AuditService auditService;
+	private final TenantConfigurationService tenantConfigurationService;
+	private final CensorFactory censorFactory;
+	private final QueryFactory queryFactory;
+	private final MessageSource messageSource;
+
+	@Autowired
+	public TenantConfigurationController(BuilderFactory builderFactory,
+										 AuditService auditService,
+										 TenantConfigurationService tenantConfigurationService, CensorFactory censorFactory,
+										 QueryFactory queryFactory,
+										 MessageSource messageSource) {
+		this.builderFactory = builderFactory;
+		this.auditService = auditService;
+		this.tenantConfigurationService = tenantConfigurationService;
+		this.censorFactory = censorFactory;
+		this.queryFactory = queryFactory;
+		this.messageSource = messageSource;
+	}
+
+	@PostMapping("query")
+	public QueryResult<TenantConfiguration> query(@RequestBody TenantConfigurationLookup lookup) throws MyApplicationException, MyForbiddenException {
+		logger.debug("querying {}", TenantConfiguration.class.getSimpleName());
+
+		this.censorFactory.censor(TenantConfigurationCensor.class).censor(lookup.getProject());
+
+		TenantConfigurationQuery query = lookup.enrich(this.queryFactory);
+		List<TenantConfigurationEntity> data = query.collectAs(lookup.getProject());
+		List<TenantConfiguration> models = this.builderFactory.builder(TenantConfigurationBuilder.class).authorize(AuthorizationFlags.OwnerOrPermission).build(lookup.getProject(), data);
+		long count = (lookup.getMetadata() != null && lookup.getMetadata().getCountAll()) ? query.count() : models.size();
+
+		this.auditService.track(AuditableAction.Tenant_Configuration_Query, "lookup", lookup);
+
+		return new QueryResult<>(models, count);
+	}
+
+	@GetMapping("{id}")
+	@Transactional
+	public TenantConfiguration get(@PathVariable UUID id, FieldSet fieldSet, Locale locale) throws MyApplicationException, MyForbiddenException, MyNotFoundException {
+		logger.debug(new MapLogEntry("retrieving" + TenantConfiguration.class.getSimpleName()).And("id", id).And("fields", fieldSet));
+
+		this.censorFactory.censor(TenantConfigurationCensor.class).censor(fieldSet);
+
+		TenantConfigurationQuery query = this.queryFactory.query(TenantConfigurationQuery.class).ids(id);
+		TenantConfiguration model = this.builderFactory.builder(TenantConfigurationBuilder.class).authorize(AuthorizationFlags.OwnerOrPermission).build(fieldSet, query.firstAs(fieldSet));
+		if (model == null)
+			throw new MyNotFoundException(messageSource.getMessage("General_ItemNotFound", new Object[]{id, TenantConfiguration.class.getSimpleName()}, LocaleContextHolder.getLocale()));
+
+		this.auditService.track(AuditableAction.Tenant_Configuration_Lookup, Map.ofEntries(
+				new AbstractMap.SimpleEntry<String, Object>("id", id),
+				new AbstractMap.SimpleEntry<String, Object>("fields", fieldSet)
+		));
+		//this.auditService.trackIdentity(AuditableAction.IdentityTracking_Action);
+
+		return model;
+	}
+
+	@PostMapping("persist/email-client")
+	@Transactional
+	public  TenantConfiguration persist(@RequestBody @Valid TenantConfigurationEmailClientPersist model, FieldSet fieldSet)
+	{
+		logger.debug(new MapLogEntry("persisting").And("type", TenantConfigurationType.EMAIL_CLIENT_CONFIGURATION).And("model", model).And("fields", fieldSet));
+
+		TenantConfiguration persisted = this.tenantConfigurationService.persist(model, fieldSet);
+
+		this.auditService.track(AuditableAction.Tenant_Configuration_Persist, Map.of(
+				"type", TenantConfigurationType.EMAIL_CLIENT_CONFIGURATION,
+				"model", model,
+				"fields", fieldSet
+	));
+		//this._auditService.TrackIdentity(AuditableAction.IdentityTracking_Action);
+
+		return persisted;
+	}
+
+	@PostMapping("notifier-list/available")
+	public NotifierListConfigurationDataContainer getAvailableNotifiers(@RequestBody NotifierListLookup tenantNotifierListLookup)
+	{
+		logger.debug("querying available notifiers");
+
+		NotifierListConfigurationDataContainer notifierListData = this.tenantConfigurationService.collectTenantAvailableNotifierList(tenantNotifierListLookup.getNotificationTypes());
+
+		this.auditService.track(AuditableAction.Tenant_Available_Notifiers_Query, Map.of(
+		"lookup", tenantNotifierListLookup
+		));
+		//this._auditService.TrackIdentity(AuditableAction.IdentityTracking_Action);
+
+		return notifierListData;
+	}
+
+	@PostMapping("persist/notifier-list")
+	@Transactional
+	public TenantConfiguration persist(@RequestBody @Valid TenantConfigurationNotifierListPersist model, FieldSet fieldSet)
+	{
+		logger.debug(new MapLogEntry("persisting").And("type", TenantConfigurationType.NOTIFIER_LIST).And("model", model).And("fields", fieldSet));
+
+		TenantConfiguration persisted = this.tenantConfigurationService.persist(model, fieldSet);
+
+		this.auditService.track(AuditableAction.Tenant_Configuration_Persist, Map.of(
+			"type", TenantConfigurationType.NOTIFIER_LIST,
+			"model", model,
+			"fields", fieldSet
+				));
+		//this._auditService.TrackIdentity(AuditableAction.IdentityTracking_Action);
+
+		return persisted;
+	}
+
+	@DeleteMapping("{id}")
+	@Transactional
+	public void delete(@PathVariable("id") UUID id) throws MyForbiddenException, InvalidApplicationException {
+		logger.debug(new MapLogEntry("deleting" + TenantConfiguration.class.getSimpleName()).And("id", id));
+
+		this.tenantConfigurationService.deleteAndSave(id);
+
+		this.auditService.track(AuditableAction.Tenant_Configuration_Delete, "id", id);
+
+		//this.auditService.trackIdentity(AuditableAction.IdentityTracking_Action);
+	}
+}

dmp-backend/notification-service/notification-web/src/main/java/gr/cite/notification/web/controllers/UserNotificationPreferenceController.java

@@ -0,0 +1,149 @@
+package gr.cite.notification.web.controllers;
+
+import gr.cite.notification.audit.AuditableAction;
+import gr.cite.notification.authorization.AuthorizationFlags;
+import gr.cite.notification.common.enums.TenantConfigurationType;
+import gr.cite.notification.common.types.tenantconfiguration.NotifierListConfigurationDataContainer;
+import gr.cite.notification.data.UserNotificationPreferenceEntity;
+import gr.cite.notification.model.TenantConfiguration;
+import gr.cite.notification.model.UserNotificationPreference;
+import gr.cite.notification.model.builder.UserNotificationPreferenceBuilder;
+import gr.cite.notification.model.censorship.UserNotificationPreferenceCensor;
+import gr.cite.notification.model.persist.UserNotificationPreferencePersist;
+import gr.cite.notification.model.persist.tenantconfiguration.TenantConfigurationNotifierListPersist;
+import gr.cite.notification.query.UserNotificationPreferenceQuery;
+import gr.cite.notification.query.lookup.NotifierListLookup;
+import gr.cite.notification.query.lookup.UserNotificationPreferenceLookup;
+import gr.cite.notification.service.tenantconfiguration.TenantConfigurationService;
+import gr.cite.notification.service.userNotificationPreference.UserNotificationPreferenceService;
+import gr.cite.notification.web.model.QueryResult;
+import gr.cite.tools.auditing.AuditService;
+import gr.cite.tools.data.builder.BuilderFactory;
+import gr.cite.tools.data.censor.CensorFactory;
+import gr.cite.tools.data.query.QueryFactory;
+import gr.cite.tools.exception.MyApplicationException;
+import gr.cite.tools.exception.MyForbiddenException;
+import gr.cite.tools.exception.MyNotFoundException;
+import gr.cite.tools.fieldset.FieldSet;
+import gr.cite.tools.logging.LoggerService;
+import gr.cite.tools.logging.MapLogEntry;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.MessageSource;
+import org.springframework.context.i18n.LocaleContextHolder;
+import org.springframework.web.bind.annotation.*;
+
+import javax.management.InvalidApplicationException;
+import javax.transaction.Transactional;
+import javax.validation.Valid;
+import java.util.*;
+
+@RestController
+@RequestMapping(path = "api/notification/notification-preference")
+public class UserNotificationPreferenceController {
+	private static final LoggerService logger = new LoggerService(LoggerFactory.getLogger(UserNotificationPreferenceController.class));
+
+	private final BuilderFactory builderFactory;
+	private final AuditService auditService;
+	private final UserNotificationPreferenceService userNotificationPreferenceService;
+	private final CensorFactory censorFactory;
+	private final QueryFactory queryFactory;
+	private final MessageSource messageSource;
+
+	@Autowired
+	public UserNotificationPreferenceController(BuilderFactory builderFactory,
+												AuditService auditService,
+												UserNotificationPreferenceService userNotificationPreferenceService,
+												CensorFactory censorFactory,
+												QueryFactory queryFactory,
+												MessageSource messageSource) {
+		this.builderFactory = builderFactory;
+		this.auditService = auditService;
+		this.userNotificationPreferenceService = userNotificationPreferenceService;
+		this.censorFactory = censorFactory;
+		this.queryFactory = queryFactory;
+		this.messageSource = messageSource;
+	}
+
+	@PostMapping("query")
+	public QueryResult<UserNotificationPreference> query(@RequestBody UserNotificationPreferenceLookup lookup) throws MyApplicationException, MyForbiddenException {
+		logger.debug("querying {}", UserNotificationPreference.class.getSimpleName());
+
+		this.censorFactory.censor(UserNotificationPreferenceCensor.class).censor(lookup.getProject());
+
+		UserNotificationPreferenceQuery query = lookup.enrich(this.queryFactory);
+		List<UserNotificationPreferenceEntity> data = query.collectAs(lookup.getProject());
+		List<UserNotificationPreference> models = this.builderFactory.builder(UserNotificationPreferenceBuilder.class).authorize(AuthorizationFlags.OwnerOrPermission).build(lookup.getProject(), data);
+		long count = (lookup.getMetadata() != null && lookup.getMetadata().getCountAll()) ? query.count() : models.size();
+
+		this.auditService.track(AuditableAction.User_Notification_Preference_Query, "lookup", lookup);
+
+		return new QueryResult<>(models, count);
+	}
+
+	@GetMapping("user/{userId}/current")
+	@Transactional
+	public UserNotificationPreference current(@PathVariable UUID userId, FieldSet fieldSet, Locale locale) throws MyApplicationException, MyForbiddenException, MyNotFoundException {
+		logger.debug(new MapLogEntry("retrieving" + UserNotificationPreference.class.getSimpleName()).And("userId", userId).And("fields", fieldSet));
+
+		this.censorFactory.censor(UserNotificationPreferenceCensor.class).censor(fieldSet);
+
+		UserNotificationPreferenceQuery query = this.queryFactory.query(UserNotificationPreferenceQuery.class).userId(userId);
+		UserNotificationPreference model = this.builderFactory.builder(UserNotificationPreferenceBuilder.class).authorize(AuthorizationFlags.OwnerOrPermission).build(fieldSet, query.firstAs(fieldSet));
+		if (model == null)
+			throw new MyNotFoundException(messageSource.getMessage("General_ItemNotFound", new Object[]{userId, TenantConfiguration.class.getSimpleName()}, LocaleContextHolder.getLocale()));
+
+		this.auditService.track(AuditableAction.User_Notification_Preference_Lookup, Map.ofEntries(
+				new AbstractMap.SimpleEntry<String, Object>("userId", userId),
+				new AbstractMap.SimpleEntry<String, Object>("fields", fieldSet)
+		));
+		//this.auditService.trackIdentity(AuditableAction.IdentityTracking_Action);
+
+		return model;
+	}
+
+	@PostMapping("notifier-list/available")
+	public NotifierListConfigurationDataContainer getAvailableNotifiers(@RequestBody NotifierListLookup tenantNotifierListLookup)
+	{
+		logger.debug("querying available notifiers");
+
+		NotifierListConfigurationDataContainer notifierListData = this.userNotificationPreferenceService.collectUserAvailableNotifierList(tenantNotifierListLookup.getNotificationTypes());
+
+		this.auditService.track(AuditableAction.User_Available_Notifiers_Query, Map.of(
+		"lookup", tenantNotifierListLookup
+		));
+		//this._auditService.TrackIdentity(AuditableAction.IdentityTracking_Action);
+
+		return notifierListData;
+	}
+
+	@PostMapping("persist")
+	@Transactional
+	public List<UserNotificationPreference> persist(@RequestBody @Valid UserNotificationPreferencePersist model, FieldSet fieldSet)
+	{
+		logger.debug(new MapLogEntry("persisting").And("type", TenantConfigurationType.NOTIFIER_LIST).And("model", model).And("fields", fieldSet));
+
+		List<UserNotificationPreference> persisted = this.userNotificationPreferenceService.persist(model, fieldSet);
+
+		this.auditService.track(AuditableAction.User_Notification_Preference_Persist, Map.of(
+			"type", TenantConfigurationType.NOTIFIER_LIST,
+			"model", model,
+			"fields", fieldSet
+				));
+		//this._auditService.TrackIdentity(AuditableAction.IdentityTracking_Action);
+
+		return persisted;
+	}
+
+/*	@DeleteMapping("{id}")
+	@Transactional
+	public void delete(@PathVariable("id") UUID id) throws MyForbiddenException, InvalidApplicationException {
+		logger.debug(new MapLogEntry("deleting" + TenantConfiguration.class.getSimpleName()).And("id", id));
+
+		this.tenantConfigurationService.deleteAndSave(id);
+
+		this.auditService.track(AuditableAction.Tenant_Configuration_Delete, "id", id);
+
+		//this.auditService.trackIdentity(AuditableAction.IdentityTracking_Action);
+	}*/
+}

dmp-backend/notification-service/notification-web/src/main/java/gr/cite/notification/web/controllers/error/GenericErrorHandler.java

@@ -0,0 +1,17 @@
+//package gr.cite.intelcomp.stiviewer.web.controllers.error;
+//
+//import gr.cite.tools.exception.MyValidationException;
+//import org.springframework.http.HttpStatus;
+//import org.springframework.http.ResponseEntity;
+//import org.springframework.web.bind.annotation.ControllerAdvice;
+//import org.springframework.web.bind.annotation.ExceptionHandler;
+//import org.springframework.web.context.request.WebRequest;
+//
+//@ControllerAdvice
+//public class GenericErrorHandler {
+//
+//    @ExceptionHandler(MyValidationException.class)
+//    public ResponseEntity<MyValidationException> handleValidationException(MyValidationException e, WebRequest webRequest) {
+//        return ResponseEntity.status(HttpStatus.NOT_ACCEPTABLE).body(e);
+//    }
+//}

dmp-backend/notification-service/notification-web/src/main/java/gr/cite/notification/web/model/Account.java

@@ -0,0 +1,160 @@
+package gr.cite.notification.web.model;
+
+import gr.cite.tools.logging.annotation.LogSensitive;
+
+import java.time.Instant;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+public class Account {
+
+	public static class PrincipalInfo {
+
+		public final static String _userId = "userId";
+		public UUID userId;
+
+		public UUID getUserId() {
+			return userId;
+		}
+
+		public void setUserId(UUID userId) {
+			this.userId = userId;
+		}
+
+		public final static String _subject = "subject";
+		public UUID subject;
+
+		public UUID getSubject() {
+			return subject;
+		}
+
+		public void setSubject(UUID subject) {
+			this.subject = subject;
+		}
+
+		public final static String _name = "name";
+		@LogSensitive
+		public String name;
+
+		public String getName() {
+			return name;
+		}
+
+		public void setName(String name) {
+			this.name = name;
+		}
+
+		public final static String _scope = "scope";
+		public List<String> scope;
+
+		public List<String> getScope() {
+			return scope;
+		}
+
+		public void setScope(List<String> scope) {
+			this.scope = scope;
+		}
+
+		public final static String _client = "client";
+		public String client;
+
+		public String getClient() {
+			return client;
+		}
+
+		public void setClient(String client) {
+			this.client = client;
+		}
+
+		public final static String _notBefore = "notBefore";
+		public Instant notBefore;
+
+		public Instant getNotBefore() {
+			return notBefore;
+		}
+
+		public void setNotBefore(Instant notBefore) {
+			this.notBefore = notBefore;
+		}
+
+		public final static String _issuedAt = "issuedAt";
+		public Instant issuedAt;
+
+		public Instant getIssuedAt() {
+			return issuedAt;
+		}
+
+		public void setIssuedAt(Instant issuedAt) {
+			this.issuedAt = issuedAt;
+		}
+
+		public final static String _authenticatedAt = "authenticatedAt";
+		public Instant authenticatedAt;
+
+		public Instant getAuthenticatedAt() {
+			return authenticatedAt;
+		}
+
+		public void setAuthenticatedAt(Instant authenticatedAt) {
+			this.authenticatedAt = authenticatedAt;
+		}
+
+		public final static String _expiresAt = "expiresAt";
+		public Instant expiresAt;
+
+		public Instant getExpiresAt() {
+			return expiresAt;
+		}
+
+		public void setExpiresAt(Instant expiresAt) {
+			this.expiresAt = expiresAt;
+		}
+
+		public final static String _more = "more";
+		@LogSensitive
+		public Map<String, List<String>> more;
+
+		public Map<String, List<String>> getMore() {
+			return more;
+		}
+
+		public void setMore(Map<String, List<String>> more) {
+			this.more = more;
+		}
+	}
+
+
+	public final static String _isAuthenticated = "isAuthenticated";
+	private Boolean isAuthenticated;
+
+	public Boolean getIsAuthenticated() {
+		return isAuthenticated;
+	}
+
+	public void setIsAuthenticated(Boolean authenticated) {
+		isAuthenticated = authenticated;
+	}
+
+	public final static String _principal = "principal";
+	private PrincipalInfo principal;
+
+	public PrincipalInfo getPrincipal() {
+		return principal;
+	}
+
+	public void setPrincipal(PrincipalInfo principal) {
+		this.principal = principal;
+	}
+
+	public final static String _permissions = "permissions";
+	private List<String> permissions;
+
+	public List<String> getPermissions() {
+		return permissions;
+	}
+
+	public void setPermissions(List<String> permissions) {
+		this.permissions = permissions;
+	}
+}

dmp-backend/notification-service/notification-web/src/main/java/gr/cite/notification/web/model/AccountBuilder.java

@@ -0,0 +1,83 @@
+package gr.cite.notification.web.model;
+
+import gr.cite.commons.web.authz.configuration.AuthorizationConfiguration;
+import gr.cite.commons.web.oidc.principal.CurrentPrincipalResolver;
+import gr.cite.commons.web.oidc.principal.MyPrincipal;
+import gr.cite.commons.web.oidc.principal.extractor.ClaimExtractor;
+import gr.cite.commons.web.oidc.principal.extractor.ClaimExtractorKeys;
+import gr.cite.notification.common.scope.user.UserScope;
+import gr.cite.tools.fieldset.BaseFieldSet;
+import gr.cite.tools.fieldset.FieldSet;
+import org.springframework.beans.factory.config.ConfigurableBeanFactory;
+import org.springframework.context.annotation.Scope;
+import org.springframework.stereotype.Component;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Set;
+
+@Component
+@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
+public class AccountBuilder {
+
+	private final ClaimExtractor claimExtractor;
+	private final Set<String> excludeMoreClaim;
+	private final AuthorizationConfiguration authorizationConfiguration;
+	private final CurrentPrincipalResolver currentPrincipalResolver;
+	private final UserScope userScope;
+
+	public AccountBuilder(ClaimExtractor claimExtractor, AuthorizationConfiguration authorizationConfiguration, CurrentPrincipalResolver currentPrincipalResolver, UserScope userScope) {
+		this.claimExtractor = claimExtractor;
+		this.authorizationConfiguration = authorizationConfiguration;
+		this.currentPrincipalResolver = currentPrincipalResolver;
+		this.userScope = userScope;
+		this.excludeMoreClaim = Set.of(
+				ClaimExtractorKeys.Subject,
+				ClaimExtractorKeys.Name,
+				ClaimExtractorKeys.Scope,
+				ClaimExtractorKeys.Client,
+				ClaimExtractorKeys.IssuedAt,
+				ClaimExtractorKeys.NotBefore,
+				ClaimExtractorKeys.AuthenticatedAt,
+				ClaimExtractorKeys.ExpiresAt);
+	}
+
+	public Account build(FieldSet fields, MyPrincipal principal) {
+		Account model = new Account();
+		if (principal == null || !principal.isAuthenticated()) {
+			model.setIsAuthenticated(false);
+			return model;
+		}
+		model.setIsAuthenticated(true);
+
+		FieldSet principalFields = fields.extractPrefixed(BaseFieldSet.asIndexerPrefix(Account._principal));
+		if (!principalFields.isEmpty()) model.setPrincipal(new Account.PrincipalInfo());
+		if (principalFields.hasField(Account.PrincipalInfo._subject)) model.getPrincipal().setSubject(this.claimExtractor.subjectUUID(principal));
+		if (principalFields.hasField(Account.PrincipalInfo._userId)) model.getPrincipal().setUserId(this.userScope.getUserIdSafe());
+		if (principalFields.hasField(Account.PrincipalInfo._name)) model.getPrincipal().setName(this.claimExtractor.name(principal));
+		if (principalFields.hasField(Account.PrincipalInfo._scope)) model.getPrincipal().setScope(this.claimExtractor.scope(principal));
+		if (principalFields.hasField(Account.PrincipalInfo._client)) model.getPrincipal().setClient(this.claimExtractor.client(principal));
+		if (principalFields.hasField(Account.PrincipalInfo._issuedAt)) model.getPrincipal().setIssuedAt(this.claimExtractor.issuedAt(principal));
+		if (principalFields.hasField(Account.PrincipalInfo._notBefore)) model.getPrincipal().setNotBefore(this.claimExtractor.notBefore(principal));
+		if (principalFields.hasField(Account.PrincipalInfo._authenticatedAt)) model.getPrincipal().setAuthenticatedAt(this.claimExtractor.authenticatedAt(principal));
+		if (principalFields.hasField(Account.PrincipalInfo._expiresAt)) model.getPrincipal().setExpiresAt(this.claimExtractor.expiresAt(principal));
+		if (principalFields.hasField(Account.PrincipalInfo._more)) {
+			model.getPrincipal().setMore(new HashMap<>());
+			for (String key : this.claimExtractor.knownPublicKeys()) {
+				if (this.excludeMoreClaim.contains(key)) continue;
+				List<String> values = this.claimExtractor.asStrings(principal, key);
+				if (values == null || values.size() == 0) continue;
+				if (!model.getPrincipal().getMore().containsKey(key)) model.getPrincipal().getMore().put(key, new ArrayList<>());
+				model.getPrincipal().getMore().get(key).addAll(values);
+			}
+		}
+
+		if (fields.hasField(Account._permissions)) {
+			List<String> roles = claimExtractor.roles(currentPrincipalResolver.currentPrincipal());
+			Set<String> permissions = authorizationConfiguration.permissionsOfRoles(roles);
+			model.setPermissions(new ArrayList<>(permissions));
+		}
+		return model;
+	}
+}

dmp-backend/notification-service/notification-web/src/main/java/gr/cite/notification/web/model/QueryResult.java

@@ -0,0 +1,37 @@
+package gr.cite.notification.web.model;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class QueryResult<M> {
+	public QueryResult() { }
+	public QueryResult(List<M> items, long count)
+	{
+		this.items = items;
+		this.count = count;
+	}
+
+	public List<M> items;
+	public long count;
+
+	public List<M> getItems() {
+		return items;
+	}
+
+	public void setItems(List<M> items) {
+		this.items = items;
+	}
+
+	public long getCount() {
+		return count;
+	}
+
+	public void setCount(long count) {
+		this.count = count;
+	}
+
+	public static QueryResult Empty()
+	{
+		return new QueryResult(new ArrayList<>(), 0L);
+	}
+}

dmp-backend/notification-service/notification-web/src/main/java/gr/cite/notification/web/scope/tenant/TenantByCodeCacheOptions.java

@@ -0,0 +1,10 @@
+package gr.cite.notification.web.scope.tenant;
+
+import gr.cite.tools.cache.CacheOptions;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+@ConfigurationProperties(prefix = "cache.tenant-by-code")
+public class TenantByCodeCacheOptions extends CacheOptions {
+}

dmp-backend/notification-service/notification-web/src/main/java/gr/cite/notification/web/scope/tenant/TenantByCodeCacheService.java

@@ -0,0 +1,76 @@
+package gr.cite.notification.web.scope.tenant;
+
+import gr.cite.notification.convention.ConventionService;
+import gr.cite.notification.event.TenantTouchedEvent;
+import gr.cite.tools.cache.CacheService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.event.EventListener;
+import org.springframework.stereotype.Service;
+
+import java.util.HashMap;
+import java.util.UUID;
+
+@Service
+public class TenantByCodeCacheService extends CacheService<TenantByCodeCacheService.TenantByCodeCacheValue> {
+
+	public static class TenantByCodeCacheValue {
+
+		public TenantByCodeCacheValue() {
+		}
+
+		public TenantByCodeCacheValue(String tenantCode, UUID tenantId) {
+			this.tenantCode = tenantCode;
+			this.tenantId = tenantId;
+		}
+
+		private String tenantCode;
+
+		public String getTenantCode() {
+			return tenantCode;
+		}
+
+		public void setTenantCode(String tenantCode) {
+			this.tenantCode = tenantCode;
+		}
+
+		private UUID tenantId;
+
+		public UUID getTenantId() {
+			return tenantId;
+		}
+
+		public void setTenantId(UUID tenantId) {
+			this.tenantId = tenantId;
+		}
+	}
+
+	private final ConventionService conventionService;
+
+	@Autowired
+	public TenantByCodeCacheService(TenantByCodeCacheOptions options, ConventionService conventionService) {
+		super(options);
+		this.conventionService = conventionService;
+	}
+
+	@EventListener
+	public void handleTenantTouchedEvent(TenantTouchedEvent event) {
+		if (!this.conventionService.isNullOrEmpty(event.getTenantCode())) this.evict(this.buildKey(event.getTenantCode()));
+		if (!this.conventionService.isNullOrEmpty(event.getPreviousTenantCode())) this.evict(this.buildKey(event.getPreviousTenantCode()));
+	}
+
+	@Override
+	protected Class<TenantByCodeCacheValue> valueClass() {
+		return TenantByCodeCacheValue.class;
+	}
+
+	@Override
+	public String keyOf(TenantByCodeCacheValue value) {
+		return this.buildKey(value.getTenantCode());
+	}
+
+	public String buildKey(String code) {
+		return this.generateKey(new HashMap<>() {{
+			put("$code$", code);
+		}});
+	}
+}

dmp-backend/notification-service/notification-web/src/main/java/gr/cite/notification/web/scope/tenant/TenantByIdCacheOptions.java

@@ -0,0 +1,10 @@
+package gr.cite.notification.web.scope.tenant;
+
+import gr.cite.tools.cache.CacheOptions;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+@ConfigurationProperties(prefix = "cache.tenant-by-id")
+public class TenantByIdCacheOptions extends CacheOptions {
+}

dmp-backend/notification-service/notification-web/src/main/java/gr/cite/notification/web/scope/tenant/TenantByIdCacheService.java

@@ -0,0 +1,76 @@
+package gr.cite.notification.web.scope.tenant;
+
+import gr.cite.notification.convention.ConventionService;
+import gr.cite.notification.event.TenantTouchedEvent;
+import gr.cite.tools.cache.CacheService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.event.EventListener;
+import org.springframework.stereotype.Service;
+
+import java.util.HashMap;
+import java.util.Locale;
+import java.util.UUID;
+
+@Service
+public class TenantByIdCacheService extends CacheService<TenantByIdCacheService.TenantByIdCacheValue> {
+
+	public static class TenantByIdCacheValue {
+
+		public TenantByIdCacheValue() {
+		}
+
+		public TenantByIdCacheValue(String tenantCode, UUID tenantId) {
+			this.tenantCode = tenantCode;
+			this.tenantId = tenantId;
+		}
+
+		private String tenantCode;
+
+		public String getTenantCode() {
+			return tenantCode;
+		}
+
+		public void setTenantCode(String tenantCode) {
+			this.tenantCode = tenantCode;
+		}
+
+		private UUID tenantId;
+
+		public UUID getTenantId() {
+			return tenantId;
+		}
+
+		public void setTenantId(UUID tenantId) {
+			this.tenantId = tenantId;
+		}
+	}
+
+	private final ConventionService conventionService;
+
+	@Autowired
+	public TenantByIdCacheService(TenantByIdCacheOptions options, ConventionService conventionService) {
+		super(options);
+		this.conventionService = conventionService;
+	}
+
+	@EventListener
+	public void handleTenantTouchedEvent(TenantTouchedEvent event) {
+		if (!this.conventionService.isNullOrEmpty(event.getTenantCode())) this.evict(this.buildKey(event.getTenantId()));
+	}
+
+	@Override
+	protected Class<TenantByIdCacheValue> valueClass() {
+		return TenantByIdCacheValue.class;
+	}
+
+	@Override
+	public String keyOf(TenantByIdCacheValue value) {
+		return this.buildKey(value.getTenantId());
+	}
+
+	public String buildKey(UUID id) {
+		return this.generateKey(new HashMap<>() {{
+			put("$tenantId$", id.toString().toLowerCase(Locale.ROOT));
+		}});
+	}
+}

dmp-backend/notification-service/notification-web/src/main/java/gr/cite/notification/web/scope/tenant/TenantInterceptor.java

@@ -0,0 +1,167 @@
+package gr.cite.notification.web.scope.tenant;
+
+
+import gr.cite.commons.web.authz.service.AuthorizationService;
+import gr.cite.commons.web.oidc.principal.CurrentPrincipalResolver;
+import gr.cite.commons.web.oidc.principal.extractor.ClaimExtractor;
+import gr.cite.notification.authorization.Permission;
+import gr.cite.notification.common.enums.IsActive;
+import gr.cite.notification.common.scope.tenant.TenantScope;
+import gr.cite.notification.common.scope.user.UserScope;
+import gr.cite.notification.data.TenantUserEntity;
+import gr.cite.notification.data.UserEntity;
+import gr.cite.notification.data.tenant.TenantScopedBaseEntity;
+import gr.cite.notification.errorcode.ErrorThesaurusProperties;
+import gr.cite.tools.exception.MyForbiddenException;
+import gr.cite.tools.logging.LoggerService;
+import org.hibernate.Session;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.ApplicationContext;
+import org.springframework.lang.NonNull;
+import org.springframework.stereotype.Component;
+import org.springframework.ui.ModelMap;
+import org.springframework.web.context.request.ServletWebRequest;
+import org.springframework.web.context.request.WebRequest;
+import org.springframework.web.context.request.WebRequestInterceptor;
+
+import javax.management.InvalidApplicationException;
+import javax.persistence.EntityManager;
+import javax.persistence.PersistenceContext;
+import javax.persistence.Tuple;
+import javax.persistence.criteria.CriteriaBuilder;
+import javax.persistence.criteria.CriteriaQuery;
+import javax.persistence.criteria.Root;
+import javax.persistence.criteria.Subquery;
+import java.util.List;
+import java.util.Locale;
+
+@Component
+public class TenantInterceptor implements WebRequestInterceptor {
+
+	private static final LoggerService logger = new LoggerService(LoggerFactory.getLogger(TenantInterceptor.class));
+	private final TenantScope tenantScope;
+	private final UserScope userScope;
+	private final CurrentPrincipalResolver currentPrincipalResolver;
+	private final ClaimExtractor claimExtractor;
+	private final ApplicationContext applicationContext;
+	private final ErrorThesaurusProperties errorThesaurusProperties;
+	private final TenantScopeProperties tenantScopeProperties;
+	private final UserAllowedTenantCacheService userAllowedTenantCacheService;
+	private final ErrorThesaurusProperties errors;
+
+	@PersistenceContext
+	public EntityManager entityManager;
+
+	@Autowired
+	public TenantInterceptor(
+			TenantScope tenantScope,
+			UserScope userScope,
+			CurrentPrincipalResolver currentPrincipalResolver,
+			ClaimExtractor claimExtractor,
+			ApplicationContext applicationContext,
+			ErrorThesaurusProperties errorThesaurusProperties,
+			TenantScopeProperties tenantScopeProperties,
+			UserAllowedTenantCacheService userAllowedTenantCacheService,
+			ErrorThesaurusProperties errors) {
+		this.tenantScope = tenantScope;
+		this.userScope = userScope;
+		this.currentPrincipalResolver = currentPrincipalResolver;
+		this.claimExtractor = claimExtractor;
+		this.applicationContext = applicationContext;
+		this.errorThesaurusProperties = errorThesaurusProperties;
+		this.tenantScopeProperties = tenantScopeProperties;
+		this.userAllowedTenantCacheService = userAllowedTenantCacheService;
+		this.errors = errors;
+	}
+
+	@Override
+	public void preHandle(WebRequest request) throws InvalidApplicationException {
+		if (!this.currentPrincipalResolver.currentPrincipal().isAuthenticated()) return;
+		if (!this.tenantScope.isMultitenant()) return;
+
+		boolean isAllowedNoTenant = this.applicationContext.getBean(AuthorizationService.class).authorize(Permission.AllowNoTenant);
+		if (tenantScope.isSet() && this.entityManager != null) {
+			List<String> currentPrincipalTenantCodes = this.claimExtractor.asStrings(this.currentPrincipalResolver.currentPrincipal(), TenantScope.TenantCodesClaimName);
+			if ((currentPrincipalTenantCodes == null || !currentPrincipalTenantCodes.contains(tenantScope.getTenantCode())) && !isAllowedNoTenant) {
+				logger.warn("tenant not allowed {}", this.tenantScope.getTenant());
+				//throw new MyForbiddenException(this.errors.getTenantNotAllowed().getCode(), this.errors.getTenantNotAllowed().getMessage());
+			}
+
+			boolean isUserAllowedTenant = false;
+			UserAllowedTenantCacheService.UserAllowedTenantCacheValue cacheValue = this.userAllowedTenantCacheService.lookup(this.userAllowedTenantCacheService.buildKey(this.userScope.getUserId(), this.tenantScope.getTenant()));
+			if (cacheValue != null) {
+				isUserAllowedTenant = cacheValue.isAllowed();
+			} else {
+				isUserAllowedTenant = this.isUserAllowedTenant();
+				this.userAllowedTenantCacheService.put(new UserAllowedTenantCacheService.UserAllowedTenantCacheValue(this.userScope.getUserId(), this.tenantScope.getTenant(), isUserAllowedTenant));
+			}
+
+			if (isUserAllowedTenant) {
+				this.entityManager
+						.unwrap(Session.class)
+						.enableFilter(TenantScopedBaseEntity.tenantFilter).setParameter(TenantScopedBaseEntity.tenantFilterTenantParam, tenantScope.getTenant().toString());
+			} else {
+				if (isAllowedNoTenant || this.isWhiteListedEndpoint(request)) {
+					tenantScope.setTenant(null, null);
+				} else {
+					logger.warn("tenant not allowed {}", this.tenantScope.getTenant());
+					//throw new MyForbiddenException(this.errors.getTenantNotAllowed().getCode(), this.errors.getTenantNotAllowed().getMessage());
+				}
+			}
+		} else {
+			if (!isAllowedNoTenant) {
+				if (!this.isWhiteListedEndpoint(request)) {
+					logger.warn("tenant scope not provided");
+					throw new MyForbiddenException(this.errorThesaurusProperties.getMissingTenant().getCode(), this.errorThesaurusProperties.getMissingTenant().getMessage());
+				}
+			}
+		}
+	}
+
+	private boolean isWhiteListedEndpoint(WebRequest request) {
+		String servletPath = ((ServletWebRequest) request).getRequest().getServletPath();
+		if (this.tenantScopeProperties.getWhiteListedEndpoints() != null) {
+			for (String whiteListedEndpoint : this.tenantScopeProperties.getWhiteListedEndpoints()) {
+				if (servletPath.toLowerCase(Locale.ROOT).startsWith(whiteListedEndpoint.toLowerCase(Locale.ROOT))) {
+					return true;
+				}
+			}
+		}
+		return false;
+	}
+
+	private boolean isUserAllowedTenant() throws InvalidApplicationException {
+		if (userScope.isSet()) {
+			CriteriaBuilder criteriaBuilder = this.entityManager.getCriteriaBuilder();
+			CriteriaQuery<Tuple> query = criteriaBuilder.createQuery(Tuple.class);
+			Root<UserEntity> root = query.from(UserEntity.class);
+			Subquery<TenantUserEntity> subQuery = query.subquery(TenantUserEntity.class);
+			Root<TenantUserEntity> subQueryRoot = subQuery.from(TenantUserEntity.class);
+			query.where(criteriaBuilder.and(
+					criteriaBuilder.equal(root.get(UserEntity._isActive), IsActive.Active),
+					criteriaBuilder.in(root.get(UserEntity._id)).value(subQuery.where(
+							criteriaBuilder.and(
+									criteriaBuilder.equal(subQueryRoot.get(TenantUserEntity._tenantId), this.tenantScope.getTenant()),
+									criteriaBuilder.equal(subQueryRoot.get(TenantUserEntity._userId), this.userScope.getUserId()),
+									criteriaBuilder.equal(subQueryRoot.get(TenantUserEntity._isActive), IsActive.Active)
+							)).select(subQueryRoot.get(TenantUserEntity._userId)).distinct(true)
+					)
+			));
+			query.multiselect(root.get(UserEntity._id).alias(UserEntity._id));
+			List<Tuple> results = this.entityManager.createQuery(query).getResultList();
+			if (results.size() > 0) return true;
+		}
+
+		return false;
+	}
+
+	@Override
+	public void postHandle(@NonNull WebRequest request, ModelMap model) {
+		this.tenantScope.setTenant(null, null);
+	}
+
+	@Override
+	public void afterCompletion(@NonNull WebRequest request, Exception ex) {
+	}
+}

dmp-backend/notification-service/notification-web/src/main/java/gr/cite/notification/web/scope/tenant/TenantScopeClaimInterceptor.java

@@ -0,0 +1,197 @@
+package gr.cite.notification.web.scope.tenant;
+
+
+import gr.cite.commons.web.oidc.principal.CurrentPrincipalResolver;
+import gr.cite.commons.web.oidc.principal.MyPrincipal;
+import gr.cite.commons.web.oidc.principal.extractor.ClaimExtractor;
+import gr.cite.commons.web.oidc.principal.extractor.ClaimExtractorContext;
+import gr.cite.notification.common.enums.IsActive;
+import gr.cite.notification.common.scope.tenant.TenantScope;
+import gr.cite.notification.convention.ConventionService;
+import gr.cite.notification.data.TenantEntity;
+import gr.cite.notification.errorcode.ErrorThesaurusProperties;
+import gr.cite.tools.exception.MyForbiddenException;
+import gr.cite.tools.logging.LoggerService;
+import org.jetbrains.annotations.NotNull;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.lang.NonNull;
+import org.springframework.stereotype.Component;
+import org.springframework.ui.ModelMap;
+import org.springframework.web.context.request.WebRequest;
+import org.springframework.web.context.request.WebRequestInterceptor;
+
+import javax.management.InvalidApplicationException;
+import javax.persistence.EntityManager;
+import javax.persistence.PersistenceContext;
+import javax.persistence.Tuple;
+import javax.persistence.criteria.CriteriaBuilder;
+import javax.persistence.criteria.CriteriaQuery;
+import javax.persistence.criteria.Root;
+import java.util.List;
+import java.util.UUID;
+
+@Component
+public class TenantScopeClaimInterceptor implements WebRequestInterceptor {
+	private static final LoggerService logger = new LoggerService(LoggerFactory.getLogger(TenantScopeClaimInterceptor.class));
+	private final TenantScope tenantScope;
+	private final ConventionService conventionService;
+	private final TenantScopeProperties tenantScopeProperties;
+	private final ErrorThesaurusProperties errorThesaurusProperties;
+	private final ClaimExtractor claimExtractor;
+	private final CurrentPrincipalResolver currentPrincipalResolver;
+	private final String clientTenantClaimName;
+	private final ClaimExtractorContext claimExtractorContext;
+	private final TenantByCodeCacheService tenantByCodeCacheService;
+	private final TenantByIdCacheService tenantByIdCacheService;
+	@PersistenceContext
+	public EntityManager entityManager;
+
+	@Autowired
+	public TenantScopeClaimInterceptor(
+			TenantScope tenantScope,
+			ConventionService conventionService,
+			ClaimExtractor claimExtractor,
+			CurrentPrincipalResolver currentPrincipalResolver,
+			ErrorThesaurusProperties errorThesaurusProperties,
+			TenantScopeProperties tenantScopeProperties,
+			ClaimExtractorContext claimExtractorContext,
+			TenantByCodeCacheService tenantByCodeCacheService,
+			TenantByIdCacheService tenantByIdCacheService
+	) {
+		this.tenantScope = tenantScope;
+		this.conventionService = conventionService;
+		this.currentPrincipalResolver = currentPrincipalResolver;
+		this.claimExtractor = claimExtractor;
+		this.errorThesaurusProperties = errorThesaurusProperties;
+		this.tenantScopeProperties = tenantScopeProperties;
+		this.claimExtractorContext = claimExtractorContext;
+		this.tenantByCodeCacheService = tenantByCodeCacheService;
+		this.tenantByIdCacheService = tenantByIdCacheService;
+		this.clientTenantClaimName = this.tenantScopeProperties.getClientClaimsPrefix() + TenantScope.TenantClaimName;
+	}
+
+	@Override
+	public void preHandle(@NotNull WebRequest request) throws InvalidApplicationException {
+		if (!this.currentPrincipalResolver.currentPrincipal().isAuthenticated()) return;
+		if (!this.tenantScope.isMultitenant()) return;
+
+		MyPrincipal principal = this.currentPrincipalResolver.currentPrincipal();
+		if (principal != null && principal.isAuthenticated() /* principal.Claims.Any() */) {
+			Boolean scoped = this.scopeByPrincipal(this.tenantScope, principal);
+			if (!scoped) scoped = this.scopeByClient(this.tenantScope, principal);
+			if (!scoped && this.tenantScope.isSet() && this.tenantScopeProperties.getEnforceTrustedTenant()) throw new MyForbiddenException(this.errorThesaurusProperties.getMissingTenant().getCode(), this.errorThesaurusProperties.getMissingTenant().getMessage());
+		}
+	}
+
+	private Boolean scopeByPrincipal(TenantScope scope, MyPrincipal principal) {
+		String tenantCode = this.claimExtractor.tenantString(principal);
+		if (tenantCode == null || tenantCode.isBlank()) tenantCode = this.claimExtractor.asString(principal, this.clientTenantClaimName);
+
+		UUID tenantId = this.conventionService.parseUUIDSafe(tenantCode);
+		if (tenantId == null && tenantCode == null) return false;
+		if (tenantId == null) {
+			TenantByCodeCacheService.TenantByCodeCacheValue cacheValue = this.tenantByCodeCacheService.lookup(this.tenantByCodeCacheService.buildKey(tenantCode));
+			if (cacheValue != null) {
+				tenantId = cacheValue.getTenantId();
+			} else {
+				tenantId = this.getTenantIdFromDatabase(tenantCode);
+				this.tenantByCodeCacheService.put(new TenantByCodeCacheService.TenantByCodeCacheValue(tenantCode, tenantId));
+				this.tenantByIdCacheService.put(new TenantByIdCacheService.TenantByIdCacheValue(tenantCode, tenantId));
+			}
+		} else {
+			logger.debug("tenant claim was set to {}", tenantId);
+			TenantByIdCacheService.TenantByIdCacheValue cacheValue = this.tenantByIdCacheService.lookup(this.tenantByIdCacheService.buildKey(tenantId));
+
+			if (cacheValue != null) {
+				tenantCode = cacheValue.getTenantCode();
+			} else {
+				tenantCode = this.getTenantCodeFromDatabase(tenantId);
+				this.tenantByCodeCacheService.put(new TenantByCodeCacheService.TenantByCodeCacheValue(tenantCode, tenantId));
+				this.tenantByIdCacheService.put(new TenantByIdCacheService.TenantByIdCacheValue(tenantCode, tenantId));
+			}
+		}
+
+		if (tenantId != null && tenantCode != null && !tenantCode.isBlank()) {
+			logger.debug("parsed tenant header and set tenant id to {}", tenantId);
+			this.tenantScope.setTenant(tenantId, tenantCode);
+			this.claimExtractorContext.putReplaceParameter(TenantScope.TenantReplaceParameter, tenantCode);
+		}
+		return tenantId != null;
+	}
+
+	private Boolean scopeByClient(TenantScope scope, MyPrincipal principal) throws InvalidApplicationException {
+		String client = this.claimExtractor.client(principal);
+
+		Boolean isWhiteListed = this.tenantScopeProperties.getWhiteListedClients() != null && !this.conventionService.isNullOrEmpty(client) && this.tenantScopeProperties.getWhiteListedClients().contains(client);
+		logger.debug("client is whitelisted : {}, scope is set: {}, with value {}", isWhiteListed, scope.isSet(), (scope.isSet() ? scope.getTenant() : null));
+
+		return isWhiteListed && scope.isSet();
+	}
+
+	private UUID getTenantIdFromDatabase(String tenantCode) {
+		CriteriaBuilder criteriaBuilder = this.entityManager.getCriteriaBuilder();
+		CriteriaQuery<Tuple> query = criteriaBuilder.createQuery(Tuple.class);
+		Root<TenantEntity> root = query.from(TenantEntity.class);
+		query = query.where(
+				criteriaBuilder.and(
+						criteriaBuilder.equal(root.get(TenantEntity._code), tenantCode),
+						criteriaBuilder.equal(root.get(TenantEntity._isActive), IsActive.Active)
+				)
+		).multiselect(root.get(TenantEntity._id).alias(TenantEntity._id));
+		List<Tuple> results = this.entityManager.createQuery(query).getResultList();
+		if (results.size() == 1) {
+			Object o;
+			try {
+				o = results.get(0).get(TenantEntity._id);
+			} catch (IllegalArgumentException e) {
+				return null;
+			}
+			if (o == null) return null;
+			try {
+				return (UUID) o;
+			} catch (ClassCastException e) {
+				return null;
+			}
+		}
+		return null;
+	}
+
+	private String getTenantCodeFromDatabase(UUID tenantId) {
+		CriteriaBuilder criteriaBuilder = this.entityManager.getCriteriaBuilder();
+		CriteriaQuery<Tuple> query = criteriaBuilder.createQuery(Tuple.class);
+		Root<TenantEntity> root = query.from(TenantEntity.class);
+		query = query.where(
+				criteriaBuilder.and(
+						criteriaBuilder.equal(root.get(TenantEntity._id), tenantId),
+						criteriaBuilder.equal(root.get(TenantEntity._isActive), IsActive.Active)
+				)
+		).multiselect(root.get(TenantEntity._code).alias(TenantEntity._code));
+		List<Tuple> results = this.entityManager.createQuery(query).getResultList();
+		if (results.size() == 1) {
+			Object o;
+			try {
+				o = results.get(0).get(TenantEntity._code);
+			} catch (IllegalArgumentException e) {
+				return null;
+			}
+			if (o == null) return null;
+			try {
+				return (String) o;
+			} catch (ClassCastException e) {
+				return null;
+			}
+		}
+		return null;
+	}
+
+	@Override
+	public void postHandle(@NonNull WebRequest request, ModelMap model) {
+		this.tenantScope.setTenant(null, null);
+		this.claimExtractorContext.removeReplaceParameter(TenantScope.TenantReplaceParameter);
+	}
+
+	@Override
+	public void afterCompletion(@NonNull WebRequest request, Exception ex) {
+	}
+}

dmp-backend/notification-service/notification-web/src/main/java/gr/cite/notification/web/scope/tenant/TenantScopeConfiguration.java

@@ -0,0 +1,9 @@
+package gr.cite.notification.web.scope.tenant;
+
+import org.springframework.boot.context.properties.EnableConfigurationProperties;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+@EnableConfigurationProperties(TenantScopeProperties.class)
+public class TenantScopeConfiguration {
+}

dmp-backend/notification-service/notification-web/src/main/java/gr/cite/notification/web/scope/tenant/TenantScopeHeaderInterceptor.java

@@ -0,0 +1,162 @@
+package gr.cite.notification.web.scope.tenant;
+
+
+import gr.cite.commons.web.oidc.principal.CurrentPrincipalResolver;
+import gr.cite.commons.web.oidc.principal.extractor.ClaimExtractorContext;
+import gr.cite.notification.common.enums.IsActive;
+import gr.cite.notification.common.scope.tenant.TenantScope;
+import gr.cite.notification.convention.ConventionService;
+import gr.cite.notification.data.TenantEntity;
+import gr.cite.tools.logging.LoggerService;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.lang.NonNull;
+import org.springframework.stereotype.Component;
+import org.springframework.ui.ModelMap;
+import org.springframework.web.context.request.WebRequest;
+import org.springframework.web.context.request.WebRequestInterceptor;
+
+import javax.management.InvalidApplicationException;
+import javax.persistence.EntityManager;
+import javax.persistence.PersistenceContext;
+import javax.persistence.Tuple;
+import javax.persistence.criteria.CriteriaBuilder;
+import javax.persistence.criteria.CriteriaQuery;
+import javax.persistence.criteria.Root;
+import java.util.List;
+import java.util.UUID;
+
+@Component
+public class TenantScopeHeaderInterceptor implements WebRequestInterceptor {
+	private static final LoggerService logger = new LoggerService(LoggerFactory.getLogger(TenantScopeHeaderInterceptor.class));
+	private final TenantScope tenantScope;
+	private final ConventionService conventionService;
+	private final TenantByCodeCacheService tenantByCodeCacheService;
+	private final TenantByIdCacheService tenantByIdCacheService;
+	private final ClaimExtractorContext claimExtractorContext;
+	private final CurrentPrincipalResolver currentPrincipalResolver;
+	@PersistenceContext
+	public EntityManager entityManager;
+
+	@Autowired
+	public TenantScopeHeaderInterceptor(
+			TenantScope tenantScope,
+			ConventionService conventionService,
+			TenantByCodeCacheService tenantByCodeCacheService,
+			TenantByIdCacheService tenantByIdCacheService,
+			ClaimExtractorContext claimExtractorContext,
+			CurrentPrincipalResolver currentPrincipalResolver
+	) {
+		this.tenantScope = tenantScope;
+		this.conventionService = conventionService;
+		this.tenantByCodeCacheService = tenantByCodeCacheService;
+		this.tenantByIdCacheService = tenantByIdCacheService;
+		this.claimExtractorContext = claimExtractorContext;
+		this.currentPrincipalResolver = currentPrincipalResolver;
+	}
+
+	@Override
+	public void preHandle(WebRequest request) throws InvalidApplicationException {
+		if (!this.currentPrincipalResolver.currentPrincipal().isAuthenticated()) return;
+		if (!this.tenantScope.isMultitenant()) return;
+
+		String tenantCode = request.getHeader(TenantScope.TenantClaimName);
+		logger.debug("retrieved request tenant header is: {header}", tenantCode);
+		if (this.conventionService.isNullOrEmpty(tenantCode)) return;
+
+		UUID tenantId = this.conventionService.parseUUIDSafe(tenantCode);
+		if (tenantId == null && tenantCode == null) return;
+		if (tenantId == null) {
+			TenantByCodeCacheService.TenantByCodeCacheValue cacheValue = this.tenantByCodeCacheService.lookup(this.tenantByCodeCacheService.buildKey(tenantCode));
+			if (cacheValue != null) {
+				tenantId = cacheValue.getTenantId();
+			} else {
+				tenantId = this.getTenantIdFromDatabase(tenantCode);
+				this.tenantByCodeCacheService.put(new TenantByCodeCacheService.TenantByCodeCacheValue(tenantCode, tenantId));
+				this.tenantByIdCacheService.put(new TenantByIdCacheService.TenantByIdCacheValue(tenantCode, tenantId));
+			}
+		} else {
+			TenantByIdCacheService.TenantByIdCacheValue cacheValue = this.tenantByIdCacheService.lookup(this.tenantByIdCacheService.buildKey(tenantId));
+			if (cacheValue != null) {
+				tenantCode = cacheValue.getTenantCode();
+			} else {
+				tenantCode = this.getTenantCodeFromDatabase(tenantId);
+				this.tenantByCodeCacheService.put(new TenantByCodeCacheService.TenantByCodeCacheValue(tenantCode, tenantId));
+				this.tenantByIdCacheService.put(new TenantByIdCacheService.TenantByIdCacheValue(tenantCode, tenantId));
+			}
+		}
+
+		if (tenantId != null && tenantCode != null && !tenantCode.isBlank()) {
+			logger.debug("parsed tenant header and set tenant id to {tenant}", tenantId);
+			this.tenantScope.setTenant(tenantId, tenantCode);
+			this.claimExtractorContext.putReplaceParameter(TenantScope.TenantReplaceParameter, tenantCode);
+		}
+	}
+
+	private UUID getTenantIdFromDatabase(String tenantCode) {
+		CriteriaBuilder criteriaBuilder = this.entityManager.getCriteriaBuilder();
+		CriteriaQuery<Tuple> query = criteriaBuilder.createQuery(Tuple.class);
+		Root<TenantEntity> root = query.from(TenantEntity.class);
+		query = query.where(
+				criteriaBuilder.and(
+						criteriaBuilder.equal(root.get(TenantEntity._code), tenantCode),
+						criteriaBuilder.equal(root.get(TenantEntity._isActive), IsActive.Active)
+				)
+		).multiselect(root.get(TenantEntity._id).alias(TenantEntity._id));
+		List<Tuple> results = this.entityManager.createQuery(query).getResultList();
+		if (results.size() == 1) {
+			Object o;
+			try {
+				o = results.get(0).get(TenantEntity._id);
+			} catch (IllegalArgumentException e) {
+				return null;
+			}
+			if (o == null) return null;
+			try {
+				return UUID.class.cast(o);
+			} catch (ClassCastException e) {
+				return null;
+			}
+		}
+		return null;
+	}
+
+	private String getTenantCodeFromDatabase(UUID tenantId) {
+		CriteriaBuilder criteriaBuilder = this.entityManager.getCriteriaBuilder();
+		CriteriaQuery<Tuple> query = criteriaBuilder.createQuery(Tuple.class);
+		Root<TenantEntity> root = query.from(TenantEntity.class);
+		query = query.where(
+				criteriaBuilder.and(
+						criteriaBuilder.equal(root.get(TenantEntity._id), tenantId),
+						criteriaBuilder.equal(root.get(TenantEntity._isActive), IsActive.Active)
+				)
+		).multiselect(root.get(TenantEntity._code).alias(TenantEntity._code));
+		List<Tuple> results = this.entityManager.createQuery(query).getResultList();
+		if (results.size() == 1) {
+			Object o;
+			try {
+				o = results.get(0).get(TenantEntity._code);
+			} catch (IllegalArgumentException e) {
+				return null;
+			}
+			if (o == null) return null;
+			try {
+				return String.class.cast(o);
+			} catch (ClassCastException e) {
+				return null;
+			}
+		}
+		return null;
+	}
+
+	@Override
+	public void postHandle(@NonNull WebRequest request, ModelMap model) {
+
+		this.tenantScope.setTenant(null, null);
+		this.claimExtractorContext.removeReplaceParameter(TenantScope.TenantReplaceParameter);
+	}
+
+	@Override
+	public void afterCompletion(@NonNull WebRequest request, Exception ex) {
+	}
+}

dmp-backend/notification-service/notification-web/src/main/java/gr/cite/notification/web/scope/tenant/TenantScopeProperties.java

@@ -0,0 +1,43 @@
+package gr.cite.notification.web.scope.tenant;
+
+
+import org.springframework.boot.context.properties.ConfigurationProperties;
+
+import java.util.HashSet;
+import java.util.List;
+
+@ConfigurationProperties(prefix = "tenant.interceptor")
+public class TenantScopeProperties {
+
+	private String clientClaimsPrefix;
+	public String getClientClaimsPrefix() {
+		return clientClaimsPrefix;
+	}
+	public void setClientClaimsPrefix(String clientClaimsPrefix) {
+		this.clientClaimsPrefix = clientClaimsPrefix;
+	}
+
+	private HashSet<String> whiteListedClients;
+	public HashSet<String> getWhiteListedClients() {
+		return whiteListedClients;
+	}
+	public void setWhiteListedClients(HashSet<String> whiteListedClients) {
+		this.whiteListedClients = whiteListedClients;
+	}
+
+	private List<String> whiteListedEndpoints;
+	public List<String> getWhiteListedEndpoints() {
+		return whiteListedEndpoints;
+	}
+	public void setWhiteListedEndpoints(List<String> whiteListedEndpoints) {
+		this.whiteListedEndpoints = whiteListedEndpoints;
+	}
+
+	private Boolean enforceTrustedTenant;
+	public Boolean getEnforceTrustedTenant() {
+		return enforceTrustedTenant;
+	}
+	public void setEnforceTrustedTenant(Boolean enforceTrustedTenant) {
+		this.enforceTrustedTenant = enforceTrustedTenant;
+	}
+}

dmp-backend/notification-service/notification-web/src/main/java/gr/cite/notification/web/scope/tenant/UserAllowedTenantCacheOptions.java

@@ -0,0 +1,10 @@
+package gr.cite.notification.web.scope.tenant;
+
+import gr.cite.tools.cache.CacheOptions;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+@ConfigurationProperties(prefix = "cache.user-allowed-tenant")
+public class UserAllowedTenantCacheOptions extends CacheOptions {
+}

dmp-backend/notification-service/notification-web/src/main/java/gr/cite/notification/web/scope/tenant/UserAllowedTenantCacheService.java

@@ -0,0 +1,90 @@
+package gr.cite.notification.web.scope.tenant;
+
+import gr.cite.notification.event.UserAddedToTenantEvent;
+import gr.cite.notification.event.UserRemovedFromTenantEvent;
+import gr.cite.tools.cache.CacheService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.event.EventListener;
+import org.springframework.stereotype.Service;
+
+import java.util.HashMap;
+import java.util.Locale;
+import java.util.UUID;
+
+@Service
+public class UserAllowedTenantCacheService extends CacheService<UserAllowedTenantCacheService.UserAllowedTenantCacheValue> {
+
+	public static class UserAllowedTenantCacheValue {
+
+		public UserAllowedTenantCacheValue() {
+		}
+
+		public UserAllowedTenantCacheValue(UUID userId, UUID tenantId, boolean isAllowed) {
+			this.userId = userId;
+			this.tenantId = tenantId;
+			this.isAllowed = isAllowed;
+		}
+
+		private UUID userId;
+
+		public UUID getUserId() {
+			return userId;
+		}
+
+		public void setUserId(UUID userId) {
+			this.userId = userId;
+		}
+
+		private UUID tenantId;
+
+		public UUID getTenantId() {
+			return tenantId;
+		}
+
+		public void setTenantId(UUID tenantId) {
+			this.tenantId = tenantId;
+		}
+
+		private boolean isAllowed;
+
+		public boolean isAllowed() {
+			return isAllowed;
+		}
+
+		public void setAllowed(boolean allowed) {
+			isAllowed = allowed;
+		}
+	}
+
+	@Autowired
+	public UserAllowedTenantCacheService(UserAllowedTenantCacheOptions options) {
+		super(options);
+	}
+
+	@EventListener
+	public void handleUserRemovedFromTenantEvent(UserRemovedFromTenantEvent event) {
+		this.evict(this.buildKey(event.getUserId(), event.getTenantId()));
+	}
+
+	@EventListener
+	public void handleUserAddedToTenantEvent(UserAddedToTenantEvent event) {
+		this.evict(this.buildKey(event.getUserId(), event.getTenantId()));
+	}
+
+	@Override
+	protected Class<UserAllowedTenantCacheValue> valueClass() {
+		return UserAllowedTenantCacheValue.class;
+	}
+
+	@Override
+	public String keyOf(UserAllowedTenantCacheValue value) {
+		return this.buildKey(value.getUserId(), value.getTenantId());
+	}
+
+	public String buildKey(UUID userId, UUID tenantId) {
+		return this.generateKey(new HashMap<>() {{
+			put("$user_id$", userId.toString().toLowerCase(Locale.ROOT));
+			put("$tenant_id$", tenantId.toString().toLowerCase(Locale.ROOT));
+		}});
+	}
+}

dmp-backend/notification-service/notification-web/src/main/java/gr/cite/notification/web/scope/user/UserInterceptor.java

@@ -0,0 +1,154 @@
+package gr.cite.notification.web.scope.user;
+
+
+import gr.cite.commons.web.oidc.principal.CurrentPrincipalResolver;
+import gr.cite.commons.web.oidc.principal.extractor.ClaimExtractor;
+import gr.cite.notification.common.enums.IsActive;
+import gr.cite.notification.common.scope.user.UserScope;
+import gr.cite.notification.data.UserEntity;
+import gr.cite.notification.locale.LocaleService;
+import gr.cite.tools.logging.LoggerService;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.lang.NonNull;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.PlatformTransactionManager;
+import org.springframework.transaction.TransactionDefinition;
+import org.springframework.transaction.TransactionStatus;
+import org.springframework.transaction.support.DefaultTransactionDefinition;
+import org.springframework.ui.ModelMap;
+import org.springframework.web.context.request.WebRequest;
+import org.springframework.web.context.request.WebRequestInterceptor;
+
+import javax.management.InvalidApplicationException;
+import javax.persistence.EntityManager;
+import javax.persistence.PersistenceContext;
+import javax.persistence.Tuple;
+import javax.persistence.criteria.CriteriaBuilder;
+import javax.persistence.criteria.CriteriaQuery;
+import javax.persistence.criteria.Root;
+import java.time.Instant;
+import java.util.List;
+import java.util.UUID;
+
+@Component
+public class UserInterceptor implements WebRequestInterceptor {
+	private static final LoggerService logger = new LoggerService(LoggerFactory.getLogger(UserInterceptor.class));
+	private final UserScope userScope;
+	private final ClaimExtractor claimExtractor;
+	private final CurrentPrincipalResolver currentPrincipalResolver;
+	private final LocaleService localeService;
+	private final PlatformTransactionManager transactionManager;
+	private final UserInterceptorCacheService userInterceptorCacheService;
+	@PersistenceContext
+	public EntityManager entityManager;
+
+	@Autowired
+	public UserInterceptor(
+			UserScope userScope,
+			LocaleService localeService,
+			ClaimExtractor claimExtractor,
+			CurrentPrincipalResolver currentPrincipalResolver,
+			PlatformTransactionManager transactionManager,
+			UserInterceptorCacheService userInterceptorCacheService
+	) {
+		this.userScope = userScope;
+		this.localeService = localeService;
+		this.currentPrincipalResolver = currentPrincipalResolver;
+		this.claimExtractor = claimExtractor;
+		this.transactionManager = transactionManager;
+		this.userInterceptorCacheService = userInterceptorCacheService;
+	}
+
+	@Override
+	public void preHandle(WebRequest request) throws InvalidApplicationException {
+		UUID userId = null;
+		if (this.currentPrincipalResolver.currentPrincipal().isAuthenticated()) {
+			String subjectId = this.claimExtractor.subjectString(this.currentPrincipalResolver.currentPrincipal());
+
+			UserInterceptorCacheService.UserInterceptorCacheValue cacheValue = this.userInterceptorCacheService.lookup(this.userInterceptorCacheService.buildKey(subjectId));
+			if (cacheValue != null) {
+				userId = cacheValue.getUserId();
+			} else {
+				userId = this.getUserIdFromDatabase(subjectId);
+				if (userId == null) userId = this.createUser(subjectId);
+
+				this.userInterceptorCacheService.put(new UserInterceptorCacheService.UserInterceptorCacheValue(subjectId, userId));
+			}
+		}
+		this.userScope.setUserId(userId);
+	}
+
+	private UUID getUserIdFromDatabase(String subjectId) throws InvalidApplicationException {
+		CriteriaBuilder criteriaBuilder = this.entityManager.getCriteriaBuilder();
+		CriteriaQuery<Tuple> query = criteriaBuilder.createQuery(Tuple.class);
+		Root<UserEntity> root = query.from(UserEntity.class);
+		query.where(
+				criteriaBuilder.and(
+//						criteriaBuilder.equal(root.get(UserEntity._subjectId), subjectId),
+						criteriaBuilder.equal(root.get(UserEntity._isActive), IsActive.Active)
+				));
+
+		query.multiselect(root.get(UserEntity._id).alias(UserEntity._id));
+
+		List<Tuple> results = this.entityManager.createQuery(query).getResultList();
+		if (results.size() == 1) {
+			Object o;
+			try {
+				o = results.get(0).get(UserEntity._id);
+			} catch (IllegalArgumentException e) {
+				return null;
+			}
+			if (o == null) return null;
+			try {
+				return UUID.class.cast(o);
+			} catch (ClassCastException e) {
+				return null;
+			}
+		}
+		return null;
+	}
+
+	private UUID createUser(String subjectId) {
+		String name = this.claimExtractor.name(this.currentPrincipalResolver.currentPrincipal());
+		String familyName = this.claimExtractor.familyName(this.currentPrincipalResolver.currentPrincipal());
+		if (name == null) name = subjectId;
+		UserEntity user = new UserEntity();
+		user.setId(UUID.randomUUID());
+		user.setCreatedAt(Instant.now());
+		user.setUpdatedAt(Instant.now());
+		user.setName(name);
+//		user.setLastName(familyName == null ? name : familyName);
+		user.setIsActive(IsActive.Active);
+//		user.setSubjectId(subjectId);
+//		user.setCulture(this.localeService.cultureName());
+//		user.setTimezone(this.localeService.timezoneName());
+//		user.setLanguage(this.localeService.language());
+
+		DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
+		definition.setName(UUID.randomUUID().toString());
+		definition.setIsolationLevel(TransactionDefinition.ISOLATION_READ_COMMITTED);
+		definition.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
+		TransactionStatus status = null;
+		try {
+			status = transactionManager.getTransaction(definition);
+			this.entityManager.persist(user);
+
+			this.entityManager.flush();
+			transactionManager.commit(status);
+		} catch (Exception ex) {
+			if (status != null) transactionManager.rollback(status);
+			throw ex;
+		}
+		return user.getId();
+	}
+
+	@Override
+	public void postHandle(@NonNull WebRequest request, ModelMap model) {
+		this.userScope.setUserId(null);
+	}
+
+	@Override
+	public void afterCompletion(@NonNull WebRequest request, Exception ex) {
+	}
+}

dmp-backend/notification-service/notification-web/src/main/java/gr/cite/notification/web/scope/user/UserInterceptorCacheOptions.java

@@ -0,0 +1,10 @@
+package gr.cite.notification.web.scope.user;
+
+import gr.cite.tools.cache.CacheOptions;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+@ConfigurationProperties(prefix = "cache.user-by-subject-id")
+public class UserInterceptorCacheOptions extends CacheOptions {
+}

dmp-backend/notification-service/notification-web/src/main/java/gr/cite/notification/web/scope/user/UserInterceptorCacheService.java

@@ -0,0 +1,77 @@
+package gr.cite.notification.web.scope.user;
+
+import gr.cite.notification.convention.ConventionService;
+import gr.cite.notification.event.UserTouchedEvent;
+import gr.cite.tools.cache.CacheService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.event.EventListener;
+import org.springframework.stereotype.Service;
+
+import java.util.HashMap;
+import java.util.UUID;
+
+@Service
+public class UserInterceptorCacheService extends CacheService<UserInterceptorCacheService.UserInterceptorCacheValue> {
+
+	public static class UserInterceptorCacheValue {
+
+		public UserInterceptorCacheValue() {
+		}
+
+		public UserInterceptorCacheValue(String subjectId, UUID userId) {
+			this.subjectId = subjectId;
+			this.userId = userId;
+		}
+
+		private String subjectId;
+
+		public String getSubjectId() {
+			return subjectId;
+		}
+
+		public void setSubjectId(String subjectId) {
+			this.subjectId = subjectId;
+		}
+
+		private UUID userId;
+
+		public UUID getUserId() {
+			return userId;
+		}
+
+		public void setUserId(UUID userId) {
+			this.userId = userId;
+		}
+	}
+
+	private final ConventionService conventionService;
+
+	@Autowired
+	public UserInterceptorCacheService(UserInterceptorCacheOptions options, ConventionService conventionService) {
+		super(options);
+		this.conventionService = conventionService;
+	}
+
+	@EventListener
+	public void handleUserTouchedEvent(UserTouchedEvent event) {
+		if (!this.conventionService.isNullOrEmpty(event.getSubjectId())) this.evict(this.buildKey(event.getSubjectId()));
+		if (!this.conventionService.isNullOrEmpty(event.getPreviousSubjectId())) this.evict(this.buildKey(event.getPreviousSubjectId()));
+	}
+
+	@Override
+	protected Class<UserInterceptorCacheValue> valueClass() {
+		return UserInterceptorCacheValue.class;
+	}
+
+	@Override
+	public String keyOf(UserInterceptorCacheValue value) {
+		return this.buildKey(value.getSubjectId());
+	}
+
+
+	public String buildKey(String subject) {
+		return this.generateKey(new HashMap<>() {{
+			put("$subject$", subject);
+		}});
+	}
+}

dmp-backend/notification-service/notification-web/src/main/resources/certificates/elasticsearch_dev04.crt

@@ -0,0 +1,20 @@
+-----BEGIN CERTIFICATE-----
+MIIDUjCCAjqgAwIBAgIUKTnOSL0Rtnm8ZQkfSUvpQiBNGnMwDQYJKoZIhvcNAQEL
+BQAwNDEyMDAGA1UEAxMpRWxhc3RpYyBDZXJ0aWZpY2F0ZSBUb29sIEF1dG9nZW5l
+cmF0ZWQgQ0EwHhcNMTkwOTAzMTUyMDM1WhcNMjIwOTAyMTUyMDM1WjAYMRYwFAYD
+VQQDEw1lbGFzdGljc2VhcmNoMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC
+AQEAkB1OMRBRUDUxQ6fIv5gv0myKDZgVJFnEEjIjU6YjMpf/htTsvu8zdpBoWhg6
+7IsflSkUPynDG4geFjQ/WtxVeqxjnmtIB2fMDAHppX882as3tYjBlHj1sU0/OwwI
+Ga5/OtxOubGswrzCEEjIgZwTtSX2Yzx3tE2UzwjWsYwGCBM/ssN8Wc1vlqq20+Qr
+Lsggk+dXapN2wL9FABrxrJfV2SxXb2qKLKVd3EIfs+HVqIt9dVrpcFRV3Lwexg+Z
+wlJv58EPsynphczssBhMOhlmVqpRY8z88fqsbqDVdqHIF8hqn7czWFqeCRldnb7W
+LWaYaOG0Jd6SM7OpHnfNgBST4wIDAQABo3gwdjAdBgNVHQ4EFgQUCkDAcWSJ6H2G
+UFFh9dhk+mG0L08wHwYDVR0jBBgwFoAUDF2zHdVwSwxo9Z7sa9vIc4Sd+1MwKQYD
+VR0RBCIwIIIJbG9jYWxob3N0hwR/AAABgg1lbGFzdGljc2VhcmNoMAkGA1UdEwQC
+MAAwDQYJKoZIhvcNAQELBQADggEBAAQpkdkGl2H0ylgbmmNiIlrQX+U2i4ag4sJ6
+xsVR5OWxuyB/aMWhuOHkgueMh2wElufn60jK0Mh25b2U7oO/0Nq+28rhhP9HURLz
+7/TwCbLcglTAgHQPWItwn5r5WKDFNCPNpZXFU/oG5H6hUJqTvuaTN6G/PQ6V9Yp3
+J00NbPuFq8tjNAc/kQnhC7zdC/7YQ/fanHBPkvQnkGbac5+VAF/se/JYbxRpSz23
+5a+v6BDb/kjs82QgV8dzsyFmntO+Neesu9tTJurBbQD5T3xMgoGSWLgnTCq3/drl
+PMBLgUQHik629dU+7o8ePCdyULruGMR6CIBqO7ZKQASulhkxdUo=
+-----END CERTIFICATE-----

dmp-backend/notification-service/notification-web/src/main/resources/config/application.yml

@@ -0,0 +1,20 @@
+spring:
+  jackson:
+    default-property-inclusion: non_null
+  config:
+    import: optional:classpath:config/app.env[.properties], optional:file:../config/app.env[.properties],
+      optional:classpath:config/db.yml[.yml], optional:classpath:config/db-${spring.profiles.active}.yml[.yml], optional:file:../config/db-${spring.profiles.active}.yml[.yml],
+      optional:classpath:config/permissions.yml[.yml], optional:classpath:config/permissions-${spring.profiles.active}.yml[.yml], optional:file:../config/permissions-${spring.profiles.active}.yml[.yml],
+      optional:classpath:config/errors.yml[.yml], optional:classpath:config/errors-${spring.profiles.active}.yml[.yml], optional:file:../config/errors-${spring.profiles.active}.yml[.yml],
+      optional:classpath:config/security.yml[.yml], optional:classpath:config/security-${spring.profiles.active}.yml[.yml], optional:file:../config/security-${spring.profiles.active}.yml[.yml],
+      optional:classpath:config/server.yml[.yml], optional:classpath:config/server-${spring.profiles.active}.yml[.yml], optional:file:../config/server-${spring.profiles.active}.yml[.yml],
+      optional:classpath:config/logging.yml[.yml], optional:classpath:config/logging-${spring.profiles.active}.yml[.yml], optional:file:../config/logging-${spring.profiles.active}.yml[.yml],
+      optional:classpath:config/idpclaims.yml[.yml], optional:classpath:config/idpclaims-${spring.profiles.active}.yml[.yml], optional:file:../config/idpclaims-${spring.profiles.active}.yml[.yml],
+      optional:classpath:config/cache.yml[.yml], optional:classpath:config/cache-${spring.profiles.active}.yml[.yml], optional:file:../config/cache-${spring.profiles.active}.yml[.yml],
+      optional:classpath:config/tenant.yml[.yml], optional:classpath:config/tenant-${spring.profiles.active}.yml[.yml], optional:file:../config/tenant-${spring.profiles.active}.yml[.yml],
+      optional:classpath:config/locale.yml[.yml], optional:classpath:config/locale-${spring.profiles.active}.yml[.yml], optional:file:../config/locale-${spring.profiles.active}.yml[.yml],
+      optional:classpath:config/cors.yml[.yml], optional:classpath:config/cors-${spring.profiles.active}.yml[.yml], optional:file:../config/cors-${spring.profiles.active}.yml[.yml],
+      optional:classpath:config/notification.yml[.yml], optional:classpath:config/notification-${spring.profiles.active}.yml[.yml], optional:file:../config/notification-${spring.profiles.active}.yml[.yml],
+      optional:classpath:config/email.yml[.yml], optional:classpath:config/email-${spring.profiles.active}.yml[.yml], optional:file:../config/email-${spring.profiles.active}.yml[.yml],
+      optional:classpath:config/cipher.yml[.yml], optional:classpath:config/cipher-${spring.profiles.active}.yml[.yml], optional:file:../config/cipher-${spring.profiles.active}.yml[.yml],
+      optional:classpath:config/formatting.yml[.yml], optional:classpath:config/formatting-${spring.profiles.active}.yml[.yml], optional:file:../config/formatting-${spring.profiles.active}.yml[.yml]

dmp-backend/notification-service/notification-web/src/main/resources/config/cache.yml

@@ -0,0 +1,77 @@
+cache:
+  manager:
+    fallbackToNoOpCache: true
+    caffeineCaches:
+      - names: [ apikey ]
+        allowNullValues: true
+        initialCapacity: 100
+        maximumSize: 500
+        enableRecordStats: false
+        expireAfterWriteMinutes: 10
+        expireAfterAccessMinutes: 10
+        refreshAfterWriteMinutes: 10
+      - names: [ tenantByCode ]
+        allowNullValues: true
+        initialCapacity: 100
+        maximumSize: 500
+        enableRecordStats: false
+        expireAfterWriteMinutes: 10
+        expireAfterAccessMinutes: 10
+        refreshAfterWriteMinutes: 10
+      - names: [ tenantById ]
+        allowNullValues: true
+        initialCapacity: 100
+        maximumSize: 500
+        enableRecordStats: false
+        expireAfterWriteMinutes: 10
+        expireAfterAccessMinutes: 10
+        refreshAfterWriteMinutes: 10
+      - names: [ userBySubjectId ]
+        allowNullValues: true
+        initialCapacity: 100
+        maximumSize: 500
+        enableRecordStats: false
+        expireAfterWriteMinutes: 5
+        expireAfterAccessMinutes: 5
+        refreshAfterWriteMinutes: 5
+      - names: [ userAccessTenant ]
+        allowNullValues: true
+        initialCapacity: 100
+        maximumSize: 500
+        enableRecordStats: false
+        expireAfterWriteMinutes: 5
+        expireAfterAccessMinutes: 5
+        refreshAfterWriteMinutes: 5
+      - names: [ formattingUserProfile ]
+        allowNullValues: true
+        initialCapacity: 100
+        maximumSize: 500
+        enableRecordStats: false
+        expireAfterWriteMinutes: 1
+        expireAfterAccessMinutes: 1
+        refreshAfterWriteMinutes: 1
+    mapCaches:
+      - names: [ cacheB ]
+        allowNullValues: true
+        storeByValue: true
+  apiKey:
+    name: apikey
+    keyPattern: resolve_$keyhash$:v0
+  userBySubjectId:
+    name: userBySubjectId
+    keyPattern: user_by_subject_$subject$:v0
+  tenantByCode:
+    name: tenantByCode
+    keyPattern: tenant_by_code_$code$:v0
+  tenantById:
+    name: tenantById
+    keyPattern: tenant_by_id_$tenantId$:v0
+  userAllowedTenant:
+    name: userAccessTenant
+    keyPattern: user_access_tenant_$user_id$_$tenant_id$:v0
+  formattingUserProfileCache:
+    name: formattingUserProfile
+    keyPattern: formatting_user_profile$user_id$:v0
+  template:
+    name: template
+    key-pattern: ------

dmp-backend/notification-service/notification-web/src/main/resources/config/cipher.yml

@@ -0,0 +1,35 @@
+cipher-profiles:
+  profile-map:
+    configuration-profile-name: "configuration"
+    queue-profile-name: "queue"
+    notification-profile-name: "queue"
+
+cipher:
+#  salted-hash:
+#    default-o: null
+#    options: null
+  symetric-encryption:
+    default-o: null
+    options:
+      configuration:
+        aes:
+          key: ${CIPHER_SYMETRIC_ENCRYPTION_CONFIGURATION_AES_KEY:}
+          iv: ${CIPHER_SYMETRIC_ENCRYPTION_CONFIGURATION_AES_IV:}
+      queue:
+        aes:
+          key: ${CIPHER_SYMETRIC_ENCRYPTION_QUEUE_AES_KEY:}
+          iv: ${CIPHER_SYMETRIC_ENCRYPTION_QUEUE_AES_IV:}
+  masking:
+    default: null
+    options:
+      configuration:
+        character: "*"
+        clear-begining: 2
+        clear-ending: 4
+        at-least-percentage: 70
+  digital-signature:
+    default: null
+    options:
+      configuration:
+        certificate-path: null
+        certificate-password: null

dmp-backend/notification-service/notification-web/src/main/resources/config/cors-devel.yml

@@ -0,0 +1,3 @@
+web:
+  cors:
+    allowed-origins: [ http://localhost, http://localhost:4200 ]

dmp-backend/notification-service/notification-web/src/main/resources/config/cors.yml

@@ -0,0 +1,7 @@
+web:
+  cors:
+    enabled: true
+    allowed-methods: [ HEAD, GET, POST, PUT, DELETE, PATCH ]
+    allowed-headers: [ Authorization, Cache-Control, Content-Type, Content-Disposition, x-tenant ]
+    exposed-headers: [ Authorization, Cache-Control, Content-Type, Content-Disposition ]
+    allow-credentials: false

dmp-backend/notification-service/notification-web/src/main/resources/config/db-devel.yml

@@ -0,0 +1,7 @@
+spring:
+  jpa:
+    show-sql: true
+    properties:
+      hibernate:
+        show_sql: true
+        format_sql: false

dmp-backend/notification-service/notification-web/src/main/resources/config/db.yml

@@ -0,0 +1,21 @@
+spring:
+  jpa:
+    properties:
+      hibernate:
+        ddl-auto: validate
+        dialect: org.hibernate.dialect.PostgreSQLDialect
+    hibernate:
+      naming:
+        physical-strategy: org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl
+        implicit-strategy: org.springframework.boot.orm.jpa.hibernate.SpringImplicitNamingStrategy
+  datasource:
+    url: ${DB_CONNECTION_STRING}
+    username: ${DB_USER}
+    password: ${DB_PASSWORD}
+    driver-class-name: org.postgresql.Driver
+    hikari:
+      connection-timeout: 30000
+      minimum-idle: 3
+      maximum-pool-size: 5
+      idle-timeout: 600000
+      max-lifetime: 1800000

dmp-backend/notification-service/notification-web/src/main/resources/config/email.yml

@@ -0,0 +1,14 @@
+spring:
+  mail:
+    host: ${MAIL_HOST:}
+    port: ${MAIL_PORT:}
+    username: ${MAIL_USERNAME:}
+    password: ${MAIL_PASSWORD:}
+    properties:
+      mail:
+        smtp:
+          auth: ${MAIL_AUTH:}
+          starttls:
+            enable: ${MAIL_TLS:}
+email:
+  address: ${MAIL_ADDRESS:}

dmp-backend/notification-service/notification-web/src/main/resources/config/errors.yml

@@ -0,0 +1,43 @@
+error-thesaurus:
+  hash-conflict:
+    code: 100
+    message: there is a hash conflict for the item modified. please reload to get the latest changes
+  forbidden:
+    code: 101
+    message: insufficient rights
+  system-error:
+    code: 102
+    message: an unexpected system error occurred
+  missing-tenant:
+    code: 103
+    message: tenant scope not provided
+  invalid-api-key:
+    code: 104
+    message: provided APIKey not valid
+  stale-api-key:
+    code: 105
+    message: there was a problem authorizing you with your API key. Please try again. Contact the system administrator if the problem persists
+  model-validation:
+    code: 106
+    message: validation error
+  sensitive-info:
+    code: 107
+    message: you are attempting to access sensitive information. please don't do that
+  non-person-principal:
+    code: 108
+    message: the operation is available only to person users
+  blocking-consent:
+    code: 113
+    message: user consents are not sufficient to complete the operation
+  single-tenant-configuration-per-type-supported:
+    code: 116
+    message: a single tenant configuration entry per config type is supported
+  incompatible-tenant-configuration-types:
+    code: 117
+    message: the provided tenant configuration type is incompatible
+  missing-totp-token:
+    code: 118
+    message: totp token not provided
+  overlapping-tenant-configuration-notifier-list:
+    code: 119
+    message: Overlapping Tenant Configuration Notifier List

dmp-backend/notification-service/notification-web/src/main/resources/config/formatting.yml

@@ -0,0 +1,6 @@
+formatting:
+  options:
+    integer-format: "%,d"
+    decimal-digits-round: 2
+    decimal-format: "#0.00"
+    date-time-format: "YYYY-MM-dd'T'HH:mm:ss"

dmp-backend/notification-service/notification-web/src/main/resources/config/idpclaims.yml

@@ -0,0 +1,50 @@
+idpclient:
+  claims:
+    mapping:
+      Subject:
+        - type: sub
+      Name:
+        - type: name
+      Client:
+        - type: client_id
+      AuthenticationMethod:
+        - type: amr
+      NotBefore:
+        - type: nbf
+      AuthenticatedAt:
+        - type: auth_time
+      ExpiresAt:
+        - type: exp
+      Email:
+        - type: email
+      Roles:
+        - type: resource_access
+          path: intelcomp-sti-viewer-dev.roles
+        - type: authorities
+          filterBy: "(.*):::TenantCode::"
+          extractByExpression: "(.*):(.*)"
+          extractExpressionValue: "[[g1]]"
+      Scope:
+        - type: scope
+      AccessToken:
+        - type: x-access-token
+          visibility: SENSITIVE
+      Tenant:
+        - type: x-tenant
+      IssuedAt:
+        - type: iat
+      Issuer:
+        - type: iss
+      Audience:
+        - type: aud
+      TokenType:
+        - type: typ
+      AuthorizedParty:
+        - type: azp
+      Authorities:
+        - type: authorities
+      TenantCodes:
+        - type: authorities
+          filterBy: "(.*):(.*)"
+          extractByExpression: "(.*):(.*)"
+          extractExpressionValue: "[[g2]]"

dmp-backend/notification-service/notification-web/src/main/resources/config/locale.yml

@@ -0,0 +1,4 @@
+locale:
+  timezone: UTC
+  language: en
+  culture: en-US

dmp-backend/notification-service/notification-web/src/main/resources/config/logging-devel.yml

@@ -0,0 +1,2 @@
+logging:
+  config: classpath:logging/logback-dev.xml

dmp-backend/notification-service/notification-web/src/main/resources/config/logging.yml

@@ -0,0 +1,35 @@
+logging:
+  context:
+    request:
+      requestIdKey: req.id
+      requestRemoteHostKey: req.remoteHost
+      requestUriKey: req.requestURI
+      requestQueryStringKey: req.queryString
+      requestUrlKey : req.requestURL
+      requestMethodKey: req.method
+      requestUserAgentKey: req.userAgent
+      requestForwardedForKey: req.xForwardedFor
+      requestSchemeKey: req.scheme
+      requestRemoteAddressKey: req.remoteAddr
+      requestRemotePortKey: req.remotePort
+      requestRemoteUserKey: req.remoteUser
+    principal:
+      subjectKey: usr.subject
+      nameKey: usr.name
+      clientKey: usr.client
+audit:
+  enable: true
+  requestRemoteHostKey: req.remoteHost
+  requestUriKey: req.requestURI
+  requestQueryStringKey: req.queryString
+  requestUrlKey : req.requestURL
+  requestMethodKey: req.method
+  requestUserAgentKey: req.userAgent
+  requestForwardedForKey: req.xForwardedFor
+  requestSchemeKey: req.scheme
+  requestRemoteAddressKey: req.remoteAddr
+  requestRemotePortKey: req.remotePort
+  requestRemoteUserKey: req.remoteUser
+  principalSubjectKey: usr.subject
+  principalNameKey: usr.name
+  principalClientKey: usr.client

dmp-backend/notification-service/notification-web/src/main/resources/config/notification-devel.yml

@@ -0,0 +1,6 @@
+notification:
+  staticFields:
+    fields: 
+      - key: "{installation-url}"
+        type: "String"
+        value: "http://localhost:42000"

dmp-backend/notification-service/notification-web/src/main/resources/config/notification.yml

@@ -0,0 +1,246 @@
+notification:
+  task:
+    processor:
+      enable: true
+      interval-seconds: 30
+      options:
+        retry-threshold: 300
+        max-retry-delay-seconds: 10800
+        too-old-to-send-seconds: 36000
+        too-old-to-track-seconds: 604800
+      overrides: []
+  resolver:
+    global-policies: 
+        - #Confirmation
+          type: 4FDBFA80-7A71-4A69-B854-67CBB70648F1
+          contacts: [ email ]
+        - #DataManagementPlan
+          type: 065DEECD-21BB-44AF-9983-E660FDF24BC4
+          contacts: [ email ]
+        - #Finalised
+          type: 90DB0B46-42DE-BD89-AEBF-6F27EFEB256E
+          contacts: [ email ]
+        - #MergeConfirmation
+          type: BFE68845-CB05-4C5A-A03D-29161A7C9660
+          contacts: [ email ]
+        - #Modified
+          type: 4542262A-22F8-4BAA-9DB6-1C8E70AC1DBB
+          contacts: [ email ]
+        - #ModifiedFinalised
+          type: D3CD55FE-8DA2-42E7-A501-3795EE4F16D3
+          contacts: [ email ]
+        - #Publish
+          type: 55736F7A-83AB-4190-AF43-9D031A6F9612
+          contacts: [ email ]
+        - #Template
+          type: 223BB607-EFA1-4CE7-99EC-4BEABFEF9A8B
+          contacts: [ email ]
+        - #UnlinkConfirmation
+          type: C9BC3F16-057E-4BBA-8A5F-36BD835E5604
+          contacts: [ email ]
+  ad-hoc-config:
+    ad-hoc-notification-type: null
+  message:
+    email:
+      flows:
+          - #Confirmation
+            key: 4FDBFA80-7A71-4A69-B854-67CBB70648F1
+            subject-path: classpath:notification_templates/Confirmation/Email/subject.{language}.txt
+            subject-field-options:
+              mandatory: [ ]
+              optional: [ ]
+
+            body-path: classpath:notification_templates/Confirmation/Email/body.{language}.html
+            body-field-options:
+              mandatory: [ ]
+              optional:
+                  - key: "{expiration_time}"
+                    value: --
+              formatting:
+                '[{expiration_time}]': null
+            cc: [ ]
+            cc-mode: 0
+            bcc: [ ]
+            bcc-mode: 0
+            allow-attachments: false
+            cipher-fields: [ ]
+          -  #DataManagementPlan
+            key: 065DEECD-21BB-44AF-9983-E660FDF24BC4
+            subject-path: classpath:notification_templates/DataManagementPlan/Email/subject.{language}.txt
+            subject-field-options:
+              mandatory: [ ]
+              optional: [ ]
+            body-path: classpath:notification_templates/DataManagementPlan/Email/body.{language}.html
+            body-field-options:
+              mandatory: [ "{dmpname}", "{dmprole}" ]
+              optional:
+                - key: "{recipient}"
+                  value:
+              formatting:
+                '[{dmpname}]': null
+                '[{dmprole}]': null
+                '[{recipient}]': null
+            cc: [ ]
+            cc-mode: 0
+            bcc: [ ]
+            bcc-mode: 0
+            allow-attachments: false
+            cipher-fields: [ ]
+          -   #Finalised
+            key: 90DB0B46-42DE-BD89-AEBF-6F27EFEB256E
+            subject-path: classpath:notification_templates/Finalised/Email/subject.{language}.txt
+            subject-field-options:
+              mandatory: [ ]
+              optional: [ ]
+            body-path: classpath:notification_templates/Finalised/Email/body.{language}.html
+            body-field-options:
+              mandatory: [ "{reasonName}", "{name}" ]
+              optional:
+                - key: "{recipient}"
+                  value:
+              formatting:
+                '[{reasonName}]': null
+                '[{name}]': null
+                '[{recipient}]': null
+            cc: [ ]
+            cc-mode: 0
+            bcc: [ ]
+            bcc-mode: 0
+            allow-attachments: false
+            cipher-fields: [ ]
+          -  #MergeConfirmation
+            key: BFE68845-CB05-4C5A-A03D-29161A7C9660
+            subject-path: classpath:notification_templates/MergeConfirmation/Email/subject.{language}.txt
+            subject-field-options:
+              mandatory: [ ]
+              optional: [ ]
+            body-path: classpath:notification_templates/MergeConfirmation/Email/body.{language}.html
+            body-field-options:
+              mandatory: [ "{userName}", "{host}" ]
+              optional:
+                - key: "{expiration_time}"
+                  value: ---
+              formatting:
+                '[{userName}]': null
+                '[{host}]': null
+                '[{expiration_time}]': null
+            cc: [ ]
+            cc-mode: 0
+            bcc: [ ]
+            bcc-mode: 0
+            allow-attachments: false
+            cipher-fields: [ ]
+          -   #Modified
+            key: 4542262A-22F8-4BAA-9DB6-1C8E70AC1DBB
+            subject-path: classpath:notification_templates/Modified/Email/subject.{language}.txt
+            subject-field-options:
+              mandatory: [ ]
+              optional: [ ]
+            body-path: classpath:notification_templates/Modified/Email/body.{language}.html
+            body-field-options:
+              mandatory: [ "{reasonName}", "{name}" ]
+              optional:
+                - key: "{recipient}"
+                  value:
+              formatting:
+                '[{reasonName}]': null
+                '[{name}]': null
+                '[{recipient}]': null
+            cc: [ ]
+            cc-mode: 0
+            bcc: [ ]
+            bcc-mode: 0
+            allow-attachments: false
+            cipher-fields: [ ]
+          -    #ModifiedFinalised
+            key: D3CD55FE-8DA2-42E7-A501-3795EE4F16D3
+            subject-path: classpath:notification_templates/ModifiedFinalised/Email/subject.{language}.txt
+            subject-field-options:
+              mandatory: [ ]
+              optional: [ ]
+            body-path: classpath:notification_templates/ModifiedFinalised/Email/body.{language}.html
+            body-field-options:
+              mandatory: [ "{reasonName}", "{name}" ]
+              optional:
+                - key: "{recipient}"
+                  value:
+              formatting:
+                '[{reasonName}]': null
+                '[{name}]': null
+                '[{recipient}]': null
+            cc: [ ]
+            cc-mode: 0
+            bcc: [ ]
+            bcc-mode: 0
+            allow-attachments: false
+            cipher-fields: [ ]
+          -   #Publish
+            key: 55736F7A-83AB-4190-AF43-9D031A6F9612
+            subject-path: classpath:notification_templates/Publish/Email/subject.{language}.txt
+            subject-field-options:
+              mandatory: [ ]
+              optional: [ ]
+            body-path: classpath:notification_templates/Publish/Email/body.{language}.html
+            body-field-options:
+              mandatory: [ "{reasonName}", "{name}" ]
+              optional:
+                - key: "{recipient}"
+                  value:
+              formatting:
+                '[{reasonName}]': null
+                '[{name}]': null
+                '[{recipient}]': null
+            cc: [ ]
+            cc-mode: 0
+            bcc: [ ]
+            bcc-mode: 0
+            allow-attachments: false
+            cipher-fields: [ ]
+          -    #Template
+            key: 223BB607-EFA1-4CE7-99EC-4BEABFEF9A8B
+            subject-path: classpath:notification_templates/Template/Email/subject.{language}.txt
+            subject-field-options:
+              mandatory: [ ]
+              optional: [ ]
+            body-path: classpath:notification_templates/Template/Email/body.{language}.html
+            body-field-options:
+              mandatory: [ "{templateName}" ]
+              optional:
+                - key: "{recipient}"
+                  value:
+              formatting:
+                '[{templateName}]': null
+                '[{recipient}]': null
+            cc: [ ]
+            cc-mode: 0
+            bcc: [ ]
+            bcc-mode: 0
+            allow-attachments: false
+            cipher-fields: [ ]
+          -    #UnlinkConfirmation
+            key: C9BC3F16-057E-4BBA-8A5F-36BD835E5604
+            subject-path: classpath:notification_templates/UnlinkConfirmation/Email/subject.{language}.txt
+            subject-field-options:
+              mandatory: [ ]
+              optional: [ ]
+            body-path: classpath:notification_templates/UnlinkConfirmation/Email/body.{language}.html
+            body-field-options:
+              mandatory: [ ]
+              optional:
+                - key: "{email}"
+                  value:
+              formatting:
+                '[{email}]': null
+            cc: [ ]
+            cc-mode: 0
+            bcc: [ ]
+            bcc-mode: 0
+            allow-attachments: false
+            cipher-fields: [ ]
+      template-cache:
+        prefix: ${CACHE_DISAMBIGUATION:}
+        key-pattern: "{prefix}:Notification_Message_Email_Template:{key}:v0"
+  override-cache:
+    template-cache:
+      prefix: ${CACHE_DISAMBIGUATION:}
+      key-pattern: "{prefix}:Notification_Override_Template:{tenant}:{type}:{channel}:{{language}}:v0"

dmp-backend/notification-service/notification-web/src/main/resources/config/permissions.yml

@@ -0,0 +1,143 @@
+permissions:
+  extendedClaims: [ ]
+  policies:
+
+    # Tenants
+    BrowseTenant:
+      roles:
+        - ic-sti-superuser
+      clients: [ ]
+      allowAnonymous: false
+      allowAuthenticated: false
+    EditTenant:
+      roles:
+        - ic-sti-superuser
+      clients: [ ]
+      allowAnonymous: false
+      allowAuthenticated: false
+    DeleteTenant:
+      roles:
+        - ic-sti-superuser
+      claims: [ ]
+      clients: [ ]
+      allowAnonymous: false
+      allowAuthenticated: false
+    AllowNoTenant:
+      roles:
+        - ic-sti-superuser
+      claims: [ ]
+      clients: [ ]
+      allowAnonymous: false
+      allowAuthenticated: false
+    # Users
+    BrowseUser:
+      roles:
+        - ic-sti-superuser
+        - tenantadmin
+      clients: [ ]
+      allowAnonymous: true
+      allowAuthenticated: false
+    EditUser:
+      roles:
+        - admin
+        - ic-sti-superuser
+      clients: [ ]
+      allowAnonymous: false
+      allowAuthenticated: false
+    DeleteUser:
+      roles:
+        - ic-sti-superuser
+      claims: [ ]
+      clients: [ ]
+      allowAnonymous: false
+      allowAuthenticated: false
+    # UserContactInfo
+    BrowseUserContactInfo:
+      roles:
+        - ic-sti-superuser
+      clients: [ ]
+      allowAnonymous: true
+      allowAuthenticated: false
+    EditUserContactInfo:
+      roles:
+        - ic-sti-superuser
+        - user
+      clients: [ ]
+      allowAnonymous: false
+      allowAuthenticated: false
+    DeleteUserContactInfo:
+      roles:
+        - ic-sti-superuser
+      claims: [ ]
+      clients: [ ]
+      allowAnonymous: false
+      allowAuthenticated: false
+    #Notification
+    BrowseNotification:
+      roles:
+        - ic-sti-superuser
+        - user
+      clients: [ ]
+      allowAnonymous: true
+      allowAuthenticated: false
+    EditNotification:
+      roles:
+        - ic-sti-superuser
+        - user
+      clients: [ ]
+      allowAnonymous: true
+      allowAuthenticated: false
+    #Tenant Configuration
+    BrowseTenantConfiguration:
+      roles:
+        - ic-sti-superuser
+      clients: [ ]
+      allowAnonymous: false
+      allowAuthenticated: false
+    EditTenantConfiguration:
+      roles:
+        - ic-sti-superuser
+      clients: [ ]
+      allowAnonymous: false
+      allowAuthenticated: false
+    #User Notification Preference
+    BrowseUserNotificationPreference:
+      roles:
+        - ic-sti-superuser
+      clients: [ ]
+      allowAnonymous: true
+      allowAuthenticated: false
+    EditUserNotificationPreference:
+      roles:
+        - ic-sti-superuser
+        - user
+      clients: [ ]
+      allowAnonymous: false
+      allowAuthenticated: false
+  
+    # ViewPage Permissions
+    ViewNotificationPage:
+      roles:
+        - ic-sti-superuser
+      clients: [ ]
+      allowAnonymous: false
+      allowAuthenticated: false
+    ViewNotificationEventRulePage:
+      roles:
+        - ic-sti-superuser
+      clients: [ ]
+      allowAnonymous: false
+      allowAuthenticated: false
+    ViewInAppNotificationPage:
+      roles:
+        - ic-sti-superuser
+        - tenantadmin
+      clients: [ ]
+      allowAnonymous: false
+      allowAuthenticated: false
+    ViewNotificationTemplatePage:
+      roles:
+        - ic-sti-superuser
+      clients: [ ]
+      allowAnonymous: false
+      allowAuthenticated: false

dmp-backend/notification-service/notification-web/src/main/resources/config/queue-devel.yml

@@ -0,0 +1,18 @@
+queue:
+  rabbitmq:
+    durable: true
+    queue: cite_dmp_devel_notification_inbox_queue
+    exchange: cite_dmp_devel_queue
+    listenerEnabled: true
+    publisherEnabled: true
+  task:
+    publisher:
+      options:
+        exchange: cite_dmp_devel_queue
+      rabbitmq:
+        enable: true
+    listener:
+      options:
+        exchange: cite_dmp_devel_queue
+      rabbitmq:
+        enable: false

dmp-backend/notification-service/notification-web/src/main/resources/config/queue.yml

@@ -0,0 +1,58 @@
+spring:
+  rabbitmq:
+    host: ${RABBIT_HOST}
+    port: ${RABBIT_PORT}
+    username: ${RABBIT_USER}
+    password: ${RABBIT_PASS}
+    ssl:
+      enabled: false
+queue:
+  rabbitmq:
+    enable: false
+    app-id: ${THE_API_ID}
+    durable: null
+    queue: null
+    exchange: null
+    listenerEnabled: true
+    publisherEnabled: true
+    #TODO
+    connection-recovery:
+      enable: true
+      network-recovery-interval: 5000
+      unreachable-recovery-interval: 5000
+  task:
+    publisher:
+      enable: false
+      options:
+        exchange: null
+        forget-me-completed-topic: forgetme.completed
+        notify-topic: notification.notify
+        tenant-reactivation-topic: tenant.reactivated
+        tenant-removal-topic: tenant.remove
+        tenant-touch-topic: tenant.touch
+        tenant-user-invite-topic: tenant.invite
+        what-you-know-about-me-completed-topic: whatyouknowaboutme.completed
+        generate-file-topic: generate.file
+      rabbitmq:
+        enable: false
+        interval-seconds: 30
+        options:
+          retry-threashold: 100
+          retry-delay-step-seconds: 300
+          max-retry-delay-seconds: 10800
+          too-old-to-send-seconds: 604800
+          confirm-timeout-seconds: 30
+    listener:
+      enable: false
+      options:
+        exchange: null
+        user-removal-topic: [ "user.remove" ]
+        user-touched-topic: [ "user.touch" ]
+      rabbitmq:
+        enable: false
+        interval-seconds: 30
+        options:
+          retry-threashold: 100
+          retry-delay-step-seconds: 300
+          max-retry-delay-seconds: 10800
+          too-old-to-send-seconds: 604800

dmp-backend/notification-service/notification-web/src/main/resources/config/security.yml

@@ -0,0 +1,20 @@
+web:
+  security:
+    enabled: true
+    authorized-endpoints: [ api ]
+    allowed-endpoints: [ public, dataset, master-item, test ]
+    idp:
+      api-key:
+        enabled: true
+        authorization-header: Authorization
+        client-id: ${IDP_APIKEY_CLIENT_ID}
+        client-secret: ${IDP_APIKEY_CLIENT_SECRET}
+        scope: ${IDP_APIKEY_SCOPE}
+      resource:
+        token-type: JWT
+        opaque:
+          client-id: ${IDP_OPAQUE_CLIENT_ID}
+          client-secret: ${IDP_OPAQUE_CLIENT_SECRET}
+        jwt:
+          claims: [ role, x-role ]
+          issuer-uri: ${IDP_ISSUER_URI:}

dmp-backend/notification-service/notification-web/src/main/resources/config/server-devel.yml

@@ -0,0 +1,2 @@
+server:
+  forward-headers-strategy: FRAMEWORK

dmp-backend/notification-service/notification-web/src/main/resources/config/server.yml

@@ -0,0 +1,3 @@
+server:
+  port: ${WEB_PORT}
+  forward-headers-strategy: NONE

dmp-backend/notification-service/notification-web/src/main/resources/config/tenant.yml

@@ -0,0 +1,8 @@
+tenant:
+  multitenancy:
+    is-multitenant: false
+  interceptor:
+    client-claims-prefix: client_
+    white-listed-clients: [ ]
+    enforce-trusted-tenant: false
+    white-listed-endpoints: [ '/api/principal/my-tenants',  '/api/principal/me','/api/user/user-settings', '/error', '/api/tenant-request' ]

dmp-backend/notification-service/notification-web/src/main/resources/logging/logback-dev.xml

@@ -0,0 +1,61 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration debug="true">
+	<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+		<encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
+			<Pattern>%date{ISO8601} [%thread] %-5level %logger{36} [%X{req.id}] - %message%n</Pattern>
+		</encoder>
+	</appender>
+
+	<appender name="TROUBLESHOOTING" class="ch.qos.logback.core.rolling.RollingFileAppender">
+		<file>logs/logging.log</file>
+		<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+			<fileNamePattern>logs/logging.%d{yyyy-MM-dd}.%i.log</fileNamePattern>
+			<timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
+				<maxFileSize>100MB</maxFileSize>
+			</timeBasedFileNamingAndTriggeringPolicy>
+			<maxHistory>15</maxHistory>
+		</rollingPolicy>
+		<encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
+			<Pattern>%date{ISO8601} [%thread] %-5level %logger{36} [%X{req.id}] - %message%n</Pattern>
+		</encoder>
+	</appender>
+
+	<appender name="AUDITING" class="ch.qos.logback.core.rolling.RollingFileAppender">
+		<file>logs/auditing.log</file>
+		<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+			<fileNamePattern>logs/auditing.%d{yyyy-MM-dd}.%i.log</fileNamePattern>
+			<timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
+				<maxFileSize>100MB</maxFileSize>
+			</timeBasedFileNamingAndTriggeringPolicy>
+			<maxHistory>15</maxHistory>
+		</rollingPolicy>
+		<encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
+			<Pattern>%date{ISO8601} - %X{req.id} - %message%n</Pattern>
+		</encoder>
+	</appender>
+
+	<logger name="org.springframework.web" level="INFO" additivity="false">
+		<appender-ref ref="TROUBLESHOOTING"/>
+		<appender-ref ref="STDOUT"/>
+	</logger>
+	<logger name="org.hibernate" level="INFO" additivity="false">
+		<appender-ref ref="TROUBLESHOOTING"/>
+		<appender-ref ref="STDOUT"/>
+	</logger>
+	<logger name="gr.cite" level="DEBUG" additivity="false">
+		<appender-ref ref="TROUBLESHOOTING"/>
+		<appender-ref ref="STDOUT"/>
+	</logger>
+	<logger name="org.springframework.data.elasticsearch.client.WIRE" level="TRACE" additivity="false">
+		<appender-ref ref="TROUBLESHOOTING"/>
+		<appender-ref ref="STDOUT"/>
+	</logger>
+	<logger name="audit" level="INFO" additivity="false">
+		<appender-ref ref="AUDITING"/>
+		<appender-ref ref="STDOUT"/>
+	</logger>
+	<root level="info">
+		<appender-ref ref="TROUBLESHOOTING"/>
+		<appender-ref ref="STDOUT"/>
+	</root>
+</configuration>

dmp-backend/notification-service/notification-web/src/main/resources/messages/messages.properties

@@ -0,0 +1,7 @@
+validation.empty=Value cannot be empty
+validation.hashempty=Hash must be set
+validation.lowerthanmin=Value must be larger than {value}
+validation.largerthanmax=Value must be less than {value}
+validation.invalidid=Not valid id
+General_ItemNotFound=Item {0} of type {1} not found
+Validation_Required={0} is required

dmp-backend/notification-service/notification-web/src/main/resources/messages/messages_el.properties

@@ -0,0 +1,6 @@
+validation.empty=el-Value cannot be empty
+validation.hashempty=el-Hash must be set
+validation.lowerthanmin=el-Value must be larger than {value}
+validation.largerthanmax=el-Value must be less than {value}
+validation.invalidid=el-Not valid id
+General_ItemNotFound=el-Item {0} of type {1} not found

dmp-backend/notification-service/notification-web/src/main/resources/notification_templates/Confirmation/Email/subject.en.txt

@@ -0,0 +1 @@
+ARGOS - Email Confirmation

dmp-backend/notification-service/notification-web/src/main/resources/notification_templates/DataManagementPlan/Email/body.en.html

@@ -0,0 +1,305 @@
+<!doctype html>
+<html>
+<head>
+    <meta name="viewport" content="width=device-width" />
+    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
+    <title>Simple Transactional Email</title>
+    <style>
+      /* -------------------------------------
+          GLOBAL RESETS
+      ------------------------------------- */
+      img {
+        border: none;
+        -ms-interpolation-mode: bicubic;
+        max-width: 100%; }
+      body {
+        background-color: #f6f6f6;
+        font-family: sans-serif;
+        -webkit-font-smoothing: antialiased;
+        font-size: 14px;
+        line-height: 1.4;
+        margin: 0;
+        padding: 0;
+        -ms-text-size-adjust: 100%;
+        -webkit-text-size-adjust: 100%; }
+      table {
+        border-collapse: separate;
+        mso-table-lspace: 0pt;
+        mso-table-rspace: 0pt;
+        width: 100%; }
+        table td {
+          font-family: sans-serif;
+          font-size: 14px;
+          vertical-align: top; }
+      /* -------------------------------------
+          BODY & CONTAINER
+      ------------------------------------- */
+      .body {
+        background-color: #f6f6f6;
+        width: 100%; }
+      /* Set a max-width, and make it display as block so it will automatically stretch to that width, but will also shrink down on a phone or something */
+      .container {
+        display: block;
+        Margin: 0 auto !important;
+        /* makes it centered */
+        max-width: 580px;
+        padding: 10px;
+        width: 580px; }
+      /* This should also be a block element, so that it will fill 100% of the .container */
+      .content {
+        box-sizing: border-box;
+        display: block;
+        Margin: 0 auto;
+        max-width: 580px;
+        padding: 10px; }
+      /* -------------------------------------
+          HEADER, FOOTER, MAIN
+      ------------------------------------- */
+      .main {
+        background: #ffffff;
+        border-radius: 3px;
+        width: 100%; }
+      .wrapper {
+        box-sizing: border-box;
+        padding: 20px; }
+      .content-block {
+        padding-bottom: 10px;
+        padding-top: 10px;
+      }
+      .footer {
+        clear: both;
+        Margin-top: 10px;
+        text-align: center;
+        width: 100%; }
+        .footer td,
+        .footer p,
+        .footer span,
+        .footer a {
+          color: #999999;
+          font-size: 12px;
+          text-align: center; }
+      /* -------------------------------------
+          TYPOGRAPHY
+      ------------------------------------- */
+      h1,
+      h2,
+      h3,
+      h4 {
+        color: #000000;
+        font-family: sans-serif;
+        font-weight: 400;
+        line-height: 1.4;
+        margin: 0;
+        Margin-bottom: 30px; }
+      h1 {
+        font-size: 35px;
+        font-weight: 300;
+        text-align: center;
+        text-transform: capitalize; }
+      p,
+      ul,
+      ol {
+        font-family: sans-serif;
+        font-size: 14px;
+        font-weight: normal;
+        margin: 0;
+        Margin-bottom: 15px; }
+        p li,
+        ul li,
+        ol li {
+          list-style-position: inside;
+          margin-left: 5px; }
+      a {
+        color: #3498db;
+        text-decoration: underline; }
+      /* -------------------------------------
+          BUTTONS
+      ------------------------------------- */
+      .btn {
+        box-sizing: border-box;
+        width: 100%; }
+        .btn > tbody > tr > td {
+          padding-bottom: 15px; }
+        .btn table {
+          width: auto; }
+        .btn table td {
+          background-color: #ffffff;
+          border-radius: 5px;
+          text-align: center; }
+        .btn a {
+          background-color: #ffffff;
+          border: solid 1px #3498db;
+          border-radius: 5px;
+          box-sizing: border-box;
+          color: #3498db;
+          cursor: pointer;
+          display: inline-block;
+          font-size: 14px;
+          font-weight: bold;
+          margin: 0;
+          padding: 12px 25px;
+          text-decoration: none;
+          text-transform: capitalize; }
+      .btn-primary table td {
+        background-color: #3498db; }
+      .btn-primary a {
+        background-color: #3498db;
+        border-color: #3498db;
+        color: #ffffff; }
+      /* -------------------------------------
+          OTHER STYLES THAT MIGHT BE USEFUL
+      ------------------------------------- */
+      .last {
+        margin-bottom: 0; }
+      .first {
+        margin-top: 0; }
+      .align-center {
+        text-align: center; }
+      .align-right {
+        text-align: right; }
+      .align-left {
+        text-align: left; }
+      .clear {
+        clear: both; }
+      .mt0 {
+        margin-top: 0; }
+      .mb0 {
+        margin-bottom: 0; }
+      .preheader {
+        color: transparent;
+        display: none;
+        height: 0;
+        max-height: 0;
+        max-width: 0;
+        opacity: 0;
+        overflow: hidden;
+        mso-hide: all;
+        visibility: hidden;
+        width: 0; }
+      .powered-by a {
+        text-decoration: none; }
+      hr {
+        border: 0;
+        border-bottom: 1px solid #f6f6f6;
+        Margin: 20px 0; }
+      /* -------------------------------------
+          RESPONSIVE AND MOBILE FRIENDLY STYLES
+      ------------------------------------- */
+      @media only screen and (max-width: 620px) {
+        table[class=body] h1 {
+          font-size: 28px !important;
+          margin-bottom: 10px !important; }
+        table[class=body] p,
+        table[class=body] ul,
+        table[class=body] ol,
+        table[class=body] td,
+        table[class=body] span,
+        table[class=body] a {
+          font-size: 16px !important; }
+        table[class=body] .wrapper,
+        table[class=body] .article {
+          padding: 10px !important; }
+        table[class=body] .content {
+          padding: 0 !important; }
+        table[class=body] .container {
+          padding: 0 !important;
+          width: 100% !important; }
+        table[class=body] .main {
+          border-left-width: 0 !important;
+          border-radius: 0 !important;
+          border-right-width: 0 !important; }
+        table[class=body] .btn table {
+          width: 100% !important; }
+        table[class=body] .btn a {
+          width: 100% !important; }
+        table[class=body] .img-responsive {
+          height: auto !important;
+          max-width: 100% !important;
+          width: auto !important; }}
+      /* -------------------------------------
+          PRESERVE THESE STYLES IN THE HEAD
+      ------------------------------------- */
+      @media all {
+        .ExternalClass {
+          width: 100%; }
+        .ExternalClass,
+        .ExternalClass p,
+        .ExternalClass span,
+        .ExternalClass font,
+        .ExternalClass td,
+        .ExternalClass div {
+          line-height: 100%; }
+        .apple-link a {
+          color: inherit !important;
+          font-family: inherit !important;
+          font-size: inherit !important;
+          font-weight: inherit !important;
+          line-height: inherit !important;
+          text-decoration: none !important; }
+        .btn-primary table td:hover {
+          background-color: #34495e !important; }
+        .btn-primary a:hover {
+          background-color: #34495e !important;
+          border-color: #34495e !important; } }
+    </style>
+</head>
+<body class="">
+<table border="0" cellpadding="0" cellspacing="0" class="body">
+    <tr>
+        <td>&nbsp;</td>
+        <td class="container">
+            <div class="content">
+
+                <!-- START CENTERED WHITE CONTAINER -->
+                <span class="preheader">This is preheader text. Some clients will show this text as a preview.</span>
+                <table class="main">
+
+                    <!-- START MAIN CONTENT AREA -->
+                    <tr>
+                        <td class="wrapper">
+                            <table border="0" cellpadding="0" cellspacing="0">
+                                <tr>
+                                    <td>
+                                        <p>Dear {recipient},</p>
+                                        <p>You have been invited to collaborate to Data Management plan {dmpname} with role {dmprole}.</p>
+                                        <p>Click the button to redirect to {dmpname}.</p>
+
+                                        <table border="0" cellpadding="0" cellspacing="0" class="btn btn-primary">
+                                            <tbody>
+                                            <tr>
+                                                <td align="left">
+                                                    <table border="0" cellpadding="0" cellspacing="0">
+                                                        <tbody>
+                                                        <tr>
+                                                            <td> <a href="{host}/plans/invitation/{invitationID}" target="_blank">Join</a> </td>
+                                                        </tr>
+                                                        </tbody>
+                                                    </table>
+                                                </td>
+                                            </tr>
+                                            </tbody>
+                                        </table>
+
+                                    </td>
+                                </tr>
+                            </table>
+                        </td>
+                    </tr>
+
+                    <!-- END MAIN CONTENT AREA -->
+                </table>
+
+                <!-- START FOOTER -->
+                <div class="footer">
+
+                </div>
+                <!-- END FOOTER -->
+
+                <!-- END CENTERED WHITE CONTAINER -->
+            </div>
+        </td>
+        <td>&nbsp;</td>
+    </tr>
+</table>
+</body>
+</html>

dmp-backend/notification-service/notification-web/src/main/resources/notification_templates/DataManagementPlan/Email/subject.en.txt

@@ -0,0 +1 @@
+ARGOS - Data Management Plan Invite

dmp-backend/notification-service/notification-web/src/main/resources/notification_templates/Finalised/Email/body.en.html

@@ -0,0 +1,304 @@
+<!doctype html>
+<html>
+<head>
+    <meta name="viewport" content="width=device-width" />
+    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
+    <title>Simple Transactional Email</title>
+    <style>
+      /* -------------------------------------
+          GLOBAL RESETS
+      ------------------------------------- */
+      img {
+        border: none;
+        -ms-interpolation-mode: bicubic;
+        max-width: 100%; }
+      body {
+        background-color: #f6f6f6;
+        font-family: sans-serif;
+        -webkit-font-smoothing: antialiased;
+        font-size: 14px;
+        line-height: 1.4;
+        margin: 0;
+        padding: 0;
+        -ms-text-size-adjust: 100%;
+        -webkit-text-size-adjust: 100%; }
+      table {
+        border-collapse: separate;
+        mso-table-lspace: 0pt;
+        mso-table-rspace: 0pt;
+        width: 100%; }
+        table td {
+          font-family: sans-serif;
+          font-size: 14px;
+          vertical-align: top; }
+      /* -------------------------------------
+          BODY & CONTAINER
+      ------------------------------------- */
+      .body {
+        background-color: #f6f6f6;
+        width: 100%; }
+      /* Set a max-width, and make it display as block so it will automatically stretch to that width, but will also shrink down on a phone or something */
+      .container {
+        display: block;
+        Margin: 0 auto !important;
+        /* makes it centered */
+        max-width: 580px;
+        padding: 10px;
+        width: 580px; }
+      /* This should also be a block element, so that it will fill 100% of the .container */
+      .content {
+        box-sizing: border-box;
+        display: block;
+        Margin: 0 auto;
+        max-width: 580px;
+        padding: 10px; }
+      /* -------------------------------------
+          HEADER, FOOTER, MAIN
+      ------------------------------------- */
+      .main {
+        background: #ffffff;
+        border-radius: 3px;
+        width: 100%; }
+      .wrapper {
+        box-sizing: border-box;
+        padding: 20px; }
+      .content-block {
+        padding-bottom: 10px;
+        padding-top: 10px;
+      }
+      .footer {
+        clear: both;
+        Margin-top: 10px;
+        text-align: center;
+        width: 100%; }
+        .footer td,
+        .footer p,
+        .footer span,
+        .footer a {
+          color: #999999;
+          font-size: 12px;
+          text-align: center; }
+      /* -------------------------------------
+          TYPOGRAPHY
+      ------------------------------------- */
+      h1,
+      h2,
+      h3,
+      h4 {
+        color: #000000;
+        font-family: sans-serif;
+        font-weight: 400;
+        line-height: 1.4;
+        margin: 0;
+        Margin-bottom: 30px; }
+      h1 {
+        font-size: 35px;
+        font-weight: 300;
+        text-align: center;
+        text-transform: capitalize; }
+      p,
+      ul,
+      ol {
+        font-family: sans-serif;
+        font-size: 14px;
+        font-weight: normal;
+        margin: 0;
+        Margin-bottom: 15px; }
+        p li,
+        ul li,
+        ol li {
+          list-style-position: inside;
+          margin-left: 5px; }
+      a {
+        color: #3498db;
+        text-decoration: underline; }
+      /* -------------------------------------
+          BUTTONS
+      ------------------------------------- */
+      .btn {
+        box-sizing: border-box;
+        width: 100%; }
+        .btn > tbody > tr > td {
+          padding-bottom: 15px; }
+        .btn table {
+          width: auto; }
+        .btn table td {
+          background-color: #ffffff;
+          border-radius: 5px;
+          text-align: center; }
+        .btn a {
+          background-color: #ffffff;
+          border: solid 1px #3498db;
+          border-radius: 5px;
+          box-sizing: border-box;
+          color: #3498db;
+          cursor: pointer;
+          display: inline-block;
+          font-size: 14px;
+          font-weight: bold;
+          margin: 0;
+          padding: 12px 25px;
+          text-decoration: none;
+          text-transform: capitalize; }
+      .btn-primary table td {
+        background-color: #3498db; }
+      .btn-primary a {
+        background-color: #3498db;
+        border-color: #3498db;
+        color: #ffffff; }
+      /* -------------------------------------
+          OTHER STYLES THAT MIGHT BE USEFUL
+      ------------------------------------- */
+      .last {
+        margin-bottom: 0; }
+      .first {
+        margin-top: 0; }
+      .align-center {
+        text-align: center; }
+      .align-right {
+        text-align: right; }
+      .align-left {
+        text-align: left; }
+      .clear {
+        clear: both; }
+      .mt0 {
+        margin-top: 0; }
+      .mb0 {
+        margin-bottom: 0; }
+      .preheader {
+        color: transparent;
+        display: none;
+        height: 0;
+        max-height: 0;
+        max-width: 0;
+        opacity: 0;
+        overflow: hidden;
+        mso-hide: all;
+        visibility: hidden;
+        width: 0; }
+      .powered-by a {
+        text-decoration: none; }
+      hr {
+        border: 0;
+        border-bottom: 1px solid #f6f6f6;
+        Margin: 20px 0; }
+      /* -------------------------------------
+          RESPONSIVE AND MOBILE FRIENDLY STYLES
+      ------------------------------------- */
+      @media only screen and (max-width: 620px) {
+        table[class=body] h1 {
+          font-size: 28px !important;
+          margin-bottom: 10px !important; }
+        table[class=body] p,
+        table[class=body] ul,
+        table[class=body] ol,
+        table[class=body] td,
+        table[class=body] span,
+        table[class=body] a {
+          font-size: 16px !important; }
+        table[class=body] .wrapper,
+        table[class=body] .article {
+          padding: 10px !important; }
+        table[class=body] .content {
+          padding: 0 !important; }
+        table[class=body] .container {
+          padding: 0 !important;
+          width: 100% !important; }
+        table[class=body] .main {
+          border-left-width: 0 !important;
+          border-radius: 0 !important;
+          border-right-width: 0 !important; }
+        table[class=body] .btn table {
+          width: 100% !important; }
+        table[class=body] .btn a {
+          width: 100% !important; }
+        table[class=body] .img-responsive {
+          height: auto !important;
+          max-width: 100% !important;
+          width: auto !important; }}
+      /* -------------------------------------
+          PRESERVE THESE STYLES IN THE HEAD
+      ------------------------------------- */
+      @media all {
+        .ExternalClass {
+          width: 100%; }
+        .ExternalClass,
+        .ExternalClass p,
+        .ExternalClass span,
+        .ExternalClass font,
+        .ExternalClass td,
+        .ExternalClass div {
+          line-height: 100%; }
+        .apple-link a {
+          color: inherit !important;
+          font-family: inherit !important;
+          font-size: inherit !important;
+          font-weight: inherit !important;
+          line-height: inherit !important;
+          text-decoration: none !important; }
+        .btn-primary table td:hover {
+          background-color: #34495e !important; }
+        .btn-primary a:hover {
+          background-color: #34495e !important;
+          border-color: #34495e !important; } }
+    </style>
+</head>
+<body class="">
+<table border="0" cellpadding="0" cellspacing="0" class="body">
+    <tr>
+        <td>&nbsp;</td>
+        <td class="container">
+            <div class="content">
+
+                <!-- START CENTERED WHITE CONTAINER -->
+                <span class="preheader">This is preheader text. Some clients will show this text as a preview.</span>
+                <table class="main">
+
+                    <!-- START MAIN CONTENT AREA -->
+                    <tr>
+                        <td class="wrapper">
+                            <table border="0" cellpadding="0" cellspacing="0">
+                                <tr>
+                                    <td>
+                                        <p>Dear {recipient},</p>
+                                        <p>{reasonName} just finalised the {name}.</p>
+
+                                        <table border="0" cellpadding="0" cellspacing="0" class="btn btn-primary">
+                                            <tbody>
+                                            <tr>
+                                                <td align="left">
+                                                    <table border="0" cellpadding="0" cellspacing="0">
+                                                        <tbody>
+                                                        <tr>
+                                                            <td> <a href="{host}{path}/{id}" target="_blank">Click here to view it.</a> </td>
+                                                        </tr>
+                                                        </tbody>
+                                                    </table>
+                                                </td>
+                                            </tr>
+                                            </tbody>
+                                        </table>
+
+                                    </td>
+                                </tr>
+                            </table>
+                        </td>
+                    </tr>
+
+                    <!-- END MAIN CONTENT AREA -->
+                </table>
+
+                <!-- START FOOTER -->
+                <div class="footer">
+
+                </div>
+                <!-- END FOOTER -->
+
+                <!-- END CENTERED WHITE CONTAINER -->
+            </div>
+        </td>
+        <td>&nbsp;</td>
+    </tr>
+</table>
+</body>
+</html>

dmp-backend/notification-service/notification-web/src/main/resources/notification_templates/Finalised/Email/subject.en.txt

@@ -0,0 +1 @@
+ARGOS - Finalised

dmp-backend/notification-service/notification-web/src/main/resources/notification_templates/MergeConfirmation/Email/subject.en.txt

@@ -0,0 +1 @@
+ARGOS - Merge Confirmation

dmp-backend/notification-service/notification-web/src/main/resources/notification_templates/Modified/Email/body.en.html

@@ -0,0 +1,304 @@
+<!doctype html>
+<html>
+<head>
+    <meta name="viewport" content="width=device-width" />
+    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
+    <title>Simple Transactional Email</title>
+    <style>
+      /* -------------------------------------
+          GLOBAL RESETS
+      ------------------------------------- */
+      img {
+        border: none;
+        -ms-interpolation-mode: bicubic;
+        max-width: 100%; }
+      body {
+        background-color: #f6f6f6;
+        font-family: sans-serif;
+        -webkit-font-smoothing: antialiased;
+        font-size: 14px;
+        line-height: 1.4;
+        margin: 0;
+        padding: 0;
+        -ms-text-size-adjust: 100%;
+        -webkit-text-size-adjust: 100%; }
+      table {
+        border-collapse: separate;
+        mso-table-lspace: 0pt;
+        mso-table-rspace: 0pt;
+        width: 100%; }
+        table td {
+          font-family: sans-serif;
+          font-size: 14px;
+          vertical-align: top; }
+      /* -------------------------------------
+          BODY & CONTAINER
+      ------------------------------------- */
+      .body {
+        background-color: #f6f6f6;
+        width: 100%; }
+      /* Set a max-width, and make it display as block so it will automatically stretch to that width, but will also shrink down on a phone or something */
+      .container {
+        display: block;
+        Margin: 0 auto !important;
+        /* makes it centered */
+        max-width: 580px;
+        padding: 10px;
+        width: 580px; }
+      /* This should also be a block element, so that it will fill 100% of the .container */
+      .content {
+        box-sizing: border-box;
+        display: block;
+        Margin: 0 auto;
+        max-width: 580px;
+        padding: 10px; }
+      /* -------------------------------------
+          HEADER, FOOTER, MAIN
+      ------------------------------------- */
+      .main {
+        background: #ffffff;
+        border-radius: 3px;
+        width: 100%; }
+      .wrapper {
+        box-sizing: border-box;
+        padding: 20px; }
+      .content-block {
+        padding-bottom: 10px;
+        padding-top: 10px;
+      }
+      .footer {
+        clear: both;
+        Margin-top: 10px;
+        text-align: center;
+        width: 100%; }
+        .footer td,
+        .footer p,
+        .footer span,
+        .footer a {
+          color: #999999;
+          font-size: 12px;
+          text-align: center; }
+      /* -------------------------------------
+          TYPOGRAPHY
+      ------------------------------------- */
+      h1,
+      h2,
+      h3,
+      h4 {
+        color: #000000;
+        font-family: sans-serif;
+        font-weight: 400;
+        line-height: 1.4;
+        margin: 0;
+        Margin-bottom: 30px; }
+      h1 {
+        font-size: 35px;
+        font-weight: 300;
+        text-align: center;
+        text-transform: capitalize; }
+      p,
+      ul,
+      ol {
+        font-family: sans-serif;
+        font-size: 14px;
+        font-weight: normal;
+        margin: 0;
+        Margin-bottom: 15px; }
+        p li,
+        ul li,
+        ol li {
+          list-style-position: inside;
+          margin-left: 5px; }
+      a {
+        color: #3498db;
+        text-decoration: underline; }
+      /* -------------------------------------
+          BUTTONS
+      ------------------------------------- */
+      .btn {
+        box-sizing: border-box;
+        width: 100%; }
+        .btn > tbody > tr > td {
+          padding-bottom: 15px; }
+        .btn table {
+          width: auto; }
+        .btn table td {
+          background-color: #ffffff;
+          border-radius: 5px;
+          text-align: center; }
+        .btn a {
+          background-color: #ffffff;
+          border: solid 1px #3498db;
+          border-radius: 5px;
+          box-sizing: border-box;
+          color: #3498db;
+          cursor: pointer;
+          display: inline-block;
+          font-size: 14px;
+          font-weight: bold;
+          margin: 0;
+          padding: 12px 25px;
+          text-decoration: none;
+          text-transform: capitalize; }
+      .btn-primary table td {
+        background-color: #3498db; }
+      .btn-primary a {
+        background-color: #3498db;
+        border-color: #3498db;
+        color: #ffffff; }
+      /* -------------------------------------
+          OTHER STYLES THAT MIGHT BE USEFUL
+      ------------------------------------- */
+      .last {
+        margin-bottom: 0; }
+      .first {
+        margin-top: 0; }
+      .align-center {
+        text-align: center; }
+      .align-right {
+        text-align: right; }
+      .align-left {
+        text-align: left; }
+      .clear {
+        clear: both; }
+      .mt0 {
+        margin-top: 0; }
+      .mb0 {
+        margin-bottom: 0; }
+      .preheader {
+        color: transparent;
+        display: none;
+        height: 0;
+        max-height: 0;
+        max-width: 0;
+        opacity: 0;
+        overflow: hidden;
+        mso-hide: all;
+        visibility: hidden;
+        width: 0; }
+      .powered-by a {
+        text-decoration: none; }
+      hr {
+        border: 0;
+        border-bottom: 1px solid #f6f6f6;
+        Margin: 20px 0; }
+      /* -------------------------------------
+          RESPONSIVE AND MOBILE FRIENDLY STYLES
+      ------------------------------------- */
+      @media only screen and (max-width: 620px) {
+        table[class=body] h1 {
+          font-size: 28px !important;
+          margin-bottom: 10px !important; }
+        table[class=body] p,
+        table[class=body] ul,
+        table[class=body] ol,
+        table[class=body] td,
+        table[class=body] span,
+        table[class=body] a {
+          font-size: 16px !important; }
+        table[class=body] .wrapper,
+        table[class=body] .article {
+          padding: 10px !important; }
+        table[class=body] .content {
+          padding: 0 !important; }
+        table[class=body] .container {
+          padding: 0 !important;
+          width: 100% !important; }
+        table[class=body] .main {
+          border-left-width: 0 !important;
+          border-radius: 0 !important;
+          border-right-width: 0 !important; }
+        table[class=body] .btn table {
+          width: 100% !important; }
+        table[class=body] .btn a {
+          width: 100% !important; }
+        table[class=body] .img-responsive {
+          height: auto !important;
+          max-width: 100% !important;
+          width: auto !important; }}
+      /* -------------------------------------
+          PRESERVE THESE STYLES IN THE HEAD
+      ------------------------------------- */
+      @media all {
+        .ExternalClass {
+          width: 100%; }
+        .ExternalClass,
+        .ExternalClass p,
+        .ExternalClass span,
+        .ExternalClass font,
+        .ExternalClass td,
+        .ExternalClass div {
+          line-height: 100%; }
+        .apple-link a {
+          color: inherit !important;
+          font-family: inherit !important;
+          font-size: inherit !important;
+          font-weight: inherit !important;
+          line-height: inherit !important;
+          text-decoration: none !important; }
+        .btn-primary table td:hover {
+          background-color: #34495e !important; }
+        .btn-primary a:hover {
+          background-color: #34495e !important;
+          border-color: #34495e !important; } }
+    </style>
+</head>
+<body class="">
+<table border="0" cellpadding="0" cellspacing="0" class="body">
+    <tr>
+        <td>&nbsp;</td>
+        <td class="container">
+            <div class="content">
+
+                <!-- START CENTERED WHITE CONTAINER -->
+                <span class="preheader">This is preheader text. Some clients will show this text as a preview.</span>
+                <table class="main">
+
+                    <!-- START MAIN CONTENT AREA -->
+                    <tr>
+                        <td class="wrapper">
+                            <table border="0" cellpadding="0" cellspacing="0">
+                                <tr>
+                                    <td>
+                                        <p>Dear {recipient},</p>
+                                        <p>{reasonName} just made changes to the {name}.</p>
+
+                                        <table border="0" cellpadding="0" cellspacing="0" class="btn btn-primary">
+                                            <tbody>
+                                            <tr>
+                                                <td align="left">
+                                                    <table border="0" cellpadding="0" cellspacing="0">
+                                                        <tbody>
+                                                        <tr>
+                                                            <td> <a href="{host}{path}/{id}" target="_blank">Click here to view it.</a> </td>
+                                                        </tr>
+                                                        </tbody>
+                                                    </table>
+                                                </td>
+                                            </tr>
+                                            </tbody>
+                                        </table>
+
+                                    </td>
+                                </tr>
+                            </table>
+                        </td>
+                    </tr>
+
+                    <!-- END MAIN CONTENT AREA -->
+                </table>
+
+                <!-- START FOOTER -->
+                <div class="footer">
+
+                </div>
+                <!-- END FOOTER -->
+
+                <!-- END CENTERED WHITE CONTAINER -->
+            </div>
+        </td>
+        <td>&nbsp;</td>
+    </tr>
+</table>
+</body>
+</html>

dmp-backend/notification-service/notification-web/src/main/resources/notification_templates/Modified/Email/subject.en.txt

@@ -0,0 +1 @@
+ARGOS - Modified

dmp-backend/notification-service/notification-web/src/main/resources/notification_templates/ModifiedFinalised/Email/body.en.html

@@ -0,0 +1,304 @@
+<!doctype html>
+<html>
+<head>
+    <meta name="viewport" content="width=device-width" />
+    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
+    <title>Simple Transactional Email</title>
+    <style>
+      /* -------------------------------------
+          GLOBAL RESETS
+      ------------------------------------- */
+      img {
+        border: none;
+        -ms-interpolation-mode: bicubic;
+        max-width: 100%; }
+      body {
+        background-color: #f6f6f6;
+        font-family: sans-serif;
+        -webkit-font-smoothing: antialiased;
+        font-size: 14px;
+        line-height: 1.4;
+        margin: 0;
+        padding: 0;
+        -ms-text-size-adjust: 100%;
+        -webkit-text-size-adjust: 100%; }
+      table {
+        border-collapse: separate;
+        mso-table-lspace: 0pt;
+        mso-table-rspace: 0pt;
+        width: 100%; }
+        table td {
+          font-family: sans-serif;
+          font-size: 14px;
+          vertical-align: top; }
+      /* -------------------------------------
+          BODY & CONTAINER
+      ------------------------------------- */
+      .body {
+        background-color: #f6f6f6;
+        width: 100%; }
+      /* Set a max-width, and make it display as block so it will automatically stretch to that width, but will also shrink down on a phone or something */
+      .container {
+        display: block;
+        Margin: 0 auto !important;
+        /* makes it centered */
+        max-width: 580px;
+        padding: 10px;
+        width: 580px; }
+      /* This should also be a block element, so that it will fill 100% of the .container */
+      .content {
+        box-sizing: border-box;
+        display: block;
+        Margin: 0 auto;
+        max-width: 580px;
+        padding: 10px; }
+      /* -------------------------------------
+          HEADER, FOOTER, MAIN
+      ------------------------------------- */
+      .main {
+        background: #ffffff;
+        border-radius: 3px;
+        width: 100%; }
+      .wrapper {
+        box-sizing: border-box;
+        padding: 20px; }
+      .content-block {
+        padding-bottom: 10px;
+        padding-top: 10px;
+      }
+      .footer {
+        clear: both;
+        Margin-top: 10px;
+        text-align: center;
+        width: 100%; }
+        .footer td,
+        .footer p,
+        .footer span,
+        .footer a {
+          color: #999999;
+          font-size: 12px;
+          text-align: center; }
+      /* -------------------------------------
+          TYPOGRAPHY
+      ------------------------------------- */
+      h1,
+      h2,
+      h3,
+      h4 {
+        color: #000000;
+        font-family: sans-serif;
+        font-weight: 400;
+        line-height: 1.4;
+        margin: 0;
+        Margin-bottom: 30px; }
+      h1 {
+        font-size: 35px;
+        font-weight: 300;
+        text-align: center;
+        text-transform: capitalize; }
+      p,
+      ul,
+      ol {
+        font-family: sans-serif;
+        font-size: 14px;
+        font-weight: normal;
+        margin: 0;
+        Margin-bottom: 15px; }
+        p li,
+        ul li,
+        ol li {
+          list-style-position: inside;
+          margin-left: 5px; }
+      a {
+        color: #3498db;
+        text-decoration: underline; }
+      /* -------------------------------------
+          BUTTONS
+      ------------------------------------- */
+      .btn {
+        box-sizing: border-box;
+        width: 100%; }
+        .btn > tbody > tr > td {
+          padding-bottom: 15px; }
+        .btn table {
+          width: auto; }
+        .btn table td {
+          background-color: #ffffff;
+          border-radius: 5px;
+          text-align: center; }
+        .btn a {
+          background-color: #ffffff;
+          border: solid 1px #3498db;
+          border-radius: 5px;
+          box-sizing: border-box;
+          color: #3498db;
+          cursor: pointer;
+          display: inline-block;
+          font-size: 14px;
+          font-weight: bold;
+          margin: 0;
+          padding: 12px 25px;
+          text-decoration: none;
+          text-transform: capitalize; }
+      .btn-primary table td {
+        background-color: #3498db; }
+      .btn-primary a {
+        background-color: #3498db;
+        border-color: #3498db;
+        color: #ffffff; }
+      /* -------------------------------------
+          OTHER STYLES THAT MIGHT BE USEFUL
+      ------------------------------------- */
+      .last {
+        margin-bottom: 0; }
+      .first {
+        margin-top: 0; }
+      .align-center {
+        text-align: center; }
+      .align-right {
+        text-align: right; }
+      .align-left {
+        text-align: left; }
+      .clear {
+        clear: both; }
+      .mt0 {
+        margin-top: 0; }
+      .mb0 {
+        margin-bottom: 0; }
+      .preheader {
+        color: transparent;
+        display: none;
+        height: 0;
+        max-height: 0;
+        max-width: 0;
+        opacity: 0;
+        overflow: hidden;
+        mso-hide: all;
+        visibility: hidden;
+        width: 0; }
+      .powered-by a {
+        text-decoration: none; }
+      hr {
+        border: 0;
+        border-bottom: 1px solid #f6f6f6;
+        Margin: 20px 0; }
+      /* -------------------------------------
+          RESPONSIVE AND MOBILE FRIENDLY STYLES
+      ------------------------------------- */
+      @media only screen and (max-width: 620px) {
+        table[class=body] h1 {
+          font-size: 28px !important;
+          margin-bottom: 10px !important; }
+        table[class=body] p,
+        table[class=body] ul,
+        table[class=body] ol,
+        table[class=body] td,
+        table[class=body] span,
+        table[class=body] a {
+          font-size: 16px !important; }
+        table[class=body] .wrapper,
+        table[class=body] .article {
+          padding: 10px !important; }
+        table[class=body] .content {
+          padding: 0 !important; }
+        table[class=body] .container {
+          padding: 0 !important;
+          width: 100% !important; }
+        table[class=body] .main {
+          border-left-width: 0 !important;
+          border-radius: 0 !important;
+          border-right-width: 0 !important; }
+        table[class=body] .btn table {
+          width: 100% !important; }
+        table[class=body] .btn a {
+          width: 100% !important; }
+        table[class=body] .img-responsive {
+          height: auto !important;
+          max-width: 100% !important;
+          width: auto !important; }}
+      /* -------------------------------------
+          PRESERVE THESE STYLES IN THE HEAD
+      ------------------------------------- */
+      @media all {
+        .ExternalClass {
+          width: 100%; }
+        .ExternalClass,
+        .ExternalClass p,
+        .ExternalClass span,
+        .ExternalClass font,
+        .ExternalClass td,
+        .ExternalClass div {
+          line-height: 100%; }
+        .apple-link a {
+          color: inherit !important;
+          font-family: inherit !important;
+          font-size: inherit !important;
+          font-weight: inherit !important;
+          line-height: inherit !important;
+          text-decoration: none !important; }
+        .btn-primary table td:hover {
+          background-color: #34495e !important; }
+        .btn-primary a:hover {
+          background-color: #34495e !important;
+          border-color: #34495e !important; } }
+    </style>
+</head>
+<body class="">
+<table border="0" cellpadding="0" cellspacing="0" class="body">
+    <tr>
+        <td>&nbsp;</td>
+        <td class="container">
+            <div class="content">
+
+                <!-- START CENTERED WHITE CONTAINER -->
+                <span class="preheader">This is preheader text. Some clients will show this text as a preview.</span>
+                <table class="main">
+
+                    <!-- START MAIN CONTENT AREA -->
+                    <tr>
+                        <td class="wrapper">
+                            <table border="0" cellpadding="0" cellspacing="0">
+                                <tr>
+                                    <td>
+                                        <p>Dear {recipient},</p>
+                                        <p>{reasonName} just made changes and finalised the {name}.</p>
+
+                                        <table border="0" cellpadding="0" cellspacing="0" class="btn btn-primary">
+                                            <tbody>
+                                            <tr>
+                                                <td align="left">
+                                                    <table border="0" cellpadding="0" cellspacing="0">
+                                                        <tbody>
+                                                        <tr>
+                                                            <td> <a href="{host}{path}/{id}" target="_blank">Click here to view it.</a> </td>
+                                                        </tr>
+                                                        </tbody>
+                                                    </table>
+                                                </td>
+                                            </tr>
+                                            </tbody>
+                                        </table>
+
+                                    </td>
+                                </tr>
+                            </table>
+                        </td>
+                    </tr>
+
+                    <!-- END MAIN CONTENT AREA -->
+                </table>
+
+                <!-- START FOOTER -->
+                <div class="footer">
+
+                </div>
+                <!-- END FOOTER -->
+
+                <!-- END CENTERED WHITE CONTAINER -->
+            </div>
+        </td>
+        <td>&nbsp;</td>
+    </tr>
+</table>
+</body>
+</html>

dmp-backend/notification-service/notification-web/src/main/resources/notification_templates/ModifiedFinalised/Email/subject.en.txt

@@ -0,0 +1 @@
+ARGOS - Modified Finalised

dmp-backend/notification-service/notification-web/src/main/resources/notification_templates/Publish/Email/body.en.html

@@ -0,0 +1,304 @@
+<!doctype html>
+<html>
+<head>
+    <meta name="viewport" content="width=device-width" />
+    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
+    <title>Simple Transactional Email</title>
+    <style>
+      /* -------------------------------------
+          GLOBAL RESETS
+      ------------------------------------- */
+      img {
+        border: none;
+        -ms-interpolation-mode: bicubic;
+        max-width: 100%; }
+      body {
+        background-color: #f6f6f6;
+        font-family: sans-serif;
+        -webkit-font-smoothing: antialiased;
+        font-size: 14px;
+        line-height: 1.4;
+        margin: 0;
+        padding: 0;
+        -ms-text-size-adjust: 100%;
+        -webkit-text-size-adjust: 100%; }
+      table {
+        border-collapse: separate;
+        mso-table-lspace: 0pt;
+        mso-table-rspace: 0pt;
+        width: 100%; }
+        table td {
+          font-family: sans-serif;
+          font-size: 14px;
+          vertical-align: top; }
+      /* -------------------------------------
+          BODY & CONTAINER
+      ------------------------------------- */
+      .body {
+        background-color: #f6f6f6;
+        width: 100%; }
+      /* Set a max-width, and make it display as block so it will automatically stretch to that width, but will also shrink down on a phone or something */
+      .container {
+        display: block;
+        Margin: 0 auto !important;
+        /* makes it centered */
+        max-width: 580px;
+        padding: 10px;
+        width: 580px; }
+      /* This should also be a block element, so that it will fill 100% of the .container */
+      .content {
+        box-sizing: border-box;
+        display: block;
+        Margin: 0 auto;
+        max-width: 580px;
+        padding: 10px; }
+      /* -------------------------------------
+          HEADER, FOOTER, MAIN
+      ------------------------------------- */
+      .main {
+        background: #ffffff;
+        border-radius: 3px;
+        width: 100%; }
+      .wrapper {
+        box-sizing: border-box;
+        padding: 20px; }
+      .content-block {
+        padding-bottom: 10px;
+        padding-top: 10px;
+      }
+      .footer {
+        clear: both;
+        Margin-top: 10px;
+        text-align: center;
+        width: 100%; }
+        .footer td,
+        .footer p,
+        .footer span,
+        .footer a {
+          color: #999999;
+          font-size: 12px;
+          text-align: center; }
+      /* -------------------------------------
+          TYPOGRAPHY
+      ------------------------------------- */
+      h1,
+      h2,
+      h3,
+      h4 {
+        color: #000000;
+        font-family: sans-serif;
+        font-weight: 400;
+        line-height: 1.4;
+        margin: 0;
+        Margin-bottom: 30px; }
+      h1 {
+        font-size: 35px;
+        font-weight: 300;
+        text-align: center;
+        text-transform: capitalize; }
+      p,
+      ul,
+      ol {
+        font-family: sans-serif;
+        font-size: 14px;
+        font-weight: normal;
+        margin: 0;
+        Margin-bottom: 15px; }
+        p li,
+        ul li,
+        ol li {
+          list-style-position: inside;
+          margin-left: 5px; }
+      a {
+        color: #3498db;
+        text-decoration: underline; }
+      /* -------------------------------------
+          BUTTONS
+      ------------------------------------- */
+      .btn {
+        box-sizing: border-box;
+        width: 100%; }
+        .btn > tbody > tr > td {
+          padding-bottom: 15px; }
+        .btn table {
+          width: auto; }
+        .btn table td {
+          background-color: #ffffff;
+          border-radius: 5px;
+          text-align: center; }
+        .btn a {
+          background-color: #ffffff;
+          border: solid 1px #3498db;
+          border-radius: 5px;
+          box-sizing: border-box;
+          color: #3498db;
+          cursor: pointer;
+          display: inline-block;
+          font-size: 14px;
+          font-weight: bold;
+          margin: 0;
+          padding: 12px 25px;
+          text-decoration: none;
+          text-transform: capitalize; }
+      .btn-primary table td {
+        background-color: #3498db; }
+      .btn-primary a {
+        background-color: #3498db;
+        border-color: #3498db;
+        color: #ffffff; }
+      /* -------------------------------------
+          OTHER STYLES THAT MIGHT BE USEFUL
+      ------------------------------------- */
+      .last {
+        margin-bottom: 0; }
+      .first {
+        margin-top: 0; }
+      .align-center {
+        text-align: center; }
+      .align-right {
+        text-align: right; }
+      .align-left {
+        text-align: left; }
+      .clear {
+        clear: both; }
+      .mt0 {
+        margin-top: 0; }
+      .mb0 {
+        margin-bottom: 0; }
+      .preheader {
+        color: transparent;
+        display: none;
+        height: 0;
+        max-height: 0;
+        max-width: 0;
+        opacity: 0;
+        overflow: hidden;
+        mso-hide: all;
+        visibility: hidden;
+        width: 0; }
+      .powered-by a {
+        text-decoration: none; }
+      hr {
+        border: 0;
+        border-bottom: 1px solid #f6f6f6;
+        Margin: 20px 0; }
+      /* -------------------------------------
+          RESPONSIVE AND MOBILE FRIENDLY STYLES
+      ------------------------------------- */
+      @media only screen and (max-width: 620px) {
+        table[class=body] h1 {
+          font-size: 28px !important;
+          margin-bottom: 10px !important; }
+        table[class=body] p,
+        table[class=body] ul,
+        table[class=body] ol,
+        table[class=body] td,
+        table[class=body] span,
+        table[class=body] a {
+          font-size: 16px !important; }
+        table[class=body] .wrapper,
+        table[class=body] .article {
+          padding: 10px !important; }
+        table[class=body] .content {
+          padding: 0 !important; }
+        table[class=body] .container {
+          padding: 0 !important;
+          width: 100% !important; }
+        table[class=body] .main {
+          border-left-width: 0 !important;
+          border-radius: 0 !important;
+          border-right-width: 0 !important; }
+        table[class=body] .btn table {
+          width: 100% !important; }
+        table[class=body] .btn a {
+          width: 100% !important; }
+        table[class=body] .img-responsive {
+          height: auto !important;
+          max-width: 100% !important;
+          width: auto !important; }}
+      /* -------------------------------------
+          PRESERVE THESE STYLES IN THE HEAD
+      ------------------------------------- */
+      @media all {
+        .ExternalClass {
+          width: 100%; }
+        .ExternalClass,
+        .ExternalClass p,
+        .ExternalClass span,
+        .ExternalClass font,
+        .ExternalClass td,
+        .ExternalClass div {
+          line-height: 100%; }
+        .apple-link a {
+          color: inherit !important;
+          font-family: inherit !important;
+          font-size: inherit !important;
+          font-weight: inherit !important;
+          line-height: inherit !important;
+          text-decoration: none !important; }
+        .btn-primary table td:hover {
+          background-color: #34495e !important; }
+        .btn-primary a:hover {
+          background-color: #34495e !important;
+          border-color: #34495e !important; } }
+    </style>
+</head>
+<body class="">
+<table border="0" cellpadding="0" cellspacing="0" class="body">
+    <tr>
+        <td>&nbsp;</td>
+        <td class="container">
+            <div class="content">
+
+                <!-- START CENTERED WHITE CONTAINER -->
+                <span class="preheader">This is preheader text. Some clients will show this text as a preview.</span>
+                <table class="main">
+
+                    <!-- START MAIN CONTENT AREA -->
+                    <tr>
+                        <td class="wrapper">
+                            <table border="0" cellpadding="0" cellspacing="0">
+                                <tr>
+                                    <td>
+                                        <p>Dear {recipient},</p>
+                                        <p>{reasonName} just publish the {name}.</p>
+
+                                        <table border="0" cellpadding="0" cellspacing="0" class="btn btn-primary">
+                                            <tbody>
+                                            <tr>
+                                                <td align="left">
+                                                    <table border="0" cellpadding="0" cellspacing="0">
+                                                        <tbody>
+                                                        <tr>
+                                                            <td> <a href="{host}{path}/{id}" target="_blank">Click here to view it.</a> </td>
+                                                        </tr>
+                                                        </tbody>
+                                                    </table>
+                                                </td>
+                                            </tr>
+                                            </tbody>
+                                        </table>
+
+                                    </td>
+                                </tr>
+                            </table>
+                        </td>
+                    </tr>
+
+                    <!-- END MAIN CONTENT AREA -->
+                </table>
+
+                <!-- START FOOTER -->
+                <div class="footer">
+
+                </div>
+                <!-- END FOOTER -->
+
+                <!-- END CENTERED WHITE CONTAINER -->
+            </div>
+        </td>
+        <td>&nbsp;</td>
+    </tr>
+</table>
+</body>
+</html>

dmp-backend/notification-service/notification-web/src/main/resources/notification_templates/Publish/Email/subject.en.txt

@@ -0,0 +1 @@
+ARGOS - Publish

dmp-backend/notification-service/notification-web/src/main/resources/notification_templates/Template/Email/body.en.html

@@ -0,0 +1,305 @@
+<!doctype html>
+<html>
+<head>
+    <meta name="viewport" content="width=device-width" />
+    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
+    <title>Simple Transactional Email</title>
+    <style>
+      /* -------------------------------------
+          GLOBAL RESETS
+      ------------------------------------- */
+      img {
+        border: none;
+        -ms-interpolation-mode: bicubic;
+        max-width: 100%; }
+      body {
+        background-color: #f6f6f6;
+        font-family: sans-serif;
+        -webkit-font-smoothing: antialiased;
+        font-size: 14px;
+        line-height: 1.4;
+        margin: 0;
+        padding: 0;
+        -ms-text-size-adjust: 100%;
+        -webkit-text-size-adjust: 100%; }
+      table {
+        border-collapse: separate;
+        mso-table-lspace: 0pt;
+        mso-table-rspace: 0pt;
+        width: 100%; }
+        table td {
+          font-family: sans-serif;
+          font-size: 14px;
+          vertical-align: top; }
+      /* -------------------------------------
+          BODY & CONTAINER
+      ------------------------------------- */
+      .body {
+        background-color: #f6f6f6;
+        width: 100%; }
+      /* Set a max-width, and make it display as block so it will automatically stretch to that width, but will also shrink down on a phone or something */
+      .container {
+        display: block;
+        Margin: 0 auto !important;
+        /* makes it centered */
+        max-width: 580px;
+        padding: 10px;
+        width: 580px; }
+      /* This should also be a block element, so that it will fill 100% of the .container */
+      .content {
+        box-sizing: border-box;
+        display: block;
+        Margin: 0 auto;
+        max-width: 580px;
+        padding: 10px; }
+      /* -------------------------------------
+          HEADER, FOOTER, MAIN
+      ------------------------------------- */
+      .main {
+        background: #ffffff;
+        border-radius: 3px;
+        width: 100%; }
+      .wrapper {
+        box-sizing: border-box;
+        padding: 20px; }
+      .content-block {
+        padding-bottom: 10px;
+        padding-top: 10px;
+      }
+      .footer {
+        clear: both;
+        Margin-top: 10px;
+        text-align: center;
+        width: 100%; }
+        .footer td,
+        .footer p,
+        .footer span,
+        .footer a {
+          color: #999999;
+          font-size: 12px;
+          text-align: center; }
+      /* -------------------------------------
+          TYPOGRAPHY
+      ------------------------------------- */
+      h1,
+      h2,
+      h3,
+      h4 {
+        color: #000000;
+        font-family: sans-serif;
+        font-weight: 400;
+        line-height: 1.4;
+        margin: 0;
+        Margin-bottom: 30px; }
+      h1 {
+        font-size: 35px;
+        font-weight: 300;
+        text-align: center;
+        text-transform: capitalize; }
+      p,
+      ul,
+      ol {
+        font-family: sans-serif;
+        font-size: 14px;
+        font-weight: normal;
+        margin: 0;
+        Margin-bottom: 15px; }
+        p li,
+        ul li,
+        ol li {
+          list-style-position: inside;
+          margin-left: 5px; }
+      a {
+        color: #3498db;
+        text-decoration: underline; }
+      /* -------------------------------------
+          BUTTONS
+      ------------------------------------- */
+      .btn {
+        box-sizing: border-box;
+        width: 100%; }
+        .btn > tbody > tr > td {
+          padding-bottom: 15px; }
+        .btn table {
+          width: auto; }
+        .btn table td {
+          background-color: #ffffff;
+          border-radius: 5px;
+          text-align: center; }
+        .btn a {
+          background-color: #ffffff;
+          border: solid 1px #3498db;
+          border-radius: 5px;
+          box-sizing: border-box;
+          color: #3498db;
+          cursor: pointer;
+          display: inline-block;
+          font-size: 14px;
+          font-weight: bold;
+          margin: 0;
+          padding: 12px 25px;
+          text-decoration: none;
+          text-transform: capitalize; }
+      .btn-primary table td {
+        background-color: #3498db; }
+      .btn-primary a {
+        background-color: #3498db;
+        border-color: #3498db;
+        color: #ffffff; }
+      /* -------------------------------------
+          OTHER STYLES THAT MIGHT BE USEFUL
+      ------------------------------------- */
+      .last {
+        margin-bottom: 0; }
+      .first {
+        margin-top: 0; }
+      .align-center {
+        text-align: center; }
+      .align-right {
+        text-align: right; }
+      .align-left {
+        text-align: left; }
+      .clear {
+        clear: both; }
+      .mt0 {
+        margin-top: 0; }
+      .mb0 {
+        margin-bottom: 0; }
+      .preheader {
+        color: transparent;
+        display: none;
+        height: 0;
+        max-height: 0;
+        max-width: 0;
+        opacity: 0;
+        overflow: hidden;
+        mso-hide: all;
+        visibility: hidden;
+        width: 0; }
+      .powered-by a {
+        text-decoration: none; }
+      hr {
+        border: 0;
+        border-bottom: 1px solid #f6f6f6;
+        Margin: 20px 0; }
+      /* -------------------------------------
+          RESPONSIVE AND MOBILE FRIENDLY STYLES
+      ------------------------------------- */
+      @media only screen and (max-width: 620px) {
+        table[class=body] h1 {
+          font-size: 28px !important;
+          margin-bottom: 10px !important; }
+        table[class=body] p,
+        table[class=body] ul,
+        table[class=body] ol,
+        table[class=body] td,
+        table[class=body] span,
+        table[class=body] a {
+          font-size: 16px !important; }
+        table[class=body] .wrapper,
+        table[class=body] .article {
+          padding: 10px !important; }
+        table[class=body] .content {
+          padding: 0 !important; }
+        table[class=body] .container {
+          padding: 0 !important;
+          width: 100% !important; }
+        table[class=body] .main {
+          border-left-width: 0 !important;
+          border-radius: 0 !important;
+          border-right-width: 0 !important; }
+        table[class=body] .btn table {
+          width: 100% !important; }
+        table[class=body] .btn a {
+          width: 100% !important; }
+        table[class=body] .img-responsive {
+          height: auto !important;
+          max-width: 100% !important;
+          width: auto !important; }}
+      /* -------------------------------------
+          PRESERVE THESE STYLES IN THE HEAD
+      ------------------------------------- */
+      @media all {
+        .ExternalClass {
+          width: 100%; }
+        .ExternalClass,
+        .ExternalClass p,
+        .ExternalClass span,
+        .ExternalClass font,
+        .ExternalClass td,
+        .ExternalClass div {
+          line-height: 100%; }
+        .apple-link a {
+          color: inherit !important;
+          font-family: inherit !important;
+          font-size: inherit !important;
+          font-weight: inherit !important;
+          line-height: inherit !important;
+          text-decoration: none !important; }
+        .btn-primary table td:hover {
+          background-color: #34495e !important; }
+        .btn-primary a:hover {
+          background-color: #34495e !important;
+          border-color: #34495e !important; } }
+    </style>
+</head>
+<body class="">
+<table border="0" cellpadding="0" cellspacing="0" class="body">
+    <tr>
+        <td>&nbsp;</td>
+        <td class="container">
+            <div class="content">
+
+                <!-- START CENTERED WHITE CONTAINER -->
+                <span class="preheader">This is preheader text. Some clients will show this text as a preview.</span>
+                <table class="main">
+
+                    <!-- START MAIN CONTENT AREA -->
+                    <tr>
+                        <td class="wrapper">
+                            <table border="0" cellpadding="0" cellspacing="0">
+                                <tr>
+                                    <td>
+                                        <p>Dear {recipient},</p>
+                                        <p>You have been invited to co-develop the Template {templateName}.</p>
+                                        <p>Click the button to redirect to {templateName}.</p>
+
+                                        <table border="0" cellpadding="0" cellspacing="0" class="btn btn-primary">
+                                            <tbody>
+                                            <tr>
+                                                <td align="left">
+                                                    <table border="0" cellpadding="0" cellspacing="0">
+                                                        <tbody>
+                                                        <tr>
+                                                            <td> <a href="{host}/dataset-profiles/{templateID}" target="_blank">{templateName}</a> </td>
+                                                        </tr>
+                                                        </tbody>
+                                                    </table>
+                                                </td>
+                                            </tr>
+                                            </tbody>
+                                        </table>
+
+                                    </td>
+                                </tr>
+                            </table>
+                        </td>
+                    </tr>
+
+                    <!-- END MAIN CONTENT AREA -->
+                </table>
+
+                <!-- START FOOTER -->
+                <div class="footer">
+
+                </div>
+                <!-- END FOOTER -->
+
+                <!-- END CENTERED WHITE CONTAINER -->
+            </div>
+        </td>
+        <td>&nbsp;</td>
+    </tr>
+</table>
+</body>
+</html>

dmp-backend/notification-service/notification-web/src/main/resources/notification_templates/Template/Email/subject.en.txt

@@ -0,0 +1 @@
+ARGOS - Template Invite

dmp-backend/notification-service/notification-web/src/main/resources/notification_templates/UnlinkConfirmation/Email/subject.en.txt

@@ -0,0 +1 @@
+ARGOS - Unlink Email Confirmation

dmp-backend/notification-service/notification-web/target/classes/certificates/elasticsearch_dev04.crt

@@ -0,0 +1,20 @@
+-----BEGIN CERTIFICATE-----
+MIIDUjCCAjqgAwIBAgIUKTnOSL0Rtnm8ZQkfSUvpQiBNGnMwDQYJKoZIhvcNAQEL
+BQAwNDEyMDAGA1UEAxMpRWxhc3RpYyBDZXJ0aWZpY2F0ZSBUb29sIEF1dG9nZW5l
+cmF0ZWQgQ0EwHhcNMTkwOTAzMTUyMDM1WhcNMjIwOTAyMTUyMDM1WjAYMRYwFAYD
+VQQDEw1lbGFzdGljc2VhcmNoMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC
+AQEAkB1OMRBRUDUxQ6fIv5gv0myKDZgVJFnEEjIjU6YjMpf/htTsvu8zdpBoWhg6
+7IsflSkUPynDG4geFjQ/WtxVeqxjnmtIB2fMDAHppX882as3tYjBlHj1sU0/OwwI
+Ga5/OtxOubGswrzCEEjIgZwTtSX2Yzx3tE2UzwjWsYwGCBM/ssN8Wc1vlqq20+Qr
+Lsggk+dXapN2wL9FABrxrJfV2SxXb2qKLKVd3EIfs+HVqIt9dVrpcFRV3Lwexg+Z
+wlJv58EPsynphczssBhMOhlmVqpRY8z88fqsbqDVdqHIF8hqn7czWFqeCRldnb7W
+LWaYaOG0Jd6SM7OpHnfNgBST4wIDAQABo3gwdjAdBgNVHQ4EFgQUCkDAcWSJ6H2G
+UFFh9dhk+mG0L08wHwYDVR0jBBgwFoAUDF2zHdVwSwxo9Z7sa9vIc4Sd+1MwKQYD
+VR0RBCIwIIIJbG9jYWxob3N0hwR/AAABgg1lbGFzdGljc2VhcmNoMAkGA1UdEwQC
+MAAwDQYJKoZIhvcNAQELBQADggEBAAQpkdkGl2H0ylgbmmNiIlrQX+U2i4ag4sJ6
+xsVR5OWxuyB/aMWhuOHkgueMh2wElufn60jK0Mh25b2U7oO/0Nq+28rhhP9HURLz
+7/TwCbLcglTAgHQPWItwn5r5WKDFNCPNpZXFU/oG5H6hUJqTvuaTN6G/PQ6V9Yp3
+J00NbPuFq8tjNAc/kQnhC7zdC/7YQ/fanHBPkvQnkGbac5+VAF/se/JYbxRpSz23
+5a+v6BDb/kjs82QgV8dzsyFmntO+Neesu9tTJurBbQD5T3xMgoGSWLgnTCq3/drl
+PMBLgUQHik629dU+7o8ePCdyULruGMR6CIBqO7ZKQASulhkxdUo=
+-----END CERTIFICATE-----

dmp-backend/notification-service/notification-web/target/classes/config/application.yml

@@ -0,0 +1,20 @@
+spring:
+  jackson:
+    default-property-inclusion: non_null
+  config:
+    import: optional:classpath:config/app.env[.properties], optional:file:../config/app.env[.properties],
+      optional:classpath:config/db.yml[.yml], optional:classpath:config/db-${spring.profiles.active}.yml[.yml], optional:file:../config/db-${spring.profiles.active}.yml[.yml],
+      optional:classpath:config/permissions.yml[.yml], optional:classpath:config/permissions-${spring.profiles.active}.yml[.yml], optional:file:../config/permissions-${spring.profiles.active}.yml[.yml],
+      optional:classpath:config/errors.yml[.yml], optional:classpath:config/errors-${spring.profiles.active}.yml[.yml], optional:file:../config/errors-${spring.profiles.active}.yml[.yml],
+      optional:classpath:config/security.yml[.yml], optional:classpath:config/security-${spring.profiles.active}.yml[.yml], optional:file:../config/security-${spring.profiles.active}.yml[.yml],
+      optional:classpath:config/server.yml[.yml], optional:classpath:config/server-${spring.profiles.active}.yml[.yml], optional:file:../config/server-${spring.profiles.active}.yml[.yml],
+      optional:classpath:config/logging.yml[.yml], optional:classpath:config/logging-${spring.profiles.active}.yml[.yml], optional:file:../config/logging-${spring.profiles.active}.yml[.yml],
+      optional:classpath:config/idpclaims.yml[.yml], optional:classpath:config/idpclaims-${spring.profiles.active}.yml[.yml], optional:file:../config/idpclaims-${spring.profiles.active}.yml[.yml],
+      optional:classpath:config/cache.yml[.yml], optional:classpath:config/cache-${spring.profiles.active}.yml[.yml], optional:file:../config/cache-${spring.profiles.active}.yml[.yml],
+      optional:classpath:config/tenant.yml[.yml], optional:classpath:config/tenant-${spring.profiles.active}.yml[.yml], optional:file:../config/tenant-${spring.profiles.active}.yml[.yml],
+      optional:classpath:config/locale.yml[.yml], optional:classpath:config/locale-${spring.profiles.active}.yml[.yml], optional:file:../config/locale-${spring.profiles.active}.yml[.yml],
+      optional:classpath:config/cors.yml[.yml], optional:classpath:config/cors-${spring.profiles.active}.yml[.yml], optional:file:../config/cors-${spring.profiles.active}.yml[.yml],
+      optional:classpath:config/notification.yml[.yml], optional:classpath:config/notification-${spring.profiles.active}.yml[.yml], optional:file:../config/notification-${spring.profiles.active}.yml[.yml],
+      optional:classpath:config/email.yml[.yml], optional:classpath:config/email-${spring.profiles.active}.yml[.yml], optional:file:../config/email-${spring.profiles.active}.yml[.yml],
+      optional:classpath:config/cipher.yml[.yml], optional:classpath:config/cipher-${spring.profiles.active}.yml[.yml], optional:file:../config/cipher-${spring.profiles.active}.yml[.yml],
+      optional:classpath:config/formatting.yml[.yml], optional:classpath:config/formatting-${spring.profiles.active}.yml[.yml], optional:file:../config/formatting-${spring.profiles.active}.yml[.yml]

dmp-backend/notification-service/notification-web/target/classes/config/cache.yml

@@ -0,0 +1,77 @@
+cache:
+  manager:
+    fallbackToNoOpCache: true
+    caffeineCaches:
+      - names: [ apikey ]
+        allowNullValues: true
+        initialCapacity: 100
+        maximumSize: 500
+        enableRecordStats: false
+        expireAfterWriteMinutes: 10
+        expireAfterAccessMinutes: 10
+        refreshAfterWriteMinutes: 10
+      - names: [ tenantByCode ]
+        allowNullValues: true
+        initialCapacity: 100
+        maximumSize: 500
+        enableRecordStats: false
+        expireAfterWriteMinutes: 10
+        expireAfterAccessMinutes: 10
+        refreshAfterWriteMinutes: 10
+      - names: [ tenantById ]
+        allowNullValues: true
+        initialCapacity: 100
+        maximumSize: 500
+        enableRecordStats: false
+        expireAfterWriteMinutes: 10
+        expireAfterAccessMinutes: 10
+        refreshAfterWriteMinutes: 10
+      - names: [ userBySubjectId ]
+        allowNullValues: true
+        initialCapacity: 100
+        maximumSize: 500
+        enableRecordStats: false
+        expireAfterWriteMinutes: 5
+        expireAfterAccessMinutes: 5
+        refreshAfterWriteMinutes: 5
+      - names: [ userAccessTenant ]
+        allowNullValues: true
+        initialCapacity: 100
+        maximumSize: 500
+        enableRecordStats: false
+        expireAfterWriteMinutes: 5
+        expireAfterAccessMinutes: 5
+        refreshAfterWriteMinutes: 5
+      - names: [ formattingUserProfile ]
+        allowNullValues: true
+        initialCapacity: 100
+        maximumSize: 500
+        enableRecordStats: false
+        expireAfterWriteMinutes: 1
+        expireAfterAccessMinutes: 1
+        refreshAfterWriteMinutes: 1
+    mapCaches:
+      - names: [ cacheB ]
+        allowNullValues: true
+        storeByValue: true
+  apiKey:
+    name: apikey
+    keyPattern: resolve_$keyhash$:v0
+  userBySubjectId:
+    name: userBySubjectId
+    keyPattern: user_by_subject_$subject$:v0
+  tenantByCode:
+    name: tenantByCode
+    keyPattern: tenant_by_code_$code$:v0
+  tenantById:
+    name: tenantById
+    keyPattern: tenant_by_id_$tenantId$:v0
+  userAllowedTenant:
+    name: userAccessTenant
+    keyPattern: user_access_tenant_$user_id$_$tenant_id$:v0
+  formattingUserProfileCache:
+    name: formattingUserProfile
+    keyPattern: formatting_user_profile$user_id$:v0
+  template:
+    name: template
+    key-pattern: ------

dmp-backend/notification-service/notification-web/target/classes/config/cipher.yml

@@ -0,0 +1,35 @@
+cipher-profiles:
+  profile-map:
+    configuration-profile-name: "configuration"
+    queue-profile-name: "queue"
+    notification-profile-name: "queue"
+
+cipher:
+#  salted-hash:
+#    default-o: null
+#    options: null
+  symetric-encryption:
+    default-o: null
+    options:
+      configuration:
+        aes:
+          key: ${CIPHER_SYMETRIC_ENCRYPTION_CONFIGURATION_AES_KEY:}
+          iv: ${CIPHER_SYMETRIC_ENCRYPTION_CONFIGURATION_AES_IV:}
+      queue:
+        aes:
+          key: ${CIPHER_SYMETRIC_ENCRYPTION_QUEUE_AES_KEY:}
+          iv: ${CIPHER_SYMETRIC_ENCRYPTION_QUEUE_AES_IV:}
+  masking:
+    default: null
+    options:
+      configuration:
+        character: "*"
+        clear-begining: 2
+        clear-ending: 4
+        at-least-percentage: 70
+  digital-signature:
+    default: null
+    options:
+      configuration:
+        certificate-path: null
+        certificate-password: null

dmp-backend/notification-service/notification-web/target/classes/config/cors-devel.yml

@@ -0,0 +1,3 @@
+web:
+  cors:
+    allowed-origins: [ http://localhost, http://localhost:4200 ]

dmp-backend/notification-service/notification-web/target/classes/config/cors.yml

@@ -0,0 +1,7 @@
+web:
+  cors:
+    enabled: true
+    allowed-methods: [ HEAD, GET, POST, PUT, DELETE, PATCH ]
+    allowed-headers: [ Authorization, Cache-Control, Content-Type, Content-Disposition, x-tenant ]
+    exposed-headers: [ Authorization, Cache-Control, Content-Type, Content-Disposition ]
+    allow-credentials: false

dmp-backend/notification-service/notification-web/target/classes/config/db-devel.yml

@@ -0,0 +1,7 @@
+spring:
+  jpa:
+    show-sql: true
+    properties:
+      hibernate:
+        show_sql: true
+        format_sql: false

dmp-backend/notification-service/notification-web/target/classes/config/db.yml

@@ -0,0 +1,21 @@
+spring:
+  jpa:
+    properties:
+      hibernate:
+        ddl-auto: validate
+        dialect: org.hibernate.dialect.PostgreSQLDialect
+    hibernate:
+      naming:
+        physical-strategy: org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl
+        implicit-strategy: org.springframework.boot.orm.jpa.hibernate.SpringImplicitNamingStrategy
+  datasource:
+    url: ${DB_CONNECTION_STRING}
+    username: ${DB_USER}
+    password: ${DB_PASSWORD}
+    driver-class-name: org.postgresql.Driver
+    hikari:
+      connection-timeout: 30000
+      minimum-idle: 3
+      maximum-pool-size: 5
+      idle-timeout: 600000
+      max-lifetime: 1800000

dmp-backend/notification-service/notification-web/target/classes/config/email.yml

@@ -0,0 +1,14 @@
+spring:
+  mail:
+    host: ${MAIL_HOST:}
+    port: ${MAIL_PORT:}
+    username: ${MAIL_USERNAME:}
+    password: ${MAIL_PASSWORD:}
+    properties:
+      mail:
+        smtp:
+          auth: ${MAIL_AUTH:}
+          starttls:
+            enable: ${MAIL_TLS:}
+email:
+  address: ${MAIL_ADDRESS:}

dmp-backend/notification-service/notification-web/target/classes/config/errors.yml

@@ -0,0 +1,43 @@
+error-thesaurus:
+  hash-conflict:
+    code: 100
+    message: there is a hash conflict for the item modified. please reload to get the latest changes
+  forbidden:
+    code: 101
+    message: insufficient rights
+  system-error:
+    code: 102
+    message: an unexpected system error occurred
+  missing-tenant:
+    code: 103
+    message: tenant scope not provided
+  invalid-api-key:
+    code: 104
+    message: provided APIKey not valid
+  stale-api-key:
+    code: 105
+    message: there was a problem authorizing you with your API key. Please try again. Contact the system administrator if the problem persists
+  model-validation:
+    code: 106
+    message: validation error
+  sensitive-info:
+    code: 107
+    message: you are attempting to access sensitive information. please don't do that
+  non-person-principal:
+    code: 108
+    message: the operation is available only to person users
+  blocking-consent:
+    code: 113
+    message: user consents are not sufficient to complete the operation
+  single-tenant-configuration-per-type-supported:
+    code: 116
+    message: a single tenant configuration entry per config type is supported
+  incompatible-tenant-configuration-types:
+    code: 117
+    message: the provided tenant configuration type is incompatible
+  missing-totp-token:
+    code: 118
+    message: totp token not provided
+  overlapping-tenant-configuration-notifier-list:
+    code: 119
+    message: Overlapping Tenant Configuration Notifier List

dmp-backend/notification-service/notification-web/target/classes/config/formatting.yml

@@ -0,0 +1,6 @@
+formatting:
+  options:
+    integer-format: "%,d"
+    decimal-digits-round: 2
+    decimal-format: "#0.00"
+    date-time-format: "YYYY-MM-dd'T'HH:mm:ss"

dmp-backend/notification-service/notification-web/target/classes/config/idpclaims.yml

@@ -0,0 +1,50 @@
+idpclient:
+  claims:
+    mapping:
+      Subject:
+        - type: sub
+      Name:
+        - type: name
+      Client:
+        - type: client_id
+      AuthenticationMethod:
+        - type: amr
+      NotBefore:
+        - type: nbf
+      AuthenticatedAt:
+        - type: auth_time
+      ExpiresAt:
+        - type: exp
+      Email:
+        - type: email
+      Roles:
+        - type: resource_access
+          path: intelcomp-sti-viewer-dev.roles
+        - type: authorities
+          filterBy: "(.*):::TenantCode::"
+          extractByExpression: "(.*):(.*)"
+          extractExpressionValue: "[[g1]]"
+      Scope:
+        - type: scope
+      AccessToken:
+        - type: x-access-token
+          visibility: SENSITIVE
+      Tenant:
+        - type: x-tenant
+      IssuedAt:
+        - type: iat
+      Issuer:
+        - type: iss
+      Audience:
+        - type: aud
+      TokenType:
+        - type: typ
+      AuthorizedParty:
+        - type: azp
+      Authorities:
+        - type: authorities
+      TenantCodes:
+        - type: authorities
+          filterBy: "(.*):(.*)"
+          extractByExpression: "(.*):(.*)"
+          extractExpressionValue: "[[g2]]"

dmp-backend/notification-service/notification-web/target/classes/config/locale.yml

@@ -0,0 +1,4 @@
+locale:
+  timezone: UTC
+  language: en
+  culture: en-US

dmp-backend/notification-service/notification-web/target/classes/config/logging-devel.yml

@@ -0,0 +1,2 @@
+logging:
+  config: classpath:logging/logback-dev.xml

dmp-backend/notification-service/notification-web/target/classes/config/logging.yml

@@ -0,0 +1,35 @@
+logging:
+  context:
+    request:
+      requestIdKey: req.id
+      requestRemoteHostKey: req.remoteHost
+      requestUriKey: req.requestURI
+      requestQueryStringKey: req.queryString
+      requestUrlKey : req.requestURL
+      requestMethodKey: req.method
+      requestUserAgentKey: req.userAgent
+      requestForwardedForKey: req.xForwardedFor
+      requestSchemeKey: req.scheme
+      requestRemoteAddressKey: req.remoteAddr
+      requestRemotePortKey: req.remotePort
+      requestRemoteUserKey: req.remoteUser
+    principal:
+      subjectKey: usr.subject
+      nameKey: usr.name
+      clientKey: usr.client
+audit:
+  enable: true
+  requestRemoteHostKey: req.remoteHost
+  requestUriKey: req.requestURI
+  requestQueryStringKey: req.queryString
+  requestUrlKey : req.requestURL
+  requestMethodKey: req.method
+  requestUserAgentKey: req.userAgent
+  requestForwardedForKey: req.xForwardedFor
+  requestSchemeKey: req.scheme
+  requestRemoteAddressKey: req.remoteAddr
+  requestRemotePortKey: req.remotePort
+  requestRemoteUserKey: req.remoteUser
+  principalSubjectKey: usr.subject
+  principalNameKey: usr.name
+  principalClientKey: usr.client

dmp-backend/notification-service/notification-web/target/classes/config/notification-devel.yml

@@ -0,0 +1,6 @@
+notification:
+  staticFields:
+    fields: 
+      - key: "{installation-url}"
+        type: "String"
+        value: "http://localhost:42000"

dmp-backend/notification-service/notification-web/target/classes/config/notification.yml

@@ -0,0 +1,246 @@
+notification:
+  task:
+    processor:
+      enable: true
+      interval-seconds: 30
+      options:
+        retry-threshold: 300
+        max-retry-delay-seconds: 10800
+        too-old-to-send-seconds: 36000
+        too-old-to-track-seconds: 604800
+      overrides: []
+  resolver:
+    global-policies: 
+        - #Confirmation
+          type: 4FDBFA80-7A71-4A69-B854-67CBB70648F1
+          contacts: [ email ]
+        - #DataManagementPlan
+          type: 065DEECD-21BB-44AF-9983-E660FDF24BC4
+          contacts: [ email ]
+        - #Finalised
+          type: 90DB0B46-42DE-BD89-AEBF-6F27EFEB256E
+          contacts: [ email ]
+        - #MergeConfirmation
+          type: BFE68845-CB05-4C5A-A03D-29161A7C9660
+          contacts: [ email ]
+        - #Modified
+          type: 4542262A-22F8-4BAA-9DB6-1C8E70AC1DBB
+          contacts: [ email ]
+        - #ModifiedFinalised
+          type: D3CD55FE-8DA2-42E7-A501-3795EE4F16D3
+          contacts: [ email ]
+        - #Publish
+          type: 55736F7A-83AB-4190-AF43-9D031A6F9612
+          contacts: [ email ]
+        - #Template
+          type: 223BB607-EFA1-4CE7-99EC-4BEABFEF9A8B
+          contacts: [ email ]
+        - #UnlinkConfirmation
+          type: C9BC3F16-057E-4BBA-8A5F-36BD835E5604
+          contacts: [ email ]
+  ad-hoc-config:
+    ad-hoc-notification-type: null
+  message:
+    email:
+      flows:
+          - #Confirmation
+            key: 4FDBFA80-7A71-4A69-B854-67CBB70648F1
+            subject-path: classpath:notification_templates/Confirmation/Email/subject.{language}.txt
+            subject-field-options:
+              mandatory: [ ]
+              optional: [ ]
+
+            body-path: classpath:notification_templates/Confirmation/Email/body.{language}.html
+            body-field-options:
+              mandatory: [ ]
+              optional:
+                  - key: "{expiration_time}"
+                    value: --
+              formatting:
+                '[{expiration_time}]': null
+            cc: [ ]
+            cc-mode: 0
+            bcc: [ ]
+            bcc-mode: 0
+            allow-attachments: false
+            cipher-fields: [ ]
+          -  #DataManagementPlan
+            key: 065DEECD-21BB-44AF-9983-E660FDF24BC4
+            subject-path: classpath:notification_templates/DataManagementPlan/Email/subject.{language}.txt
+            subject-field-options:
+              mandatory: [ ]
+              optional: [ ]
+            body-path: classpath:notification_templates/DataManagementPlan/Email/body.{language}.html
+            body-field-options:
+              mandatory: [ "{dmpname}", "{dmprole}" ]
+              optional:
+                - key: "{recipient}"
+                  value:
+              formatting:
+                '[{dmpname}]': null
+                '[{dmprole}]': null
+                '[{recipient}]': null
+            cc: [ ]
+            cc-mode: 0
+            bcc: [ ]
+            bcc-mode: 0
+            allow-attachments: false
+            cipher-fields: [ ]
+          -   #Finalised
+            key: 90DB0B46-42DE-BD89-AEBF-6F27EFEB256E
+            subject-path: classpath:notification_templates/Finalised/Email/subject.{language}.txt
+            subject-field-options:
+              mandatory: [ ]
+              optional: [ ]
+            body-path: classpath:notification_templates/Finalised/Email/body.{language}.html
+            body-field-options:
+              mandatory: [ "{reasonName}", "{name}" ]
+              optional:
+                - key: "{recipient}"
+                  value:
+              formatting:
+                '[{reasonName}]': null
+                '[{name}]': null
+                '[{recipient}]': null
+            cc: [ ]
+            cc-mode: 0
+            bcc: [ ]
+            bcc-mode: 0
+            allow-attachments: false
+            cipher-fields: [ ]
+          -  #MergeConfirmation
+            key: BFE68845-CB05-4C5A-A03D-29161A7C9660
+            subject-path: classpath:notification_templates/MergeConfirmation/Email/subject.{language}.txt
+            subject-field-options:
+              mandatory: [ ]
+              optional: [ ]
+            body-path: classpath:notification_templates/MergeConfirmation/Email/body.{language}.html
+            body-field-options:
+              mandatory: [ "{userName}", "{host}" ]
+              optional:
+                - key: "{expiration_time}"
+                  value: ---
+              formatting:
+                '[{userName}]': null
+                '[{host}]': null
+                '[{expiration_time}]': null
+            cc: [ ]
+            cc-mode: 0
+            bcc: [ ]
+            bcc-mode: 0
+            allow-attachments: false
+            cipher-fields: [ ]
+          -   #Modified
+            key: 4542262A-22F8-4BAA-9DB6-1C8E70AC1DBB
+            subject-path: classpath:notification_templates/Modified/Email/subject.{language}.txt
+            subject-field-options:
+              mandatory: [ ]
+              optional: [ ]
+            body-path: classpath:notification_templates/Modified/Email/body.{language}.html
+            body-field-options:
+              mandatory: [ "{reasonName}", "{name}" ]
+              optional:
+                - key: "{recipient}"
+                  value:
+              formatting:
+                '[{reasonName}]': null
+                '[{name}]': null
+                '[{recipient}]': null
+            cc: [ ]
+            cc-mode: 0
+            bcc: [ ]
+            bcc-mode: 0
+            allow-attachments: false
+            cipher-fields: [ ]
+          -    #ModifiedFinalised
+            key: D3CD55FE-8DA2-42E7-A501-3795EE4F16D3
+            subject-path: classpath:notification_templates/ModifiedFinalised/Email/subject.{language}.txt
+            subject-field-options:
+              mandatory: [ ]
+              optional: [ ]
+            body-path: classpath:notification_templates/ModifiedFinalised/Email/body.{language}.html
+            body-field-options:
+              mandatory: [ "{reasonName}", "{name}" ]
+              optional:
+                - key: "{recipient}"
+                  value:
+              formatting:
+                '[{reasonName}]': null
+                '[{name}]': null
+                '[{recipient}]': null
+            cc: [ ]
+            cc-mode: 0
+            bcc: [ ]
+            bcc-mode: 0
+            allow-attachments: false
+            cipher-fields: [ ]
+          -   #Publish
+            key: 55736F7A-83AB-4190-AF43-9D031A6F9612
+            subject-path: classpath:notification_templates/Publish/Email/subject.{language}.txt
+            subject-field-options:
+              mandatory: [ ]
+              optional: [ ]
+            body-path: classpath:notification_templates/Publish/Email/body.{language}.html
+            body-field-options:
+              mandatory: [ "{reasonName}", "{name}" ]
+              optional:
+                - key: "{recipient}"
+                  value:
+              formatting:
+                '[{reasonName}]': null
+                '[{name}]': null
+                '[{recipient}]': null
+            cc: [ ]
+            cc-mode: 0
+            bcc: [ ]
+            bcc-mode: 0
+            allow-attachments: false
+            cipher-fields: [ ]
+          -    #Template
+            key: 223BB607-EFA1-4CE7-99EC-4BEABFEF9A8B
+            subject-path: classpath:notification_templates/Template/Email/subject.{language}.txt
+            subject-field-options:
+              mandatory: [ ]
+              optional: [ ]
+            body-path: classpath:notification_templates/Template/Email/body.{language}.html
+            body-field-options:
+              mandatory: [ "{templateName}" ]
+              optional:
+                - key: "{recipient}"
+                  value:
+              formatting:
+                '[{templateName}]': null
+                '[{recipient}]': null
+            cc: [ ]
+            cc-mode: 0
+            bcc: [ ]
+            bcc-mode: 0
+            allow-attachments: false
+            cipher-fields: [ ]
+          -    #UnlinkConfirmation
+            key: C9BC3F16-057E-4BBA-8A5F-36BD835E5604
+            subject-path: classpath:notification_templates/UnlinkConfirmation/Email/subject.{language}.txt
+            subject-field-options:
+              mandatory: [ ]
+              optional: [ ]
+            body-path: classpath:notification_templates/UnlinkConfirmation/Email/body.{language}.html
+            body-field-options:
+              mandatory: [ ]
+              optional:
+                - key: "{email}"
+                  value:
+              formatting:
+                '[{email}]': null
+            cc: [ ]
+            cc-mode: 0
+            bcc: [ ]
+            bcc-mode: 0
+            allow-attachments: false
+            cipher-fields: [ ]
+      template-cache:
+        prefix: ${CACHE_DISAMBIGUATION:}
+        key-pattern: "{prefix}:Notification_Message_Email_Template:{key}:v0"
+  override-cache:
+    template-cache:
+      prefix: ${CACHE_DISAMBIGUATION:}
+      key-pattern: "{prefix}:Notification_Override_Template:{tenant}:{type}:{channel}:{{language}}:v0"

dmp-backend/notification-service/notification-web/target/classes/config/permissions.yml

@@ -0,0 +1,143 @@
+permissions:
+  extendedClaims: [ ]
+  policies:
+
+    # Tenants
+    BrowseTenant:
+      roles:
+        - ic-sti-superuser
+      clients: [ ]
+      allowAnonymous: false
+      allowAuthenticated: false
+    EditTenant:
+      roles:
+        - ic-sti-superuser
+      clients: [ ]
+      allowAnonymous: false
+      allowAuthenticated: false
+    DeleteTenant:
+      roles:
+        - ic-sti-superuser
+      claims: [ ]
+      clients: [ ]
+      allowAnonymous: false
+      allowAuthenticated: false
+    AllowNoTenant:
+      roles:
+        - ic-sti-superuser
+      claims: [ ]
+      clients: [ ]
+      allowAnonymous: false
+      allowAuthenticated: false
+    # Users
+    BrowseUser:
+      roles:
+        - ic-sti-superuser
+        - tenantadmin
+      clients: [ ]
+      allowAnonymous: true
+      allowAuthenticated: false
+    EditUser:
+      roles:
+        - admin
+        - ic-sti-superuser
+      clients: [ ]
+      allowAnonymous: false
+      allowAuthenticated: false
+    DeleteUser:
+      roles:
+        - ic-sti-superuser
+      claims: [ ]
+      clients: [ ]
+      allowAnonymous: false
+      allowAuthenticated: false
+    # UserContactInfo
+    BrowseUserContactInfo:
+      roles:
+        - ic-sti-superuser
+      clients: [ ]
+      allowAnonymous: true
+      allowAuthenticated: false
+    EditUserContactInfo:
+      roles:
+        - ic-sti-superuser
+        - user
+      clients: [ ]
+      allowAnonymous: false
+      allowAuthenticated: false
+    DeleteUserContactInfo:
+      roles:
+        - ic-sti-superuser
+      claims: [ ]
+      clients: [ ]
+      allowAnonymous: false
+      allowAuthenticated: false
+    #Notification
+    BrowseNotification:
+      roles:
+        - ic-sti-superuser
+        - user
+      clients: [ ]
+      allowAnonymous: true
+      allowAuthenticated: false
+    EditNotification:
+      roles:
+        - ic-sti-superuser
+        - user
+      clients: [ ]
+      allowAnonymous: true
+      allowAuthenticated: false
+    #Tenant Configuration
+    BrowseTenantConfiguration:
+      roles:
+        - ic-sti-superuser
+      clients: [ ]
+      allowAnonymous: false
+      allowAuthenticated: false
+    EditTenantConfiguration:
+      roles:
+        - ic-sti-superuser
+      clients: [ ]
+      allowAnonymous: false
+      allowAuthenticated: false
+    #User Notification Preference
+    BrowseUserNotificationPreference:
+      roles:
+        - ic-sti-superuser
+      clients: [ ]
+      allowAnonymous: true
+      allowAuthenticated: false
+    EditUserNotificationPreference:
+      roles:
+        - ic-sti-superuser
+        - user
+      clients: [ ]
+      allowAnonymous: false
+      allowAuthenticated: false
+  
+    # ViewPage Permissions
+    ViewNotificationPage:
+      roles:
+        - ic-sti-superuser
+      clients: [ ]
+      allowAnonymous: false
+      allowAuthenticated: false
+    ViewNotificationEventRulePage:
+      roles:
+        - ic-sti-superuser
+      clients: [ ]
+      allowAnonymous: false
+      allowAuthenticated: false
+    ViewInAppNotificationPage:
+      roles:
+        - ic-sti-superuser
+        - tenantadmin
+      clients: [ ]
+      allowAnonymous: false
+      allowAuthenticated: false
+    ViewNotificationTemplatePage:
+      roles:
+        - ic-sti-superuser
+      clients: [ ]
+      allowAnonymous: false
+      allowAuthenticated: false

dmp-backend/notification-service/notification-web/target/classes/config/queue-devel.yml

@@ -0,0 +1,18 @@
+queue:
+  rabbitmq:
+    durable: true
+    queue: cite_dmp_devel_notification_inbox_queue
+    exchange: cite_dmp_devel_queue
+    listenerEnabled: true
+    publisherEnabled: true
+  task:
+    publisher:
+      options:
+        exchange: cite_dmp_devel_queue
+      rabbitmq:
+        enable: true
+    listener:
+      options:
+        exchange: cite_dmp_devel_queue
+      rabbitmq:
+        enable: false

dmp-backend/notification-service/notification-web/target/classes/config/queue.yml

@@ -0,0 +1,58 @@
+spring:
+  rabbitmq:
+    host: ${RABBIT_HOST}
+    port: ${RABBIT_PORT}
+    username: ${RABBIT_USER}
+    password: ${RABBIT_PASS}
+    ssl:
+      enabled: false
+queue:
+  rabbitmq:
+    enable: false
+    app-id: ${THE_API_ID}
+    durable: null
+    queue: null
+    exchange: null
+    listenerEnabled: true
+    publisherEnabled: true
+    #TODO
+    connection-recovery:
+      enable: true
+      network-recovery-interval: 5000
+      unreachable-recovery-interval: 5000
+  task:
+    publisher:
+      enable: false
+      options:
+        exchange: null
+        forget-me-completed-topic: forgetme.completed
+        notify-topic: notification.notify
+        tenant-reactivation-topic: tenant.reactivated
+        tenant-removal-topic: tenant.remove
+        tenant-touch-topic: tenant.touch
+        tenant-user-invite-topic: tenant.invite
+        what-you-know-about-me-completed-topic: whatyouknowaboutme.completed
+        generate-file-topic: generate.file
+      rabbitmq:
+        enable: false
+        interval-seconds: 30
+        options:
+          retry-threashold: 100
+          retry-delay-step-seconds: 300
+          max-retry-delay-seconds: 10800
+          too-old-to-send-seconds: 604800
+          confirm-timeout-seconds: 30
+    listener:
+      enable: false
+      options:
+        exchange: null
+        user-removal-topic: [ "user.remove" ]
+        user-touched-topic: [ "user.touch" ]
+      rabbitmq:
+        enable: false
+        interval-seconds: 30
+        options:
+          retry-threashold: 100
+          retry-delay-step-seconds: 300
+          max-retry-delay-seconds: 10800
+          too-old-to-send-seconds: 604800

dmp-backend/notification-service/notification-web/target/classes/config/security.yml

@@ -0,0 +1,20 @@
+web:
+  security:
+    enabled: true
+    authorized-endpoints: [ api ]
+    allowed-endpoints: [ public, dataset, master-item, test ]
+    idp:
+      api-key:
+        enabled: true
+        authorization-header: Authorization
+        client-id: ${IDP_APIKEY_CLIENT_ID}
+        client-secret: ${IDP_APIKEY_CLIENT_SECRET}
+        scope: ${IDP_APIKEY_SCOPE}
+      resource:
+        token-type: JWT
+        opaque:
+          client-id: ${IDP_OPAQUE_CLIENT_ID}
+          client-secret: ${IDP_OPAQUE_CLIENT_SECRET}
+        jwt:
+          claims: [ role, x-role ]
+          issuer-uri: ${IDP_ISSUER_URI:}

dmp-backend/notification-service/notification-web/target/classes/config/server-devel.yml

@@ -0,0 +1,2 @@
+server:
+  forward-headers-strategy: FRAMEWORK

dmp-backend/notification-service/notification-web/target/classes/config/server.yml

@@ -0,0 +1,3 @@
+server:
+  port: ${WEB_PORT}
+  forward-headers-strategy: NONE

dmp-backend/notification-service/notification-web/target/classes/config/tenant.yml

@@ -0,0 +1,8 @@
+tenant:
+  multitenancy:
+    is-multitenant: false
+  interceptor:
+    client-claims-prefix: client_
+    white-listed-clients: [ ]
+    enforce-trusted-tenant: false
+    white-listed-endpoints: [ '/api/principal/my-tenants',  '/api/principal/me','/api/user/user-settings', '/error', '/api/tenant-request' ]

dmp-backend/notification-service/notification-web/target/classes/logging/logback-dev.xml

@@ -0,0 +1,61 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration debug="true">
+	<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+		<encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
+			<Pattern>%date{ISO8601} [%thread] %-5level %logger{36} [%X{req.id}] - %message%n</Pattern>
+		</encoder>
+	</appender>
+
+	<appender name="TROUBLESHOOTING" class="ch.qos.logback.core.rolling.RollingFileAppender">
+		<file>logs/logging.log</file>
+		<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+			<fileNamePattern>logs/logging.%d{yyyy-MM-dd}.%i.log</fileNamePattern>
+			<timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
+				<maxFileSize>100MB</maxFileSize>
+			</timeBasedFileNamingAndTriggeringPolicy>
+			<maxHistory>15</maxHistory>
+		</rollingPolicy>
+		<encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
+			<Pattern>%date{ISO8601} [%thread] %-5level %logger{36} [%X{req.id}] - %message%n</Pattern>
+		</encoder>
+	</appender>
+
+	<appender name="AUDITING" class="ch.qos.logback.core.rolling.RollingFileAppender">
+		<file>logs/auditing.log</file>
+		<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+			<fileNamePattern>logs/auditing.%d{yyyy-MM-dd}.%i.log</fileNamePattern>
+			<timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
+				<maxFileSize>100MB</maxFileSize>
+			</timeBasedFileNamingAndTriggeringPolicy>
+			<maxHistory>15</maxHistory>
+		</rollingPolicy>
+		<encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
+			<Pattern>%date{ISO8601} - %X{req.id} - %message%n</Pattern>
+		</encoder>
+	</appender>
+
+	<logger name="org.springframework.web" level="INFO" additivity="false">
+		<appender-ref ref="TROUBLESHOOTING"/>
+		<appender-ref ref="STDOUT"/>
+	</logger>
+	<logger name="org.hibernate" level="INFO" additivity="false">
+		<appender-ref ref="TROUBLESHOOTING"/>
+		<appender-ref ref="STDOUT"/>
+	</logger>
+	<logger name="gr.cite" level="DEBUG" additivity="false">
+		<appender-ref ref="TROUBLESHOOTING"/>
+		<appender-ref ref="STDOUT"/>
+	</logger>
+	<logger name="org.springframework.data.elasticsearch.client.WIRE" level="TRACE" additivity="false">
+		<appender-ref ref="TROUBLESHOOTING"/>
+		<appender-ref ref="STDOUT"/>
+	</logger>
+	<logger name="audit" level="INFO" additivity="false">
+		<appender-ref ref="AUDITING"/>
+		<appender-ref ref="STDOUT"/>
+	</logger>
+	<root level="info">
+		<appender-ref ref="TROUBLESHOOTING"/>
+		<appender-ref ref="STDOUT"/>
+	</root>
+</configuration>