From e812fd56b89812140283b6f4a35261acdfeccebf Mon Sep 17 00:00:00 2001
From: RIHTARSIC Joze <joze.rihtarsic@ext.ec.europa.eu>
Date: Thu, 27 Apr 2023 07:34:16 +0200
Subject: [PATCH] enable back alerts
---
.../edelivery/smp/data/dao/CredentialDao.java | 127 ++++-----
.../ec/edelivery/smp/data/dao/QueryNames.java | 6 +
.../ec/edelivery/smp/data/dao/UserDao.java | 33 +--
.../ec/edelivery/smp/data/model/DBAlert.java | 5 +-
.../smp/data/model/user/DBCredential.java | 84 ++----
.../edelivery/smp/data/model/user/DBUser.java | 88 ++++---
.../smp/services/CredentialService.java | 9 +-
.../services/CredentialValidatorService.java | 35 +--
.../smp/services/CredentialsAlertService.java | 246 +++++++-----------
.../smp/data/dao/CredentialDaoAlertsTest.java | 213 +++++++++++++++
.../smp/data/dao/UserDaoAlertsTest.java | 180 -------------
.../smp/services/AlertServiceTest.java | 18 +-
.../CredentialValidatorServiceTest.java | 79 +++---
.../edelivery/smp/testutil/TestDBUtils.java | 25 +-
14 files changed, 530 insertions(+), 618 deletions(-)
create mode 100644 smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/data/dao/CredentialDaoAlertsTest.java
delete mode 100644 smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/data/dao/UserDaoAlertsTest.java
diff --git a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/data/dao/CredentialDao.java b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/data/dao/CredentialDao.java
index d2ed00ff2..858c541d7 100644
--- a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/data/dao/CredentialDao.java
+++ b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/data/dao/CredentialDao.java
@@ -43,9 +43,9 @@ import static eu.europa.ec.edelivery.smp.exceptions.ErrorCode.ILLEGAL_STATE_USER
@Repository
public class CredentialDao extends BaseDao<DBCredential> {
private static final SMPLogger LOG = SMPLoggerFactory.getLogger(CredentialDao.class);
- private static final String QUERY_PARAM_ALERT_CREDENTIAL_START_DATE = "startAlertDate";
+ private static final String QUERY_PARAM_ALERT_CREDENTIAL_START_ALERT_SEND_DATE = "start_alert_send_date";
private static final String QUERY_PARAM_ALERT_CREDENTIAL_END_DATE = "endAlertDate";
- private static final String QUERY_PARAM_ALERT_CREDENTIAL_EXPIRE_DATE = "expireDate";
+ private static final String QUERY_PARAM_ALERT_CREDENTIAL_EXPIRE_TEST_DATE = "expire_test_date";
private static final String QUERY_PARAM_ALERT_CREDENTIAL_LAST_ALERT_DATE = "lastSendAlertDate";
@@ -188,86 +188,74 @@ public class CredentialDao extends BaseDao<DBCredential> {
}
}
+ /**
+ * Get users with credentials which are about to expire, and they were not yet notified in alertInterval period
+ * @param credentialType - the credential type to send alert
+ * @param beforeStartDays - days before password is expired and the alerting starts
+ * @param alertInterval - how many days must past since last alert before we can send next alert
+ * @param maxAlertsInBatch - max number of alerts we can process in on batch
+ * @return
+ */
+ public List<DBCredential> getCredentialsBeforeExpireForAlerts(CredentialType credentialType, int beforeStartDays, int alertInterval, int maxAlertsInBatch) {
- public List<DBUser> getBeforePasswordExpireUsersForAlerts(int beforeStartDays, int alertInterval, int maxAlertsInBatch) {
- OffsetDateTime expireDate = OffsetDateTime.now();
- OffsetDateTime startDateTime = expireDate.plusDays(beforeStartDays);
- OffsetDateTime lastSendAlertDate = expireDate.minusDays(alertInterval);
+ OffsetDateTime expireTestDate = OffsetDateTime.now();
+ OffsetDateTime startAlertSendDate = expireTestDate.plusDays(beforeStartDays);
+ OffsetDateTime lastSendAlertDate = expireTestDate.minusDays(alertInterval);
- TypedQuery<DBUser> query = memEManager.createNamedQuery("DBUser.getUsersForBeforePasswordExpireAlerts", DBUser.class);
- query.setParameter(QUERY_PARAM_ALERT_CREDENTIAL_START_DATE, startDateTime);
- query.setParameter(QUERY_PARAM_ALERT_CREDENTIAL_EXPIRE_DATE, expireDate);
+ TypedQuery<DBCredential> query = memEManager.createNamedQuery(QUERY_CREDENTIAL_BEFORE_EXPIRE, DBCredential.class);
+
+ query.setParameter(PARAM_CREDENTIAL_TYPE, credentialType );
+ query.setParameter(QUERY_PARAM_ALERT_CREDENTIAL_START_ALERT_SEND_DATE, startAlertSendDate);
+ query.setParameter(QUERY_PARAM_ALERT_CREDENTIAL_EXPIRE_TEST_DATE, expireTestDate);
query.setParameter(QUERY_PARAM_ALERT_CREDENTIAL_LAST_ALERT_DATE, lastSendAlertDate);
query.setMaxResults(maxAlertsInBatch);
return query.getResultList();
}
-
- public List<DBUser> getPasswordExpiredUsersForAlerts(int alertPeriodDays, int alertInterval, int maxAlertsInBatch) {
+ /**
+ * Get users with passwords which are about to expire, and they were not yet notified in alertInterval period
+ * @param credentialType - the credential type to send alert
+ * @param alertPeriodDays - days before password is expired and the alerting starts
+ * @param alertInterval - how many days must past since last alert before we can send next alert
+ * @param maxAlertsInBatch - max number of alerts we can process in on batch
+ * @return
+ */
+ public List<DBCredential> getUsersWithExpiredCredentialsForAlerts(CredentialType credentialType, int alertPeriodDays, int alertInterval, int maxAlertsInBatch) {
OffsetDateTime expireDate = OffsetDateTime.now();
- // the alert period must be less then expire day
+ // the alert period must be less than expire day
OffsetDateTime startDateTime = expireDate.minusDays(alertPeriodDays);
OffsetDateTime lastSendAlertDate = expireDate.minusDays(alertInterval);
- TypedQuery<DBUser> query = memEManager.createNamedQuery("DBUser.getUsersForPasswordExpiredAlerts", DBUser.class);
+ TypedQuery<DBCredential> query = memEManager.createNamedQuery(QUERY_CREDENTIAL_EXPIRED, DBCredential.class);
+ query.setParameter(PARAM_CREDENTIAL_TYPE, credentialType );
query.setParameter(QUERY_PARAM_ALERT_CREDENTIAL_END_DATE, startDateTime);
- query.setParameter(QUERY_PARAM_ALERT_CREDENTIAL_EXPIRE_DATE, expireDate);
+ query.setParameter(QUERY_PARAM_ALERT_CREDENTIAL_EXPIRE_TEST_DATE, expireDate);
query.setParameter(QUERY_PARAM_ALERT_CREDENTIAL_LAST_ALERT_DATE, lastSendAlertDate);
query.setMaxResults(maxAlertsInBatch);
return query.getResultList();
}
- public List<DBUser> getBeforeAccessTokenExpireUsersForAlerts(int beforeStartDays, int alertInterval, int maxAlertsInBatch) {
- OffsetDateTime expireDate = OffsetDateTime.now();
- OffsetDateTime startDateTime = expireDate.plusDays(beforeStartDays);
- OffsetDateTime lastSendAlertDate = expireDate.minusDays(alertInterval);
-
- TypedQuery<DBUser> query = memEManager.createNamedQuery("DBUser.getUsersForBeforeAccessTokenExpireAlerts", DBUser.class);
- query.setParameter(QUERY_PARAM_ALERT_CREDENTIAL_START_DATE, startDateTime);
- query.setParameter(QUERY_PARAM_ALERT_CREDENTIAL_EXPIRE_DATE, expireDate);
- query.setParameter(QUERY_PARAM_ALERT_CREDENTIAL_LAST_ALERT_DATE, lastSendAlertDate);
- query.setMaxResults(maxAlertsInBatch);
- return query.getResultList();
+ public List<DBCredential> getBeforePasswordExpireUsersForAlerts(int beforeStartDays, int alertInterval, int maxAlertsInBatch) {
+ return getCredentialsBeforeExpireForAlerts(CredentialType.USERNAME_PASSWORD, beforeStartDays, alertInterval, maxAlertsInBatch);
}
- public List<DBUser> getAccessTokenExpiredUsersForAlerts(int alertPeriodDays, int alertInterval, int maxAlertsInBatch) {
- OffsetDateTime expireDate = OffsetDateTime.now();
- // the alert period must be less then expire day
- OffsetDateTime startDateTime = expireDate.minusDays(alertPeriodDays);
- OffsetDateTime lastSendAlertDate = expireDate.minusDays(alertInterval);
-
- TypedQuery<DBUser> query = memEManager.createNamedQuery("DBUser.getUsersForAccessTokenExpiredAlerts", DBUser.class);
- query.setParameter(QUERY_PARAM_ALERT_CREDENTIAL_END_DATE, startDateTime);
- query.setParameter(QUERY_PARAM_ALERT_CREDENTIAL_EXPIRE_DATE, expireDate);
- query.setParameter(QUERY_PARAM_ALERT_CREDENTIAL_LAST_ALERT_DATE, lastSendAlertDate);
- query.setMaxResults(maxAlertsInBatch);
- return query.getResultList();
+ public List<DBCredential> getPasswordExpiredUsersForAlerts(int alertPeriodDays, int alertInterval, int maxAlertsInBatch) {
+ return getUsersWithExpiredCredentialsForAlerts(CredentialType.USERNAME_PASSWORD, alertPeriodDays, alertInterval, maxAlertsInBatch);
}
- public List<DBUser> getBeforeCertificateExpireUsersForAlerts(int beforeStartDays, int alertInterval, int maxAlertsInBatch) {
- OffsetDateTime expireDate = OffsetDateTime.now();
- OffsetDateTime startDateTime = expireDate.plusDays(beforeStartDays);
- OffsetDateTime lastSendAlertDate = expireDate.minusDays(alertInterval);
+ public List<DBCredential> getBeforeAccessTokenExpireUsersForAlerts(int beforeStartDays, int alertInterval, int maxAlertsInBatch) {
+ return getCredentialsBeforeExpireForAlerts(CredentialType.ACCESS_TOKEN, beforeStartDays, alertInterval, maxAlertsInBatch);
+ }
- TypedQuery<DBUser> query = memEManager.createNamedQuery("DBUser.getUsersForBeforeCertificateExpireAlerts", DBUser.class);
- query.setParameter(QUERY_PARAM_ALERT_CREDENTIAL_START_DATE, startDateTime);
- query.setParameter(QUERY_PARAM_ALERT_CREDENTIAL_EXPIRE_DATE, expireDate);
- query.setParameter(QUERY_PARAM_ALERT_CREDENTIAL_LAST_ALERT_DATE, lastSendAlertDate);
- query.setMaxResults(maxAlertsInBatch);
- return query.getResultList();
+ public List<DBCredential> getAccessTokenExpiredUsersForAlerts(int alertPeriodDays, int alertInterval, int maxAlertsInBatch) {
+ return getUsersWithExpiredCredentialsForAlerts(CredentialType.ACCESS_TOKEN, alertPeriodDays, alertInterval, maxAlertsInBatch);
}
- public List<DBUser> getCertificateExpiredUsersForAlerts(int alertPeriodDays, int alertInterval, int maxAlertsInBatch) {
- OffsetDateTime expireDate = OffsetDateTime.now();
- // the alert period must be less then expire day
- OffsetDateTime startDateTime = expireDate.minusDays(alertPeriodDays);
- OffsetDateTime lastSendAlertDate = expireDate.minusDays(alertInterval);
+ public List<DBCredential> getBeforeCertificateExpireUsersForAlerts(int beforeStartDays, int alertInterval, int maxAlertsInBatch) {
+ return getCredentialsBeforeExpireForAlerts(CredentialType.CERTIFICATE, beforeStartDays, alertInterval, maxAlertsInBatch);
+ }
- TypedQuery<DBUser> query = memEManager.createNamedQuery("DBUser.getUsersForCertificateExpiredAlerts", DBUser.class);
- query.setParameter(QUERY_PARAM_ALERT_CREDENTIAL_END_DATE, startDateTime);
- query.setParameter(QUERY_PARAM_ALERT_CREDENTIAL_EXPIRE_DATE, expireDate);
- query.setParameter(QUERY_PARAM_ALERT_CREDENTIAL_LAST_ALERT_DATE, lastSendAlertDate);
- query.setMaxResults(maxAlertsInBatch);
- return query.getResultList();
+ public List<DBCredential> getCertificateExpiredUsersForAlerts(int alertPeriodDays, int alertInterval, int maxAlertsInBatch) {
+ return getUsersWithExpiredCredentialsForAlerts(CredentialType.CERTIFICATE, alertPeriodDays, alertInterval, maxAlertsInBatch);
}
/**
@@ -316,25 +304,10 @@ public class CredentialDao extends BaseDao<DBCredential> {
}
@Transactional
- public void updateAlertSentForUserCredentials(Long userId, CredentialType credentialType, OffsetDateTime dateTime) {
- /*
- DBUser user = find(userId);
- switch (credentialType) {
- case USERNAME_PASSWORD:
- user.setPasswordExpireAlertOn(dateTime);
- break;
- case ACCESS_TOKEN:
- user.setAccessTokenExpireAlertOn(dateTime);
- break;
- case CERTIFICATE:
- /*if (user.getCertificate() == null) {
- LOG.warn("Can not set certificate alert sent date for user [{}] without certificate!", user.getUsername());
- } else {
- user.getCertificate().setCertificateLastExpireAlertOn(dateTime);
- }* /
- break;
- }
- */
+ public void updateAlertSentForUserCredentials(DBCredential credential, OffsetDateTime dateTime) {
+ // attach to jpa session of not already
+ DBCredential managedCredential = find(credential.getId());
+ managedCredential.setExpireAlertOn(dateTime);
}
diff --git a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/data/dao/QueryNames.java b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/data/dao/QueryNames.java
index bae9ceb41..10e4c77d6 100644
--- a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/data/dao/QueryNames.java
+++ b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/data/dao/QueryNames.java
@@ -120,6 +120,12 @@ public class QueryNames {
public static final String QUERY_USER_FILTER_COUNT = "DBUser.getUsersByFilterCount";
public static final String QUERY_USERS = "DBUser.getUsers";
public static final String QUERY_QUERY_USERS_FILTER = "DBUser.getUsersByFilter";
+ // ALERTS
+ public static final String QUERY_USER_BEFORE_PASSWORD_EXPIRE = "DBUser.getUsersForBeforePasswordExpireAlerts";
+ public static final String QUERY_USER_WITH_PASSWORD_EXPIRED = "DBUser.getUsersForPasswordExpiredAlerts";
+
+ public static final String QUERY_CREDENTIAL_BEFORE_EXPIRE = "DBCredential.getCredentialBeforeExpireAlerts";
+ public static final String QUERY_CREDENTIAL_EXPIRED = "DBCredential.getCredentiaExpiredAlerts";
public static final String PARAM_NAME = "name";
diff --git a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/data/dao/UserDao.java b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/data/dao/UserDao.java
index 8bb831c97..23615e6ed 100644
--- a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/data/dao/UserDao.java
+++ b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/data/dao/UserDao.java
@@ -16,6 +16,7 @@ package eu.europa.ec.edelivery.smp.data.dao;
import eu.europa.ec.edelivery.smp.data.enums.CredentialTargetType;
import eu.europa.ec.edelivery.smp.data.enums.CredentialType;
import eu.europa.ec.edelivery.smp.data.model.DBUserDeleteValidation;
+import eu.europa.ec.edelivery.smp.data.model.user.DBCredential;
import eu.europa.ec.edelivery.smp.data.model.user.DBUser;
import eu.europa.ec.edelivery.smp.exceptions.SMPRuntimeException;
import eu.europa.ec.edelivery.smp.logging.SMPLogger;
@@ -200,13 +201,14 @@ public class UserDao extends BaseDao<DBUser> {
throw new SMPRuntimeException(ILLEGAL_STATE_USERNAME_MULTIPLE_ENTRY, username);
}
}
-
+/*
public List<DBUser> getBeforePasswordExpireUsersForAlerts(int beforeStartDays, int alertInterval, int maxAlertsInBatch) {
OffsetDateTime expireDate = OffsetDateTime.now();
OffsetDateTime startDateTime = expireDate.plusDays(beforeStartDays);
OffsetDateTime lastSendAlertDate = expireDate.minusDays(alertInterval);
- TypedQuery<DBUser> query = memEManager.createNamedQuery("DBUser.getUsersForBeforePasswordExpireAlerts", DBUser.class);
+ TypedQuery<DBUser> query = memEManager.createNamedQuery(QUERY_USER_BEFORE_PASSWORD_EXPIRE, DBUser.class);
+ query.setParameter(PARAM_CREDENTIAL_TYPE, CredentialType.USERNAME_PASSWORD );
query.setParameter(QUERY_PARAM_ALERT_CREDENTIAL_START_DATE, startDateTime);
query.setParameter(QUERY_PARAM_ALERT_CREDENTIAL_EXPIRE_DATE, expireDate);
query.setParameter(QUERY_PARAM_ALERT_CREDENTIAL_LAST_ALERT_DATE, lastSendAlertDate);
@@ -220,7 +222,8 @@ public class UserDao extends BaseDao<DBUser> {
OffsetDateTime startDateTime = expireDate.minusDays(alertPeriodDays);
OffsetDateTime lastSendAlertDate = expireDate.minusDays(alertInterval);
- TypedQuery<DBUser> query = memEManager.createNamedQuery("DBUser.getUsersForPasswordExpiredAlerts", DBUser.class);
+ TypedQuery<DBUser> query = memEManager.createNamedQuery(QUERY_USER_WITH_PASSWORD_EXPIRED, DBUser.class);
+ query.setParameter(PARAM_CREDENTIAL_TYPE, CredentialType.USERNAME_PASSWORD );
query.setParameter(QUERY_PARAM_ALERT_CREDENTIAL_END_DATE, startDateTime);
query.setParameter(QUERY_PARAM_ALERT_CREDENTIAL_EXPIRE_DATE, expireDate);
query.setParameter(QUERY_PARAM_ALERT_CREDENTIAL_LAST_ALERT_DATE, lastSendAlertDate);
@@ -281,7 +284,7 @@ public class UserDao extends BaseDao<DBUser> {
query.setMaxResults(maxAlertsInBatch);
return query.getResultList();
}
-
+*/
/**
* Validation report for users which owns service group
*
@@ -295,28 +298,6 @@ public class UserDao extends BaseDao<DBUser> {
return query.getResultList();
}
- @Transactional
- public void updateAlertSentForUserCredentials(Long userId, CredentialType credentialType, OffsetDateTime dateTime) {
- DBUser user = find(userId);
- /*
- switch (credentialType) {
- case USERNAME_PASSWORD:
- user.setPasswordExpireAlertOn(dateTime);
- break;
- case ACCESS_TOKEN:
- user.setAccessTokenExpireAlertOn(dateTime);
- break;
- case CERTIFICATE:
- / *if (user.getCertificate() == null) {
- LOG.warn("Can not set certificate alert sent date for user [{}] without certificate!", user.getUsername());
- } else {
- user.getCertificate().setCertificateLastExpireAlertOn(dateTime);
- }* /
- break;
- }
- */
- }
-
public List<DBUser> getFilteredUserList(int iPage, int iPageSize, String filter) {
boolean hasFilter = StringUtils.isNotBlank(filter);
TypedQuery<DBUser> query = memEManager.createNamedQuery(hasFilter ?
diff --git a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/data/model/DBAlert.java b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/data/model/DBAlert.java
index 025572309..49370b4fc 100644
--- a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/data/model/DBAlert.java
+++ b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/data/model/DBAlert.java
@@ -12,7 +12,6 @@ import javax.validation.constraints.NotNull;
import java.time.OffsetDateTime;
import java.util.HashMap;
import java.util.Map;
-import java.util.Objects;
/**
* Database table containing update data
@@ -49,7 +48,7 @@ public class DBAlert extends BaseEntity {
@NotNull
private AlertStatusEnum alertStatus;
- @Column(name = "ALERT_STATUS_DESC", length = CommonColumnsLengths.MAX_MEDIUM_TEXT_LENGTH )
+ @Column(name = "ALERT_STATUS_DESC", length = CommonColumnsLengths.MAX_MEDIUM_TEXT_LENGTH)
private String alertStatusDesc;
@Column(name = "ALERT_LEVEL")
@@ -57,7 +56,7 @@ public class DBAlert extends BaseEntity {
@NotNull
private AlertLevelEnum alertLevel;
- @Column(name = "MAIL_SUBJECT",length = CommonColumnsLengths.MAX_MEDIUM_TEXT_LENGTH)
+ @Column(name = "MAIL_SUBJECT", length = CommonColumnsLengths.MAX_MEDIUM_TEXT_LENGTH)
private String mailSubject;
@Column(name = "MAIL_TO", length = CommonColumnsLengths.MAX_MEDIUM_TEXT_LENGTH)
private String mailTo;
diff --git a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/data/model/user/DBCredential.java b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/data/model/user/DBCredential.java
index 30adccf87..bcac19305 100644
--- a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/data/model/user/DBCredential.java
+++ b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/data/model/user/DBCredential.java
@@ -33,66 +33,32 @@ import static eu.europa.ec.edelivery.smp.data.dao.QueryNames.*;
@Index(name = "SMP_CRD_USER_NAME_TYPE_IDX", columnList = "CREDENTIAL_NAME, CREDENTIAL_TYPE, CREDENTIAL_TARGET", unique = true),
})
@org.hibernate.annotations.Table(appliesTo = "SMP_CREDENTIAL", comment = "Credentials for the users")
-@NamedQueries({
- @NamedQuery(name = QUERY_CREDENTIAL_ALL, query = "SELECT u FROM DBCredential u"),
- @NamedQuery(name = QUERY_CREDENTIALS_BY_CI_USERNAME_CREDENTIAL_TYPE_TARGET, query = "SELECT c FROM DBCredential c " +
- "WHERE upper(c.user.username) = upper(:username) and c.credentialType = :credential_type and c.credentialTarget = :credential_target"),
- @NamedQuery(name = QUERY_CREDENTIALS_BY_USERID_CREDENTIAL_TYPE_TARGET, query = "SELECT c FROM DBCredential c " +
- "WHERE c.user.id = :user_id and c.credentialType = :credential_type and c.credentialTarget = :credential_target order by c.id"),
-
-
- // case-insensitive search
- @NamedQuery(name = QUERY_CREDENTIAL_BY_CREDENTIAL_NAME_TYPE_TARGET, query = "SELECT c FROM DBCredential c " +
- "WHERE c.name = :credential_name and c.credentialType = :credential_type and c.credentialTarget = :credential_target"),
- @NamedQuery(name = QUERY_CREDENTIAL_BY_CERTIFICATE_ID, query = "SELECT u FROM DBCredential u WHERE u.certificate.certificateId = :certificate_identifier"),
- @NamedQuery(name = QUERY_CREDENTIAL_BY_CI_CERTIFICATE_ID, query = "SELECT u FROM DBCredential u WHERE upper(u.certificate.certificateId) = upper(:certificate_identifier)"),
-
- //@NamedQuery(name = "DBUser.getUserByPatId", query = "SELECT u FROM DBUser u WHERE u.accessTokenIdentifier = :patId"),
- //@NamedQuery(name = "DBUser.getUserByCertificateIdCaseInsensitive", query = "SELECT u FROM DBUser u WHERE upper(u.certificate.certificateId) = upper(:certificateId)"),
- /*@NamedQuery(name = "DBUser.getUsersForBeforePasswordExpireAlerts",
- query = "SELECT u FROM DBUser u WHERE u.passwordExpireOn IS NOT NULL" +
- " AND u.passwordExpireOn <= :startAlertDate " +
- " AND u.passwordExpireOn > :expireDate" +
- " AND (u.passwordExpireAlertOn IS NULL OR u.passwordExpireAlertOn < :lastSendAlertDate )"),
- @NamedQuery(name = "DBUser.getUsersForPasswordExpiredAlerts",
- query = "SELECT u FROM DBUser u WHERE u.passwordExpireOn IS NOT NULL" +
- " AND u.passwordExpireOn > :endAlertDate " +
- " AND u.passwordExpireOn <= :expireDate" +
- " AND (u.passwordExpireAlertOn IS NULL " +
- " OR u.passwordExpireAlertOn <= u.passwordExpireOn " +
- " OR u.passwordExpireAlertOn < :lastSendAlertDate )"),
-
- @NamedQuery(name = "DBUser.getUsersForBeforeAccessTokenExpireAlerts",
- query = "SELECT u FROM DBUser u WHERE u.accessTokenExpireOn IS NOT NULL" +
- " AND u.accessTokenExpireOn <= :startAlertDate " +
- " AND u.accessTokenExpireOn > :expireDate" +
- " AND (u.accessTokenExpireAlertOn IS NULL OR u.accessTokenExpireAlertOn < :lastSendAlertDate )"),
- @NamedQuery(name = "DBUser.getUsersForAccessTokenExpiredAlerts",
- query = "SELECT u FROM DBUser u WHERE u.accessTokenExpireOn IS NOT NULL" +
- " AND u.accessTokenExpireOn > :endAlertDate " +
- " AND u.accessTokenExpireOn <= :expireDate" +
- " AND (u.accessTokenExpireAlertOn IS NULL " +
- " OR u.accessTokenExpireAlertOn <= u.accessTokenExpireOn " +
- " OR u.accessTokenExpireAlertOn < :lastSendAlertDate )"),
-/*
- @NamedQuery(name = "DBUser.getUsersForBeforeCertificateExpireAlerts",
- query = "SELECT u FROM DBUser u WHERE u.certificate IS NOT NULL" +
- " AND u.certificate.validTo IS NOT NULL " +
- " AND u.certificate.validTo <= :startAlertDate " +
- " AND u.certificate.validTo > :expireDate" +
- " AND (u.certificate.certificateLastExpireAlertOn IS NULL " +
- " OR u.certificate.certificateLastExpireAlertOn < :lastSendAlertDate )"),
- @NamedQuery(name = "DBUser.getUsersForCertificateExpiredAlerts",
- query = "SELECT u FROM DBUser u WHERE u.certificate IS NOT NULL" +
- " AND u.certificate.validTo IS NOT NULL " +
- " AND u.certificate.validTo > :endAlertDate " +
- " AND u.certificate.validTo <= :expireDate" +
- " AND (u.certificate.certificateLastExpireAlertOn IS NULL " +
- " OR u.certificate.certificateLastExpireAlertOn <= u.certificate.validTo " +
- " OR u.certificate.certificateLastExpireAlertOn < :lastSendAlertDate )")
- */
+@NamedQuery(name = QUERY_CREDENTIAL_ALL, query = "SELECT u FROM DBCredential u")
+@NamedQuery(name = QUERY_CREDENTIALS_BY_CI_USERNAME_CREDENTIAL_TYPE_TARGET, query = "SELECT c FROM DBCredential c " +
+ "WHERE upper(c.user.username) = upper(:username) and c.credentialType = :credential_type and c.credentialTarget = :credential_target")
+@NamedQuery(name = QUERY_CREDENTIALS_BY_USERID_CREDENTIAL_TYPE_TARGET, query = "SELECT c FROM DBCredential c " +
+ "WHERE c.user.id = :user_id and c.credentialType = :credential_type and c.credentialTarget = :credential_target order by c.id")
+// case-insensitive search
+@NamedQuery(name = QUERY_CREDENTIAL_BY_CREDENTIAL_NAME_TYPE_TARGET, query = "SELECT c FROM DBCredential c " +
+ "WHERE c.name = :credential_name and c.credentialType = :credential_type and c.credentialTarget = :credential_target")
+@NamedQuery(name = QUERY_CREDENTIAL_BY_CERTIFICATE_ID, query = "SELECT u FROM DBCredential u WHERE u.certificate.certificateId = :certificate_identifier")
+@NamedQuery(name = QUERY_CREDENTIAL_BY_CI_CERTIFICATE_ID, query = "SELECT u FROM DBCredential u WHERE upper(u.certificate.certificateId) = upper(:certificate_identifier)")
+
+@NamedQuery(name = QUERY_CREDENTIAL_BEFORE_EXPIRE,
+ query = "SELECT distinct c FROM DBCredential c WHERE c.credentialType=:credential_type " +
+ " AND c.expireOn IS NOT NULL" +
+ " AND c.expireOn <= :start_alert_send_date " +
+ " AND c.expireOn > :expire_test_date" +
+ " AND (c.expireAlertOn IS NULL OR c.expireAlertOn < :lastSendAlertDate )")
+@NamedQuery(name = QUERY_CREDENTIAL_EXPIRED,
+ query = "SELECT distinct c FROM DBCredential c WHERE c.credentialType=:credential_type" +
+ " AND c.expireOn IS NOT NULL" +
+ " AND c.expireOn > :endAlertDate " +
+ " AND c.expireOn <= :expire_test_date" +
+ " AND (c.expireAlertOn IS NULL " +
+ " OR c.expireAlertOn <= c.expireOn " +
+ " OR c.expireAlertOn < :lastSendAlertDate )")
-})
@NamedNativeQueries({
@NamedNativeQuery(name = "DBCredentialDeleteValidation.validateUsersForOwnership",
diff --git a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/data/model/user/DBUser.java b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/data/model/user/DBUser.java
index 637a7581a..5d997c51b 100644
--- a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/data/model/user/DBUser.java
+++ b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/data/model/user/DBUser.java
@@ -58,50 +58,52 @@ import static eu.europa.ec.edelivery.smp.data.dao.QueryNames.*;
// @NamedQuery(name = "DBUser.getUserByCertificateId", query = "SELECT u FROM DBUser u WHERE u.certificate.certificateId = :certificateId"),
//@NamedQuery(name = "DBUser.getUserByPatId", query = "SELECT u FROM DBUser u WHERE u.accessTokenIdentifier = :patId"),
//@NamedQuery(name = "DBUser.getUserByCertificateIdCaseInsensitive", query = "SELECT u FROM DBUser u WHERE upper(u.certificate.certificateId) = upper(:certificateId)"),
- /*@NamedQuery(name = "DBUser.getUsersForBeforePasswordExpireAlerts",
- query = "SELECT u FROM DBUser u WHERE u.passwordExpireOn IS NOT NULL" +
- " AND u.passwordExpireOn <= :startAlertDate " +
- " AND u.passwordExpireOn > :expireDate" +
- " AND (u.passwordExpireAlertOn IS NULL OR u.passwordExpireAlertOn < :lastSendAlertDate )"),
- @NamedQuery(name = "DBUser.getUsersForPasswordExpiredAlerts",
- query = "SELECT u FROM DBUser u WHERE u.passwordExpireOn IS NOT NULL" +
- " AND u.passwordExpireOn > :endAlertDate " +
- " AND u.passwordExpireOn <= :expireDate" +
- " AND (u.passwordExpireAlertOn IS NULL " +
- " OR u.passwordExpireAlertOn <= u.passwordExpireOn " +
- " OR u.passwordExpireAlertOn < :lastSendAlertDate )"),
-
- @NamedQuery(name = "DBUser.getUsersForBeforeAccessTokenExpireAlerts",
- query = "SELECT u FROM DBUser u WHERE u.accessTokenExpireOn IS NOT NULL" +
- " AND u.accessTokenExpireOn <= :startAlertDate " +
- " AND u.accessTokenExpireOn > :expireDate" +
- " AND (u.accessTokenExpireAlertOn IS NULL OR u.accessTokenExpireAlertOn < :lastSendAlertDate )"),
- @NamedQuery(name = "DBUser.getUsersForAccessTokenExpiredAlerts",
- query = "SELECT u FROM DBUser u WHERE u.accessTokenExpireOn IS NOT NULL" +
- " AND u.accessTokenExpireOn > :endAlertDate " +
- " AND u.accessTokenExpireOn <= :expireDate" +
- " AND (u.accessTokenExpireAlertOn IS NULL " +
- " OR u.accessTokenExpireAlertOn <= u.accessTokenExpireOn " +
- " OR u.accessTokenExpireAlertOn < :lastSendAlertDate )"),
+@NamedQuery(name = QUERY_USER_BEFORE_PASSWORD_EXPIRE,
+ query = "SELECT distinct u FROM DBUser u JOIN DBCredential c ON u.id = c.user.id WHERE c.credentialType=:credential_type " +
+ " AND c.expireOn IS NOT NULL" +
+ " AND c.expireOn <= :start_alert_send_date " +
+ " AND c.expireOn > :expire_test_date" +
+ " AND (c.expireAlertOn IS NULL OR c.expireAlertOn < :lastSendAlertDate )")
+@NamedQuery(name = QUERY_USER_WITH_PASSWORD_EXPIRED,
+ query = "SELECT distinct u FROM DBUser u JOIN DBCredential c ON u.id = c.user.id WHERE c.credentialType=:credential_type" +
+ " AND c.expireOn IS NOT NULL" +
+ " AND c.expireOn > :endAlertDate " +
+ " AND c.expireOn <= :expire_test_date" +
+ " AND (c.expireAlertOn IS NULL " +
+ " OR c.expireAlertOn <= c.expireOn " +
+ " OR c.expireAlertOn < :lastSendAlertDate )")
/*
- @NamedQuery(name = "DBUser.getUsersForBeforeCertificateExpireAlerts",
- query = "SELECT u FROM DBUser u WHERE u.certificate IS NOT NULL" +
- " AND u.certificate.validTo IS NOT NULL " +
- " AND u.certificate.validTo <= :startAlertDate " +
- " AND u.certificate.validTo > :expireDate" +
- " AND (u.certificate.certificateLastExpireAlertOn IS NULL " +
- " OR u.certificate.certificateLastExpireAlertOn < :lastSendAlertDate )"),
- @NamedQuery(name = "DBUser.getUsersForCertificateExpiredAlerts",
- query = "SELECT u FROM DBUser u WHERE u.certificate IS NOT NULL" +
- " AND u.certificate.validTo IS NOT NULL " +
- " AND u.certificate.validTo > :endAlertDate " +
- " AND u.certificate.validTo <= :expireDate" +
- " AND (u.certificate.certificateLastExpireAlertOn IS NULL " +
- " OR u.certificate.certificateLastExpireAlertOn <= u.certificate.validTo " +
-
- " OR u.certificate.certificateLastExpireAlertOn < :lastSendAlertDate )")
- })
- */
+@NamedQuery(name = "DBUser.getUsersForBeforeAccessTokenExpireAlerts",
+ query = "SELECT u FROM DBUser u WHERE u.accessTokenExpireOn IS NOT NULL" +
+ " AND u.accessTokenExpireOn <= :startAlertDate " +
+ " AND u.accessTokenExpireOn > :expire_test_date" +
+ " AND (u.accessTokenExpireAlertOn IS NULL OR u.accessTokenExpireAlertOn < :lastSendAlertDate )"),
+@NamedQuery(name = "DBUser.getUsersForAccessTokenExpiredAlerts",
+ query = "SELECT u FROM DBUser u WHERE u.accessTokenExpireOn IS NOT NULL" +
+ " AND u.accessTokenExpireOn > :endAlertDate " +
+ " AND u.accessTokenExpireOn <= :expire_test_date" +
+ " AND (u.accessTokenExpireAlertOn IS NULL " +
+ " OR u.accessTokenExpireAlertOn <= u.accessTokenExpireOn " +
+ " OR u.accessTokenExpireAlertOn < :lastSendAlertDate )"),
+/*
+@NamedQuery(name = "DBUser.getUsersForBeforeCertificateExpireAlerts",
+ query = "SELECT u FROM DBUser u WHERE u.certificate IS NOT NULL" +
+ " AND u.certificate.validTo IS NOT NULL " +
+ " AND u.certificate.validTo <= :startAlertDate " +
+ " AND u.certificate.validTo > :expire_test_date" +
+ " AND (u.certificate.certificateLastExpireAlertOn IS NULL " +
+ " OR u.certificate.certificateLastExpireAlertOn < :lastSendAlertDate )"),
+@NamedQuery(name = "DBUser.getUsersForCertificateExpiredAlerts",
+ query = "SELECT u FROM DBUser u WHERE u.certificate IS NOT NULL" +
+ " AND u.certificate.validTo IS NOT NULL " +
+ " AND u.certificate.validTo > :endAlertDate " +
+ " AND u.certificate.validTo <= :expire_test_date" +
+ " AND (u.certificate.certificateLastExpireAlertOn IS NULL " +
+ " OR u.certificate.certificateLastExpireAlertOn <= u.certificate.validTo " +
+
+ " OR u.certificate.certificateLastExpireAlertOn < :lastSendAlertDate )")
+ })
+ */
@NamedNativeQuery(name = "DBUserDeleteValidation.validateUsersForOwnership",
resultSetMapping = "DBUserDeleteValidationMapping",
query = "SELECT S.ID as ID, S.USERNAME as USERNAME, " +
diff --git a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/CredentialService.java b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/CredentialService.java
index 72499e711..12615fb9b 100644
--- a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/CredentialService.java
+++ b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/CredentialService.java
@@ -109,7 +109,7 @@ public class CredentialService {
userDetails);
try {
if (!BCrypt.checkpw(userCredentialToken, credential.getValue())) {
- LOG.securityWarn(SMPMessageCode.SEC_INVALID_USER_CREDENTIALS, username);
+ LOG.securityWarn(SMPMessageCode.SEC_INVALID_USER_CREDENTIALS, username, credential.getName(), credential.getCredentialType(), credential.getCredentialTarget());
loginAttemptFailedAndThrowError(credential, true, startTime);
}
credential.setSequentialLoginFailureCount(0);
@@ -335,7 +335,8 @@ public class CredentialService {
mCredentialDao.update(credential);
String username = credential.getUser().getUsername();
LOG.securityWarn(SMPMessageCode.SEC_INVALID_USER_CREDENTIALS, username,
- credential.getName(), credential.getCredentialType(),
+ credential.getName(),
+ credential.getCredentialType(),
credential.getCredentialTarget());
boolean isUserSuspended = credential.getSequentialLoginFailureCount() >= getLoginMaxAttempts(credentialType);
@@ -344,11 +345,11 @@ public class CredentialService {
// at notYetSuspended alert is sent for all settings AT_LOGON, WHEN_BLOCKED
if (notYetSuspended ||
getAlertBeforeUserSuspendedAlertMoment() == AlertSuspensionMomentEnum.AT_LOGON) {
- alertService.alertCredentialsSuspended(credential.getUser(), credential.getCredentialType());
+ alertService.alertCredentialsSuspended(credential);
}
} else {
// always invoke the method. The method handles the smp.alert.user.login_failure.enabled
- alertService.alertCredentialVerificationFailed(credential.getUser(), credential.getCredentialType());
+ alertService.alertCredentialVerificationFailed(credential);
}
delayResponse(credentialType, startTime);
if (isUserSuspended) {
diff --git a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/CredentialValidatorService.java b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/CredentialValidatorService.java
index 172a2f8d5..cc885de2e 100644
--- a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/CredentialValidatorService.java
+++ b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/CredentialValidatorService.java
@@ -1,7 +1,7 @@
package eu.europa.ec.edelivery.smp.services;
-import eu.europa.ec.edelivery.smp.data.dao.UserDao;
-import eu.europa.ec.edelivery.smp.data.model.user.DBUser;
+import eu.europa.ec.edelivery.smp.data.dao.CredentialDao;
+import eu.europa.ec.edelivery.smp.data.model.user.DBCredential;
import eu.europa.ec.edelivery.smp.logging.SMPLogger;
import eu.europa.ec.edelivery.smp.logging.SMPLoggerFactory;
import eu.europa.ec.edelivery.smp.utils.HttpUtils;
@@ -23,14 +23,14 @@ public class CredentialValidatorService {
private final CredentialsAlertService alertService;
private final ConfigurationService configurationService;
- private final UserDao userDao;
+ private final CredentialDao credentialDao;
public CredentialValidatorService(ConfigurationService configurationService,
CredentialsAlertService alertService,
- UserDao userDao) {
+ CredentialDao credentialDao) {
this.configurationService = configurationService;
this.alertService = alertService;
- this.userDao = userDao;
+ this.credentialDao = credentialDao;
}
/**
@@ -59,11 +59,12 @@ public class CredentialValidatorService {
LOG.debug("Before expire user password validation is disabled");
return;
}
- List<DBUser> dbUserBeforeExpireList = userDao.getBeforePasswordExpireUsersForAlerts(
+ List<DBCredential> dbUserBeforeExpireList = credentialDao.getBeforePasswordExpireUsersForAlerts(
configurationService.getAlertBeforeExpirePasswordPeriod(),
configurationService.getAlertBeforeExpirePasswordInterval(),
configurationService.getAlertCredentialsBatchSize());
- dbUserBeforeExpireList.forEach(alertService::alertBeforeUsernamePasswordExpire);
+
+ dbUserBeforeExpireList.forEach(alertService::alertBeforeCredentialExpire);
}
protected void validateCredentialsForExpiredUsernames() {
@@ -72,11 +73,11 @@ public class CredentialValidatorService {
LOG.debug("Expire user password validation is disabled");
return;
}
- List<DBUser> dbUserExpiredList = userDao.getPasswordExpiredUsersForAlerts(
+ List<DBCredential> dbUserExpiredList = credentialDao.getPasswordExpiredUsersForAlerts(
configurationService.getAlertExpiredPasswordPeriod(),
configurationService.getAlertExpiredPasswordInterval(),
configurationService.getAlertCredentialsBatchSize());
- dbUserExpiredList.forEach(alertService::alertUsernamePasswordExpired);
+ dbUserExpiredList.forEach(alertService::alertCredentialExpired);
}
protected void validateCredentialsForBeforeExpireAccessToken() {
@@ -86,11 +87,11 @@ public class CredentialValidatorService {
LOG.debug("Before expire user AccessToken validation is disabled");
return;
}
- List<DBUser> dbUserBeforeExpireList = userDao.getBeforeAccessTokenExpireUsersForAlerts(
+ List<DBCredential> dbUserBeforeExpireList = credentialDao.getBeforeAccessTokenExpireUsersForAlerts(
configurationService.getAlertBeforeExpireAccessTokenPeriod(),
configurationService.getAlertBeforeExpireAccessTokenInterval(),
configurationService.getAlertCredentialsBatchSize());
- dbUserBeforeExpireList.forEach(alertService::alertBeforeAccessTokenExpire);
+ dbUserBeforeExpireList.forEach(alertService::alertBeforeCredentialExpire);
}
protected void validateCredentialsForExpiredAccessToken() {
@@ -99,11 +100,11 @@ public class CredentialValidatorService {
LOG.debug("Expire user AccessToken validation is disabled");
return;
}
- List<DBUser> dbUserExpiredList = userDao.getAccessTokenExpiredUsersForAlerts(
+ List<DBCredential> dbUserExpiredList = credentialDao.getAccessTokenExpiredUsersForAlerts(
configurationService.getAlertExpiredAccessTokenPeriod(),
configurationService.getAlertExpiredAccessTokenInterval(),
configurationService.getAlertCredentialsBatchSize());
- dbUserExpiredList.forEach(alertService::alertAccessTokenExpired);
+ dbUserExpiredList.forEach(alertService::alertCredentialExpired);
}
@@ -114,11 +115,11 @@ public class CredentialValidatorService {
LOG.debug("Before expire user Certificate validation is disabled");
return;
}
- List<DBUser> dbUserBeforeExpireList = userDao.getBeforeCertificateExpireUsersForAlerts(
+ List<DBCredential> dbUserBeforeExpireList = credentialDao.getBeforeCertificateExpireUsersForAlerts(
configurationService.getAlertBeforeExpireCertificatePeriod(),
configurationService.getAlertBeforeExpireCertificateInterval(),
configurationService.getAlertCredentialsBatchSize());
- dbUserBeforeExpireList.forEach(alertService::alertBeforeCertificateExpire);
+ dbUserBeforeExpireList.forEach(alertService::alertBeforeCredentialExpire);
}
protected void validateCredentialsForExpiredCertificate() {
@@ -127,11 +128,11 @@ public class CredentialValidatorService {
LOG.debug("Expire user Certificate validation is disabled");
return;
}
- List<DBUser> dbUserExpiredList = userDao.getCertificateExpiredUsersForAlerts(
+ List<DBCredential> dbUserExpiredList = credentialDao.getCertificateExpiredUsersForAlerts(
configurationService.getAlertExpiredCertificatePeriod(),
configurationService.getAlertExpiredCertificateInterval(),
configurationService.getAlertCredentialsBatchSize());
- dbUserExpiredList.forEach(alertService::alertCertificateExpired);
+ dbUserExpiredList.forEach(alertService::alertCredentialExpired);
}
/**
diff --git a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/CredentialsAlertService.java b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/CredentialsAlertService.java
index e09b336ca..f35f4dc6f 100644
--- a/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/CredentialsAlertService.java
+++ b/smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/CredentialsAlertService.java
@@ -2,9 +2,11 @@ package eu.europa.ec.edelivery.smp.services;
import eu.europa.ec.edelivery.smp.cron.SMPDynamicCronTrigger;
import eu.europa.ec.edelivery.smp.data.dao.AlertDao;
+import eu.europa.ec.edelivery.smp.data.dao.CredentialDao;
import eu.europa.ec.edelivery.smp.data.dao.UserDao;
import eu.europa.ec.edelivery.smp.data.enums.CredentialType;
import eu.europa.ec.edelivery.smp.data.model.DBAlert;
+import eu.europa.ec.edelivery.smp.data.model.user.DBCredential;
import eu.europa.ec.edelivery.smp.data.model.user.DBUser;
import eu.europa.ec.edelivery.smp.data.ui.enums.AlertLevelEnum;
import eu.europa.ec.edelivery.smp.data.ui.enums.AlertStatusEnum;
@@ -42,159 +44,109 @@ public class CredentialsAlertService {
final MailService mailService;
final ConfigurationService configurationService;
final UserDao userDao;
+ final CredentialDao credentialDao;
final SMPDynamicCronTrigger alertCronTrigger;
public CredentialsAlertService(AlertDao alertDao,
MailService mailService,
ConfigurationService configurationService,
UserDao userDao,
+ CredentialDao credentialDao,
@Qualifier(TRIGGER_BEAN_CREDENTIAL_ALERTS) SMPDynamicCronTrigger alertCronTrigger) {
this.alertDao = alertDao;
this.mailService = mailService;
this.configurationService = configurationService;
this.userDao = userDao;
+ this.credentialDao = credentialDao;
this.alertCronTrigger = alertCronTrigger;
}
- public void alertBeforeUsernamePasswordExpire(DBUser user) {
- /*
- LOG.info("Alert username [{}] is about to expire on [{}]", user.getUsername(),
- ISO_LOCAL_DATE_TIME.format(user.getPasswordExpireOn()));
-
- String mailTo = user.getEmailAddress();
- CredentialTypeEnum credentialType = CredentialTypeEnum.USERNAME_PASSWORD;
- String credentialId = user.getUsername();
- OffsetDateTime expiredOn = user.getPasswordExpireOn();
- // alert specific properties
- String mailSubject = configurationService.getAlertBeforeExpirePasswordMailSubject();
- AlertLevelEnum alertLevel = configurationService.getAlertBeforeExpirePasswordLevel();
- AlertTypeEnum alertType = AlertTypeEnum.CREDENTIAL_IMMINENT_EXPIRATION;
-
- DBAlert alert = createAlert(user.getUsername(), mailSubject, mailTo, alertLevel, alertType);
-
- alertCredentialExpiration(user, alert, credentialType, credentialId, expiredOn);
-
- */
- }
-
- public void alertUsernamePasswordExpired(DBUser user) {
- /*
- LOG.info("Alert username [{}] expired on [{}]", user.getUsername(),
- ISO_LOCAL_DATE_TIME.format(user.getPasswordExpireOn()));
-
- String mailTo = user.getEmailAddress();
- CredentialTypeEnum credentialType = CredentialTypeEnum.USERNAME_PASSWORD;
- String credentialId = user.getUsername();
- OffsetDateTime expiredOn = user.getPasswordExpireOn();
-
- // alert specific properties
- String mailSubject = configurationService.getAlertExpiredPasswordMailSubject();
- AlertLevelEnum alertLevel = configurationService.getAlertExpiredPasswordLevel();
- AlertTypeEnum alertType = AlertTypeEnum.CREDENTIAL_EXPIRED;
-
- DBAlert alert = createAlert(user.getUsername(), mailSubject, mailTo, alertLevel, alertType);
-
- alertCredentialExpiration(user, alert, credentialType, credentialId, expiredOn);
-
- */
- }
-
- public void alertBeforeAccessTokenExpire(DBUser user) {
- /*
- LOG.info("Alert access token [{}] for user [{}] is about to expire on [{}]",
- user.getAccessToken(),
+ public void alertBeforeCredentialExpire(DBCredential userCredential) {
+ DBUser user = userCredential.getUser();
+ LOG.info("Alert for credentials type name [{}:{}] for user [{}] is about to expire on [{}]",
+ userCredential.getCredentialType(),
+ userCredential.getName(),
user.getUsername(),
- ISO_LOCAL_DATE_TIME.format(user.getAccessTokenExpireOn()));
+ ISO_LOCAL_DATE_TIME.format(userCredential.getExpireOn()));
String mailTo = user.getEmailAddress();
- CredentialTypeEnum credentialType = CredentialTypeEnum.ACCESS_TOKEN;
- String credentialId = user.getAccessTokenIdentifier();
- OffsetDateTime expiredOn = user.getAccessTokenExpireOn();
+ CredentialType credentialType = userCredential.getCredentialType();
+ String credentialId = userCredential.getName();
+ OffsetDateTime expiredOn = userCredential.getExpireOn();
// alert specific properties
- String mailSubject = configurationService.getAlertBeforeExpireAccessTokenMailSubject();
- AlertLevelEnum alertLevel = configurationService.getAlertBeforeExpireAccessTokenLevel();
+ String mailSubject;
+ AlertLevelEnum alertLevel;
+ if (credentialType == CredentialType.ACCESS_TOKEN) {
+ mailSubject = configurationService.getAlertBeforeExpireAccessTokenMailSubject();
+ alertLevel = configurationService.getAlertBeforeExpireAccessTokenLevel();
+ } else if (credentialType == CredentialType.USERNAME_PASSWORD) {
+ mailSubject = configurationService.getAlertBeforeExpirePasswordMailSubject();
+ alertLevel = configurationService.getAlertBeforeExpirePasswordLevel();
+ } else if (credentialType == CredentialType.CERTIFICATE) {
+ mailSubject = configurationService.getAlertBeforeExpireCertificateMailSubject();
+ alertLevel = configurationService.getAlertBeforeExpireCertificateLevel();
+ } else {
+ LOG.warn("Alert service for credential type [{}] is not supported! Skip alerts", credentialType);
+ return;
+ }
+
AlertTypeEnum alertType = AlertTypeEnum.CREDENTIAL_IMMINENT_EXPIRATION;
DBAlert alert = createAlert(user.getUsername(), mailSubject, mailTo, alertLevel, alertType);
- alertCredentialExpiration(user, alert, credentialType, credentialId, expiredOn);
-
- */
+ alertCredentialExpiration(userCredential, alert, credentialType, credentialId, expiredOn);
}
- public void alertAccessTokenExpired(DBUser user) {
- /*
- LOG.info("Alert access token [{}] for user [{}] expired on [{}]",
- user.getAccessToken(),
+ public void alertCredentialExpired(DBCredential userCredential) {
+ DBUser user = userCredential.getUser();
+ LOG.info("Alert access token [{}:{}] for user [{}] expired on [{}]",
+ userCredential.getCredentialType(),
+ userCredential.getName(),
user.getUsername(),
- ISO_LOCAL_DATE_TIME.format(user.getAccessTokenExpireOn()));
-
- String mailTo = user.getEmailAddress();
- CredentialTypeEnum credentialType = CredentialTypeEnum.ACCESS_TOKEN;
- String credentialId = user.getAccessTokenIdentifier();
- OffsetDateTime expiredOn = user.getAccessTokenExpireOn();
-
- // alert specific properties
- String mailSubject = configurationService.getAlertExpiredAccessTokenMailSubject();
- AlertLevelEnum alertLevel = configurationService.getAlertExpiredAccessTokenLevel();
- AlertTypeEnum alertType = AlertTypeEnum.CREDENTIAL_EXPIRED;
-
- DBAlert alert = createAlert(user.getUsername(), mailSubject, mailTo, alertLevel, alertType);
- alertCredentialExpiration(user, alert, credentialType, credentialId, expiredOn);
-
- */
- }
-
-
- public void alertBeforeCertificateExpire(DBUser user) {
- /*
- LOG.info("Alert Certificate [{}] for user [{}] is about to expire",
- user.getCertificate().getCertificateId(),
- user.getUsername());
+ ISO_LOCAL_DATE_TIME.format(userCredential.getExpireOn()));
String mailTo = user.getEmailAddress();
- CredentialTypeEnum credentialType = CredentialTypeEnum.CERTIFICATE;
- String credentialId = user.getCertificate().getCertificateId();
- OffsetDateTime expiredOn = user.getCertificate().getValidTo();
+ CredentialType credentialType = userCredential.getCredentialType();
+ String credentialId = userCredential.getName();
+ OffsetDateTime expiredOn = userCredential.getExpireOn();
// alert specific properties
- String mailSubject = configurationService.getAlertBeforeExpireCertificateMailSubject();
- AlertLevelEnum alertLevel = configurationService.getAlertBeforeExpireCertificateLevel();
- AlertTypeEnum alertType = AlertTypeEnum.CREDENTIAL_IMMINENT_EXPIRATION;
-
- DBAlert alert = createAlert(user.getUsername(), mailSubject, mailTo, alertLevel, alertType);
- alertCredentialExpiration(user, alert, credentialType, credentialId, expiredOn);
-
- */
- }
-
- public void alertCertificateExpired(DBUser user) {
- /*
- LOG.info("Alert Certificate [{}] for user [{}] expired",
- user.getCertificate().getCertificateId(),
- user.getUsername());
+ String mailSubject;
+ AlertLevelEnum alertLevel;
+
+ if (credentialType == CredentialType.ACCESS_TOKEN) {
+ mailSubject = configurationService.getAlertExpiredAccessTokenMailSubject();
+ alertLevel = configurationService.getAlertExpiredAccessTokenLevel();
+ } else if (credentialType == CredentialType.USERNAME_PASSWORD) {
+ mailSubject = configurationService.getAlertExpiredPasswordMailSubject();
+ alertLevel = configurationService.getAlertExpiredPasswordLevel();
+ } else if (credentialType == CredentialType.CERTIFICATE) {
+ mailSubject = configurationService.getAlertExpiredCertificateMailSubject();
+ alertLevel = configurationService.getAlertExpiredCertificateLevel();
+ } else {
+ LOG.warn("Alert service for credential type [{}] is not supported! Skip alerts", credentialType);
+ return;
+ }
- String mailTo = user.getEmailAddress();
- CredentialTypeEnum credentialType = CredentialTypeEnum.CERTIFICATE;
- String credentialId = user.getCertificate().getCertificateId();
- OffsetDateTime expiredOn = user.getCertificate().getValidTo();
- // alert specific properties
- String mailSubject = configurationService.getAlertExpiredCertificateMailSubject();
- AlertLevelEnum alertLevel = configurationService.getAlertExpiredCertificateLevel();
AlertTypeEnum alertType = AlertTypeEnum.CREDENTIAL_EXPIRED;
-
DBAlert alert = createAlert(user.getUsername(), mailSubject, mailTo, alertLevel, alertType);
- alertCredentialExpiration(user, alert, credentialType, credentialId, expiredOn);
+ alertCredentialExpiration(userCredential, alert, credentialType, credentialId, expiredOn);
+
- */
}
- public void alertCredentialVerificationFailed(DBUser user, CredentialType credentialType) {
- /*
+ public void alertCredentialVerificationFailed(DBCredential credential) {
+ LOG.info("Alert on Login failure [{}]!", credential);
Boolean loginFailureEnabled = configurationService.getAlertUserLoginFailureEnabled();
if (!loginFailureEnabled) {
- LOG.debug("Alert Login failure is disabled!");
+ LOG.warn("Alert Login failure is disabled!");
+ return;
+ }
+ DBUser user = credential.getUser();
+ CredentialType credentialType = credential.getCredentialType();
+ if (credentialType != CredentialType.ACCESS_TOKEN && credentialType != CredentialType.USERNAME_PASSWORD) {
+ LOG.error("Alert for suspended credentials type [{}] is not supported", credentialType);
return;
}
@@ -203,35 +155,29 @@ public class CredentialsAlertService {
AlertLevelEnum alertLevel = configurationService.getAlertUserLoginFailureLevel();
AlertTypeEnum alertType = AlertTypeEnum.CREDENTIAL_VERIFICATION_FAILED;
- Integer failureCount;
- OffsetDateTime lastFailedLoginDate;
- String credentialId;
-
- if (credentialType == CredentialTypeEnum.ACCESS_TOKEN) {
- failureCount = user.getSequentialTokenLoginFailureCount();
- lastFailedLoginDate = user.getLastTokenFailedLoginAttempt();
- credentialId = user.getAccessTokenIdentifier();
- } else if (credentialType == CredentialTypeEnum.USERNAME_PASSWORD) {
- failureCount = user.getSequentialLoginFailureCount();
- lastFailedLoginDate = user.getLastFailedLoginAttempt();
- credentialId = user.getUsername();
- } else {
- LOG.error("Alert for suspended credentials type [{}] is not supported", credentialType);
- return;
- }
+ Integer failureCount = credential.getSequentialLoginFailureCount();
+ OffsetDateTime lastFailedLoginDate = credential.getLastFailedLoginAttempt();
+ String credentialId = credential.getName();
+
DBAlert alert = createAlert(user.getUsername(), mailSubject, mailTo, alertLevel, alertType);
alertCredentialVerificationFailed(user, alert,
credentialType, credentialId,
failureCount, lastFailedLoginDate);
- */
+
}
- public void alertCredentialsSuspended(DBUser user, CredentialType credentialType) {
- /*
+ public void alertCredentialsSuspended(DBCredential credential) {
+
Boolean suspensionAlertEnabled = configurationService.getAlertUserSuspendedEnabled();
if (!suspensionAlertEnabled) {
- LOG.debug("Alert suspended is disabled!");
+ LOG.info("Alert suspended is disabled!");
+ return;
+ }
+ DBUser user = credential.getUser();
+ CredentialType credentialType = credential.getCredentialType();
+ if (credentialType != CredentialType.ACCESS_TOKEN && credentialType != CredentialType.USERNAME_PASSWORD) {
+ LOG.error("Alert for suspended credentials type [{}] is not supported", credentialType);
return;
}
@@ -240,32 +186,25 @@ public class CredentialsAlertService {
AlertLevelEnum alertLevel = configurationService.getAlertUserSuspendedLevel();
AlertTypeEnum alertType = AlertTypeEnum.CREDENTIAL_SUSPENDED;
- Integer failureCount;
- OffsetDateTime lastFailedLoginDate;
- OffsetDateTime suspendedUtil;
- String credentialId;
- if (credentialType == CredentialTypeEnum.ACCESS_TOKEN) {
- failureCount = user.getSequentialTokenLoginFailureCount();
- lastFailedLoginDate = user.getLastTokenFailedLoginAttempt();
+ Integer failureCount = credential.getSequentialLoginFailureCount();
+ OffsetDateTime lastFailedLoginDate = credential.getLastFailedLoginAttempt();
+ OffsetDateTime suspendedUtil = lastFailedLoginDate.plusSeconds(configurationService.getAccessTokenLoginSuspensionTimeInSeconds());
+ String credentialId = credential.getName();
+
+
+ if (credentialType == CredentialType.ACCESS_TOKEN) {
suspendedUtil = lastFailedLoginDate.plusSeconds(configurationService.getAccessTokenLoginSuspensionTimeInSeconds());
- credentialId = user.getAccessTokenIdentifier();
- } else if (credentialType == CredentialTypeEnum.USERNAME_PASSWORD) {
- failureCount = user.getSequentialLoginFailureCount();
- lastFailedLoginDate = user.getLastFailedLoginAttempt();
+ } else if (credentialType == CredentialType.USERNAME_PASSWORD) {
suspendedUtil = lastFailedLoginDate.plusSeconds(configurationService.getLoginSuspensionTimeInSeconds());
- credentialId = user.getUsername();
- } else {
- LOG.error("Alert for suspended credentials type [{}] is not supported", credentialType);
- return;
}
DBAlert alert = createAlert(user.getUsername(), mailSubject, mailTo, alertLevel, alertType);
alertCredentialSuspended(user, alert,
credentialType, credentialId,
- failureCount, lastFailedLoginDate, suspendedUtil);*/
+ failureCount, lastFailedLoginDate, suspendedUtil);
}
- public void alertCredentialExpiration(DBUser user,
+ public void alertCredentialExpiration(DBCredential credential,
DBAlert alert,
CredentialType credentialType,
String credentialId,
@@ -285,7 +224,7 @@ public class CredentialsAlertService {
submitAlertMail(alert);
// when alert about to expire - check if the next cron execution is expired
// and set date sent tp null to ensure alert submission in next cron execution
- userDao.updateAlertSentForUserCredentials(user.getId(), credentialType,
+ credentialDao.updateAlertSentForUserCredentials(credential,
alert.getAlertType() == AlertTypeEnum.CREDENTIAL_IMMINENT_EXPIRATION
&& isNextExecutionExpired(expirationDate) ?
null : OffsetDateTime.now());
@@ -298,6 +237,7 @@ public class CredentialsAlertService {
Integer failedLoginCount,
OffsetDateTime lastFailedLoginDate
) {
+ LOG.info("Prepare alert for credentials [{}] ", credentialId );
String serverName = HttpUtils.getServerAddress();
// add alert properties
alert.addProperty(CredentialVerificationFailedProperties.CREDENTIAL_TYPE.name(), credentialType.name());
diff --git a/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/data/dao/CredentialDaoAlertsTest.java b/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/data/dao/CredentialDaoAlertsTest.java
new file mode 100644
index 000000000..40d09d912
--- /dev/null
+++ b/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/data/dao/CredentialDaoAlertsTest.java
@@ -0,0 +1,213 @@
+package eu.europa.ec.edelivery.smp.data.dao;
+
+import eu.europa.ec.edelivery.smp.data.model.user.DBCredential;
+import eu.europa.ec.edelivery.smp.data.model.user.DBUser;
+import eu.europa.ec.edelivery.smp.testutil.TestDBUtils;
+import org.junit.Before;
+import org.junit.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+
+import java.time.OffsetDateTime;
+import java.util.List;
+import java.util.UUID;
+import java.util.stream.Collectors;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+public class CredentialDaoAlertsTest extends AbstractBaseDao {
+
+ DBUser okUser = TestDBUtils.createDBUserByUsername("okUser-" + UUID.randomUUID());
+ DBUser beforePasswordExpireNoAlertSend = TestDBUtils.createDBUserByUsername("beforePasswordExpireNoAlertSend-" + UUID.randomUUID());
+ DBUser beforePasswordExpireRecentAlertSend = TestDBUtils.createDBUserByUsername("beforePasswordExpireRecentAlertSend-" + UUID.randomUUID());
+ DBUser beforePasswordExpireAlertSend = TestDBUtils.createDBUserByUsername("beforePasswordExpireAlertSend-" + UUID.randomUUID());
+ // set expired test cases
+ DBUser passwordExpiredNoAlertSend = TestDBUtils.createDBUserByUsername("passwordExpiredNoAlertSend-" + UUID.randomUUID());
+ DBUser passwordExpiredRecentAlertSend = TestDBUtils.createDBUserByUsername("passwordExpiredRecentAlertSend-" + UUID.randomUUID());
+ DBUser passwordExpiredAlertSend = TestDBUtils.createDBUserByUsername("passwordExpiredAlertSend-" + UUID.randomUUID());
+ // ------------
+ // access token users setup
+ DBUser beforeATExpireNoAlertSend = TestDBUtils.createDBUserByUsername("beforeATExpireNoAlertSend-" + UUID.randomUUID());
+ DBUser beforeATExpireRecentAlertSend = TestDBUtils.createDBUserByUsername("beforeATExpireRecentAlertSend-" + UUID.randomUUID());
+ DBUser beforeATExpireAlertSend = TestDBUtils.createDBUserByUsername("beforeATExpireAlertSend-" + UUID.randomUUID());
+ // set expired test cases
+ DBUser aTExpiredNoAlertSend = TestDBUtils.createDBUserByUsername("ATExpiredNoAlertSend-" + UUID.randomUUID());
+ DBUser aTExpiredRecentAlertSend = TestDBUtils.createDBUserByUsername("ATExpiredRecentAlertSend-" + UUID.randomUUID());
+ DBUser aTExpiredAlertSend = TestDBUtils.createDBUserByUsername("ATExpiredAlertSend-" + UUID.randomUUID());
+
+ // ------------
+ // access token users setup
+ DBUser beforeCertExpireNoAlertSend = TestDBUtils.createDBUserByCertificate("beforecertxpireNoAlertSend-" + UUID.randomUUID());
+ DBUser beforeCertExpireRecentAlertSend = TestDBUtils.createDBUserByCertificate("beforeATExpireRecentAlertSend-" + UUID.randomUUID());
+ DBUser beforeCertExpireAlertSend = TestDBUtils.createDBUserByCertificate("beforeATExpireAlertSend-" + UUID.randomUUID());
+ // set expired test cases
+ DBUser certExpiredNoAlertSend = TestDBUtils.createDBUserByCertificate("ATExpiredNoAlertSend-" + UUID.randomUUID());
+ DBUser certExpiredRecentAlertSend = TestDBUtils.createDBUserByCertificate("ATExpiredRecentAlertSend-" + UUID.randomUUID());
+ DBUser certExpiredAlertSend = TestDBUtils.createDBUserByCertificate("ATExpiredAlertSend-" + UUID.randomUUID());
+
+ @Autowired
+ CredentialDao testInstance;
+
+ @Autowired
+ UserDao userDao;
+
+ @Before
+ public void setupData() {
+ // persist users to database
+ userDao.persistFlushDetach(okUser);
+ userDao.persistFlushDetach(beforePasswordExpireNoAlertSend);
+ userDao.persistFlushDetach(beforePasswordExpireRecentAlertSend);
+ userDao.persistFlushDetach(beforePasswordExpireAlertSend);
+ userDao.persistFlushDetach(passwordExpiredNoAlertSend);
+ userDao.persistFlushDetach(passwordExpiredRecentAlertSend);
+ userDao.persistFlushDetach(passwordExpiredAlertSend);
+ userDao.persistFlushDetach(beforeATExpireNoAlertSend);
+ userDao.persistFlushDetach(beforeATExpireRecentAlertSend);
+ userDao.persistFlushDetach(beforeATExpireAlertSend);
+ userDao.persistFlushDetach(aTExpiredNoAlertSend);
+ userDao.persistFlushDetach(aTExpiredRecentAlertSend);
+ userDao.persistFlushDetach(aTExpiredAlertSend);
+ userDao.persistFlushDetach(beforeCertExpireNoAlertSend);
+ userDao.persistFlushDetach(beforeCertExpireRecentAlertSend);
+ userDao.persistFlushDetach(beforeCertExpireAlertSend);
+ userDao.persistFlushDetach(certExpiredNoAlertSend);
+ userDao.persistFlushDetach(certExpiredRecentAlertSend);
+ userDao.persistFlushDetach(certExpiredAlertSend);
+ // configure user credentials for various issues
+
+ // set user password credentials to database
+ // reference OK User
+ DBCredential credOkUser = TestDBUtils.createDBCredentialForUser(okUser, null, OffsetDateTime.now().plusDays(90) , null);
+ // test before password expires - alerts are send 30 days before they are expired and mail is send every 5 days
+ // set users where
+ // -- user credBeforePasswordExpireNoAlertSend - password will expire in 20 days - alert must be sent.
+ // -- user credBeforePasswordExpireRecentAlertSend - password will expire in 20 days - but alert was sent 2 days ago
+ // -- user credBeforePasswordExpireAlertSend - password will expire in 20 days and alert was sent 10 days ago - alert must be sent again
+ DBCredential credBeforePasswordExpireNoAlertSend = TestDBUtils.createDBCredentialForUser(beforePasswordExpireNoAlertSend, null,
+ OffsetDateTime.now().plusDays(20), null);
+ DBCredential credBeforePasswordExpireRecentAlertSend = TestDBUtils.createDBCredentialForUser(beforePasswordExpireRecentAlertSend, null,
+ OffsetDateTime.now().plusDays(20), OffsetDateTime.now().minusDays(2));
+ DBCredential credBeforePasswordExpireAlertSend = TestDBUtils.createDBCredentialForUser(beforePasswordExpireAlertSend, null,
+ OffsetDateTime.now().plusDays(20),OffsetDateTime.now().minusDays(10));
+ // -- user 1 - password expired 20 days aga alert must be sent.
+ // -- user 2 - password expired 20 ago - but alert was sent 2 days ago - no need to send it yet.
+ // -- user 3 - password expired 20 ago and alert was sent 10 days ago - alert must be sent again
+ DBCredential credPasswordExpiredNoAlertSend = TestDBUtils.createDBCredentialForUser(passwordExpiredNoAlertSend, null,
+ OffsetDateTime.now().minusDays(20), null);
+ DBCredential credPasswordExpiredRecentAlertSend = TestDBUtils.createDBCredentialForUser(passwordExpiredRecentAlertSend, null,
+ OffsetDateTime.now().minusDays(20), OffsetDateTime.now().minusDays(2));
+ DBCredential credPasswordExpiredAlertSend = TestDBUtils.createDBCredentialForUser(passwordExpiredAlertSend, null,
+ OffsetDateTime.now().minusDays(20), OffsetDateTime.now().minusDays(10));
+
+ //-----------------------------------------
+ // set before expired access-token testcases
+ DBCredential credBeforeATExpireNoAlertSend = TestDBUtils.createDBCredentialForUserAccessToken(beforeATExpireNoAlertSend, null,
+ OffsetDateTime.now().plusDays(20), null);
+ DBCredential credBeforeATExpireRecentAlertSend = TestDBUtils.createDBCredentialForUserAccessToken(beforeATExpireRecentAlertSend, null,
+ OffsetDateTime.now().plusDays(20), OffsetDateTime.now().minusDays(2));
+ DBCredential credBeforeATExpireAlertSend = TestDBUtils.createDBCredentialForUserAccessToken(beforeATExpireAlertSend, null,
+ OffsetDateTime.now().plusDays(20),OffsetDateTime.now().minusDays(10));
+ DBCredential credATExpiredNoAlertSend = TestDBUtils.createDBCredentialForUserAccessToken(aTExpiredNoAlertSend, null,
+ OffsetDateTime.now().minusDays(20), null);
+ DBCredential credATExpiredRecentAlertSend = TestDBUtils.createDBCredentialForUserAccessToken(aTExpiredRecentAlertSend, null,
+ OffsetDateTime.now().minusDays(20), OffsetDateTime.now().minusDays(2));
+ DBCredential credATExpiredAlertSend = TestDBUtils.createDBCredentialForUserAccessToken(aTExpiredAlertSend, null,
+ OffsetDateTime.now().minusDays(20), OffsetDateTime.now().minusDays(10));
+
+ //-----------------------------------------
+ // set before expired certificates testcases
+ DBCredential credBeforeCertExpireNoAlertSend = TestDBUtils.createDBCredentialForUserCertificate(beforeCertExpireNoAlertSend, null,
+ OffsetDateTime.now().plusDays(20), null);
+ DBCredential credBeforeCertExpireRecentAlertSend = TestDBUtils.createDBCredentialForUserCertificate(beforeCertExpireRecentAlertSend, null,
+ OffsetDateTime.now().plusDays(20), OffsetDateTime.now().minusDays(2));
+ DBCredential credBeforeCertExpireAlertSend = TestDBUtils.createDBCredentialForUserCertificate(beforeCertExpireAlertSend, null,
+ OffsetDateTime.now().plusDays(20),OffsetDateTime.now().minusDays(10));
+ // set expired certificates testcases
+ DBCredential credCertExpiredNoAlertSend = TestDBUtils.createDBCredentialForUserCertificate(certExpiredNoAlertSend, null,
+ OffsetDateTime.now().minusDays(20), null);
+ DBCredential credCertExpiredRecentAlertSend = TestDBUtils.createDBCredentialForUserCertificate(certExpiredRecentAlertSend, null,
+ OffsetDateTime.now().minusDays(20), OffsetDateTime.now().minusDays(2));
+ DBCredential credCertExpiredAlertSend = TestDBUtils.createDBCredentialForUserCertificate(certExpiredAlertSend, null,
+ OffsetDateTime.now().minusDays(20), OffsetDateTime.now().minusDays(10));
+
+ // persists
+ testInstance.persistFlushDetach(credOkUser);
+ testInstance.persistFlushDetach(credBeforePasswordExpireNoAlertSend);
+ testInstance.persistFlushDetach(credBeforePasswordExpireRecentAlertSend);
+ testInstance.persistFlushDetach(credBeforePasswordExpireAlertSend);
+ testInstance.persistFlushDetach(credPasswordExpiredNoAlertSend);
+ testInstance.persistFlushDetach(credPasswordExpiredRecentAlertSend);
+ testInstance.persistFlushDetach(credPasswordExpiredAlertSend);
+ // access token examples
+ testInstance.persistFlushDetach(credBeforeATExpireNoAlertSend);
+ testInstance.persistFlushDetach(credBeforeATExpireRecentAlertSend);
+ testInstance.persistFlushDetach(credBeforeATExpireAlertSend);
+ testInstance.persistFlushDetach(credATExpiredNoAlertSend);
+ testInstance.persistFlushDetach(credATExpiredRecentAlertSend);
+ testInstance.persistFlushDetach(credATExpiredAlertSend);
+ // certificate examples
+ testInstance.persistFlushDetach(credBeforeCertExpireNoAlertSend);
+ testInstance.persistFlushDetach(credBeforeCertExpireRecentAlertSend);
+ testInstance.persistFlushDetach(credBeforeCertExpireAlertSend);
+ testInstance.persistFlushDetach(credCertExpiredNoAlertSend);
+ testInstance.persistFlushDetach(credCertExpiredRecentAlertSend);
+ testInstance.persistFlushDetach(credCertExpiredAlertSend);
+ }
+
+ @Test
+ public void getPasswordImminentExpireUsers() {
+ List<DBCredential> dbUserList = testInstance.getBeforePasswordExpireUsersForAlerts(30, 5, 200);
+ List<String> usernames = dbUserList.stream().map(DBCredential::getUser).map(DBUser::getUsername).collect(Collectors.toList());
+ assertTrue(usernames.contains(beforePasswordExpireNoAlertSend.getUsername()));
+ assertTrue(usernames.contains(beforePasswordExpireAlertSend.getUsername()));
+ }
+
+ @Test
+ public void getPasswordExpireUsers() {
+ List<DBCredential> dbUserList = testInstance.getPasswordExpiredUsersForAlerts(30, 5, 200);
+ assertEquals(2, dbUserList.size());
+ List<String> usernames = dbUserList.stream().map(DBCredential::getUser).map(DBUser::getUsername).collect(Collectors.toList());
+ assertTrue(usernames.contains(passwordExpiredNoAlertSend.getUsername()));
+ assertTrue(usernames.contains(passwordExpiredAlertSend.getUsername()));
+ }
+
+ @Test
+ public void getAccessTokenImminentExpireUsers() {
+ List<DBCredential> dbUserList = testInstance.getBeforeAccessTokenExpireUsersForAlerts(30, 5, 200);
+ List<String> usernames = dbUserList.stream().map(DBCredential::getUser).map(DBUser::getUsername).collect(Collectors.toList());
+ System.out.println(usernames);
+ assertEquals(2, dbUserList.size());
+ assertTrue(usernames.contains(beforeATExpireNoAlertSend.getUsername()));
+ assertTrue(usernames.contains(beforeATExpireAlertSend.getUsername()));
+ }
+
+ @Test
+ public void getAccessTokenExpireUsers() {
+ List<DBCredential> dbUserList = testInstance.getAccessTokenExpiredUsersForAlerts(30, 5, 200);
+ List<String> usernames = dbUserList.stream().map(DBCredential::getUser).map(DBUser::getUsername).collect(Collectors.toList());
+ System.out.println(usernames);
+ assertEquals(2, dbUserList.size());
+ assertTrue(usernames.contains(aTExpiredNoAlertSend.getUsername()));
+ assertTrue(usernames.contains(aTExpiredAlertSend.getUsername()));
+ }
+
+ @Test
+ public void getCertificateImminentExpireUsers() {
+ List<DBCredential> dbUserList = testInstance.getBeforeCertificateExpireUsersForAlerts(30, 5, 200);
+ List<String> usernames = dbUserList.stream().map(DBCredential::getUser).map(DBUser::getUsername).collect(Collectors.toList());
+ System.out.println(usernames);
+ assertEquals(2, dbUserList.size());
+ assertTrue(usernames.contains(beforeCertExpireNoAlertSend.getUsername()));
+ assertTrue(usernames.contains(beforeCertExpireAlertSend.getUsername()));
+ }
+
+ @Test
+ public void getCertificateExpireUsers() {
+ List<DBCredential> dbUserList = testInstance.getCertificateExpiredUsersForAlerts(30, 5, 200);
+ List<String> usernames = dbUserList.stream().map(DBCredential::getUser).map(DBUser::getUsername).collect(Collectors.toList());
+ System.out.println(usernames);
+ assertEquals(2, dbUserList.size());
+ assertTrue(usernames.contains(certExpiredNoAlertSend.getUsername()));
+ assertTrue(usernames.contains(certExpiredAlertSend.getUsername()));
+ }
+}
diff --git a/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/data/dao/UserDaoAlertsTest.java b/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/data/dao/UserDaoAlertsTest.java
deleted file mode 100644
index 58e17229f..000000000
--- a/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/data/dao/UserDaoAlertsTest.java
+++ /dev/null
@@ -1,180 +0,0 @@
-package eu.europa.ec.edelivery.smp.data.dao;
-
-import eu.europa.ec.edelivery.smp.data.model.user.DBUser;
-import eu.europa.ec.edelivery.smp.testutil.TestDBUtils;
-import org.junit.Before;
-import org.junit.Ignore;
-import org.junit.Test;
-import org.springframework.beans.factory.annotation.Autowired;
-
-import java.time.OffsetDateTime;
-import java.util.List;
-import java.util.UUID;
-import java.util.stream.Collectors;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-
-@Ignore
-public class UserDaoAlertsTest extends AbstractBaseDao {
-/*
- DBUser okUser = TestDBUtils.createDBUserByUsername("okUser-" + UUID.randomUUID().toString());
- DBUser beforePasswordExpireNoAlertSend = TestDBUtils.createDBUserByUsername("beforePasswordExpireNoAlertSend-" + UUID.randomUUID().toString());
- DBUser beforePasswordExpireRecentAlertSend = TestDBUtils.createDBUserByUsername("beforePasswordExpireRecentAlertSend-" + UUID.randomUUID().toString());
- DBUser beforePasswordExpireAlertSend = TestDBUtils.createDBUserByUsername("beforePasswordExpireAlertSend-" + UUID.randomUUID().toString());
- // set expired test cases
- DBUser passwordExpiredNoAlertSend = TestDBUtils.createDBUserByUsername("passwordExpiredNoAlertSend-" + UUID.randomUUID().toString());
- DBUser passwordExpiredRecentAlertSend = TestDBUtils.createDBUserByUsername("passwordExpiredRecentAlertSend-" + UUID.randomUUID().toString());
- DBUser passwordExpiredAlertSend = TestDBUtils.createDBUserByUsername("passwordExpiredAlertSend-" + UUID.randomUUID().toString());
- // ------------
- // access token users setup
- DBUser beforeATExpireNoAlertSend = TestDBUtils.createDBUserByUsername("beforeATExpireNoAlertSend-" + UUID.randomUUID().toString());
- DBUser beforeATExpireRecentAlertSend = TestDBUtils.createDBUserByUsername("beforeATExpireRecentAlertSend-" + UUID.randomUUID().toString());
- DBUser beforeATExpireAlertSend = TestDBUtils.createDBUserByUsername("beforeATExpireAlertSend-" + UUID.randomUUID().toString());
- // set expired test cases
- DBUser aTExpiredNoAlertSend = TestDBUtils.createDBUserByUsername("ATExpiredNoAlertSend-" + UUID.randomUUID().toString());
- DBUser aTExpiredRecentAlertSend = TestDBUtils.createDBUserByUsername("ATExpiredRecentAlertSend-" + UUID.randomUUID().toString());
- DBUser aTExpiredAlertSend = TestDBUtils.createDBUserByUsername("ATExpiredAlertSend-" + UUID.randomUUID().toString());
-
- // ------------
- // access token users setup
- DBUser beforeCertExpireNoAlertSend = TestDBUtils.createDBUserByCertificate("beforecertxpireNoAlertSend-" + UUID.randomUUID().toString());
- DBUser beforeCertExpireRecentAlertSend = TestDBUtils.createDBUserByCertificate("beforeATExpireRecentAlertSend-" + UUID.randomUUID().toString());
- DBUser beforeCertExpireAlertSend = TestDBUtils.createDBUserByCertificate("beforeATExpireAlertSend-" + UUID.randomUUID().toString());
- // set expired test cases
- DBUser certExpiredNoAlertSend = TestDBUtils.createDBUserByCertificate("ATExpiredNoAlertSend-" + UUID.randomUUID().toString());
- DBUser certExpiredRecentAlertSend = TestDBUtils.createDBUserByCertificate("ATExpiredRecentAlertSend-" + UUID.randomUUID().toString());
- DBUser certExpiredAlertSend = TestDBUtils.createDBUserByCertificate("ATExpiredAlertSend-" + UUID.randomUUID().toString());
-
- @Autowired
- UserDao testInstance;
-
- @Before
- public void setupData() {
- // reference OK User
- okUser.setPasswordExpireOn(OffsetDateTime.now().plusDays(90));
- // set before expired username-password testcases
- okUser.setPasswordExpireOn(OffsetDateTime.now().plusDays(90));
- beforePasswordExpireNoAlertSend.setPasswordExpireOn(OffsetDateTime.now().plusDays(20));
- beforePasswordExpireRecentAlertSend.setPasswordExpireOn(OffsetDateTime.now().plusDays(20));
- beforePasswordExpireRecentAlertSend.setPasswordExpireAlertOn(OffsetDateTime.now().minusDays(2));
- beforePasswordExpireAlertSend.setPasswordExpireOn(OffsetDateTime.now().plusDays(20));
- beforePasswordExpireAlertSend.setPasswordExpireAlertOn(OffsetDateTime.now().minusDays(10));
- // set expired username-password testcases
- passwordExpiredNoAlertSend.setPasswordExpireOn(OffsetDateTime.now().minusDays(20));
- passwordExpiredRecentAlertSend.setPasswordExpireOn(OffsetDateTime.now().minusDays(20));
- passwordExpiredRecentAlertSend.setPasswordExpireAlertOn(OffsetDateTime.now().minusDays(2));
- passwordExpiredAlertSend.setPasswordExpireOn(OffsetDateTime.now().minusDays(10));
- //-----------------------------------------
- // set before expired access-token testcases
- beforeATExpireNoAlertSend.setAccessTokenExpireOn(OffsetDateTime.now().plusDays(20));
- beforeATExpireRecentAlertSend.setAccessTokenExpireOn(OffsetDateTime.now().plusDays(20));
- beforeATExpireRecentAlertSend.setAccessTokenExpireAlertOn(OffsetDateTime.now().minusDays(2));
- beforeATExpireAlertSend.setAccessTokenExpireOn(OffsetDateTime.now().plusDays(20));
- beforeATExpireAlertSend.setAccessTokenExpireAlertOn(OffsetDateTime.now().minusDays(10));
- // set expired access-token testcases
- aTExpiredNoAlertSend.setAccessTokenExpireOn(OffsetDateTime.now().minusDays(20));
- aTExpiredRecentAlertSend.setAccessTokenExpireOn(OffsetDateTime.now().minusDays(20));
- aTExpiredRecentAlertSend.setAccessTokenExpireAlertOn(OffsetDateTime.now().minusDays(2));
- aTExpiredAlertSend.setAccessTokenExpireOn(OffsetDateTime.now().minusDays(10));
- //-----------------------------------------
- // set before expired certificates testcases
- beforeCertExpireNoAlertSend.getCertificate().setValidTo(OffsetDateTime.now().plusDays(20));
- beforeCertExpireRecentAlertSend.getCertificate().setValidTo(OffsetDateTime.now().plusDays(20));
- beforeCertExpireRecentAlertSend.getCertificate().setCertificateLastExpireAlertOn(OffsetDateTime.now().minusDays(2));
- beforeCertExpireAlertSend.getCertificate().setValidTo(OffsetDateTime.now().plusDays(20));
- beforeCertExpireAlertSend.getCertificate().setCertificateLastExpireAlertOn(OffsetDateTime.now().minusDays(10));
- // set expired certificates testcases
- certExpiredNoAlertSend.getCertificate().setValidTo(OffsetDateTime.now().minusDays(20));
- certExpiredRecentAlertSend.getCertificate().setValidTo(OffsetDateTime.now().minusDays(20));
- certExpiredRecentAlertSend.getCertificate().setCertificateLastExpireAlertOn(OffsetDateTime.now().minusDays(2));
- certExpiredAlertSend.getCertificate().setValidTo(OffsetDateTime.now().minusDays(10));
- // persists
- testInstance.persistFlushDetach(okUser);
- testInstance.persistFlushDetach(beforePasswordExpireNoAlertSend);
- testInstance.persistFlushDetach(beforePasswordExpireRecentAlertSend);
- testInstance.persistFlushDetach(beforePasswordExpireAlertSend);
-
- testInstance.persistFlushDetach(passwordExpiredNoAlertSend);
- testInstance.persistFlushDetach(passwordExpiredRecentAlertSend);
- testInstance.persistFlushDetach(passwordExpiredAlertSend);
-
- testInstance.persistFlushDetach(beforeATExpireNoAlertSend);
- testInstance.persistFlushDetach(beforeATExpireRecentAlertSend);
- testInstance.persistFlushDetach(beforeATExpireAlertSend);
-
- testInstance.persistFlushDetach(aTExpiredNoAlertSend);
- testInstance.persistFlushDetach(aTExpiredRecentAlertSend);
- testInstance.persistFlushDetach(aTExpiredAlertSend);
- // ---
- testInstance.persistFlushDetach(beforeCertExpireNoAlertSend);
- testInstance.persistFlushDetach(beforeCertExpireRecentAlertSend);
- testInstance.persistFlushDetach(beforeCertExpireAlertSend);
-
- testInstance.persistFlushDetach(certExpiredNoAlertSend);
- testInstance.persistFlushDetach(certExpiredRecentAlertSend);
- testInstance.persistFlushDetach(certExpiredAlertSend);
- }
-
- @Test
- public void getPasswordImminentExpireUsers() {
- List<DBUser> dbUserList = testInstance.getBeforePasswordExpireUsersForAlerts(30, 5, 200);
- assertEquals(2, dbUserList.size());
- List<String> usernames = dbUserList.stream().map(DBUser::getUsername).collect(Collectors.toList());
- System.out.println(usernames);
- assertTrue(usernames.contains(beforePasswordExpireNoAlertSend.getUsername()));
- assertTrue(usernames.contains(beforePasswordExpireAlertSend.getUsername()));
- }
-
- @Test
- public void getPasswordExpireUsers() {
- List<DBUser> dbUserList = testInstance.getPasswordExpiredUsersForAlerts(30, 5, 200);
- assertEquals(2, dbUserList.size());
- List<String> usernames = dbUserList.stream().map(DBUser::getUsername).collect(Collectors.toList());
- System.out.println(usernames);
- assertTrue(usernames.contains(passwordExpiredNoAlertSend.getUsername()));
- assertTrue(usernames.contains(passwordExpiredAlertSend.getUsername()));
- }
-
- @Test
- public void getAccessTokenImminentExpireUsers() {
- List<DBUser> dbUserList = testInstance.getBeforeAccessTokenExpireUsersForAlerts(30, 5, 200);
- List<String> usernames = dbUserList.stream().map(DBUser::getUsername).collect(Collectors.toList());
- System.out.println(usernames);
- assertEquals(2, dbUserList.size());
- assertTrue(usernames.contains(beforeATExpireNoAlertSend.getUsername()));
- assertTrue(usernames.contains(beforeATExpireAlertSend.getUsername()));
- }
-
- @Test
- public void getAccessTokenExpireUsers() {
- List<DBUser> dbUserList = testInstance.getAccessTokenExpiredUsersForAlerts(30, 5, 200);
- List<String> usernames = dbUserList.stream().map(DBUser::getUsername).collect(Collectors.toList());
- System.out.println(usernames);
- assertEquals(2, dbUserList.size());
- assertTrue(usernames.contains(aTExpiredNoAlertSend.getUsername()));
- assertTrue(usernames.contains(aTExpiredAlertSend.getUsername()));
- }
-
- @Test
- public void getCertificateImminentExpireUsers() {
- List<DBUser> dbUserList = testInstance.getBeforeCertificateExpireUsersForAlerts(30, 5, 200);
- List<String> usernames = dbUserList.stream().map(DBUser::getUsername).collect(Collectors.toList());
- System.out.println(usernames);
- assertEquals(2, dbUserList.size());
- assertTrue(usernames.contains(beforeCertExpireNoAlertSend.getUsername()));
- assertTrue(usernames.contains(beforeCertExpireAlertSend.getUsername()));
- }
-
- @Test
- public void getCertificateExpireUsers() {
- List<DBUser> dbUserList = testInstance.getCertificateExpiredUsersForAlerts(30, 5, 200);
- List<String> usernames = dbUserList.stream().map(DBUser::getUsername).collect(Collectors.toList());
- System.out.println(usernames);
- assertEquals(2, dbUserList.size());
- assertTrue(usernames.contains(certExpiredNoAlertSend.getUsername()));
- assertTrue(usernames.contains(certExpiredAlertSend.getUsername()));
- }
-
- */
-}
diff --git a/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/AlertServiceTest.java b/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/AlertServiceTest.java
index d619b8674..1a56789e2 100644
--- a/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/AlertServiceTest.java
+++ b/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/AlertServiceTest.java
@@ -2,31 +2,18 @@ package eu.europa.ec.edelivery.smp.services;
import eu.europa.ec.edelivery.smp.cron.SMPDynamicCronTrigger;
import eu.europa.ec.edelivery.smp.data.dao.AlertDao;
+import eu.europa.ec.edelivery.smp.data.dao.CredentialDao;
import eu.europa.ec.edelivery.smp.data.dao.UserDao;
import eu.europa.ec.edelivery.smp.data.model.DBAlert;
-import eu.europa.ec.edelivery.smp.data.model.user.DBUser;
import eu.europa.ec.edelivery.smp.data.ui.enums.AlertLevelEnum;
import eu.europa.ec.edelivery.smp.data.ui.enums.AlertStatusEnum;
import eu.europa.ec.edelivery.smp.data.ui.enums.AlertTypeEnum;
-import eu.europa.ec.edelivery.smp.services.mail.MailModel;
import eu.europa.ec.edelivery.smp.services.mail.MailService;
-import eu.europa.ec.edelivery.smp.services.mail.prop.CredentialSuspendedProperties;
-import eu.europa.ec.edelivery.smp.services.mail.prop.CredentialVerificationFailedProperties;
-import eu.europa.ec.edelivery.smp.services.mail.prop.CredentialsExpirationProperties;
-import eu.europa.ec.edelivery.smp.testutil.TestDBUtils;
import org.junit.Ignore;
import org.junit.Test;
-import org.mockito.ArgumentCaptor;
import org.mockito.Mockito;
-import java.time.OffsetDateTime;
-import java.util.Arrays;
-import java.util.List;
-import java.util.Properties;
-import java.util.stream.Collectors;
-
import static org.junit.Assert.*;
-import static org.mockito.Mockito.*;
@Ignore
public class AlertServiceTest {
@@ -35,10 +22,11 @@ public class AlertServiceTest {
MailService mailService = Mockito.mock(MailService.class);
ConfigurationService configurationService = Mockito.mock(ConfigurationService.class);
UserDao userDao = Mockito.mock(UserDao.class);
+ CredentialDao credentialDao = Mockito.mock(CredentialDao.class);
SMPDynamicCronTrigger alertCronTrigger = Mockito.mock(SMPDynamicCronTrigger.class);
- CredentialsAlertService testInstance = new CredentialsAlertService(alertDao, mailService, configurationService,userDao,alertCronTrigger);
+ CredentialsAlertService testInstance = new CredentialsAlertService(alertDao, mailService, configurationService, userDao, credentialDao, alertCronTrigger);
@Test
public void testCreateAlert() {
diff --git a/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/CredentialValidatorServiceTest.java b/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/CredentialValidatorServiceTest.java
index 94eff07ad..135ae84ba 100644
--- a/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/CredentialValidatorServiceTest.java
+++ b/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/CredentialValidatorServiceTest.java
@@ -1,6 +1,7 @@
package eu.europa.ec.edelivery.smp.services;
-import eu.europa.ec.edelivery.smp.data.dao.UserDao;
+import eu.europa.ec.edelivery.smp.data.dao.CredentialDao;
+import eu.europa.ec.edelivery.smp.data.model.user.DBCredential;
import eu.europa.ec.edelivery.smp.data.model.user.DBUser;
import eu.europa.ec.edelivery.smp.utils.HttpUtils;
import org.junit.Test;
@@ -18,9 +19,9 @@ public class CredentialValidatorServiceTest {
ConfigurationService mockConfigService = Mockito.mock(ConfigurationService.class);
CredentialsAlertService mockAlertService = Mockito.mock(CredentialsAlertService.class);
- UserDao mockUserDao = Mockito.mock(UserDao.class);
+ CredentialDao mockCredentialDao = Mockito.mock(CredentialDao.class);
- CredentialValidatorService testInstance = new CredentialValidatorService(mockConfigService, mockAlertService, mockUserDao);
+ CredentialValidatorService testInstance = new CredentialValidatorService(mockConfigService, mockAlertService, mockCredentialDao);
@Test
public void testSkipCredentialValidationFalseNotCluster() {
@@ -52,7 +53,7 @@ public class CredentialValidatorServiceTest {
@Test
public void validateCredentialsForBeforeExpireUsernames() {
- DBUser user = Mockito.mock(DBUser.class);
+ DBCredential userCredentials = Mockito.mock(DBCredential.class);
Integer iPeriod = 10;
Integer iInterval = 15;
Integer iBatchSize = 20;
@@ -61,7 +62,7 @@ public class CredentialValidatorServiceTest {
doReturn(iPeriod).when(mockConfigService).getAlertBeforeExpirePasswordPeriod();
doReturn(iInterval).when(mockConfigService).getAlertBeforeExpirePasswordInterval();
doReturn(iBatchSize).when(mockConfigService).getAlertCredentialsBatchSize();
- doReturn(Collections.singletonList(user)).when(mockUserDao).getBeforePasswordExpireUsersForAlerts(anyInt(), anyInt(), anyInt());
+ doReturn(Collections.singletonList(userCredentials)).when(mockCredentialDao).getBeforePasswordExpireUsersForAlerts(anyInt(), anyInt(), anyInt());
testInstance.validateCredentialsForBeforeExpireUsernames();
@@ -69,23 +70,23 @@ public class CredentialValidatorServiceTest {
ArgumentCaptor<Integer> period = ArgumentCaptor.forClass(Integer.class);
ArgumentCaptor<Integer> interval = ArgumentCaptor.forClass(Integer.class);
ArgumentCaptor<Integer> batchSize = ArgumentCaptor.forClass(Integer.class);
- ArgumentCaptor<DBUser> userCapture = ArgumentCaptor.forClass(DBUser.class);
+ ArgumentCaptor<DBCredential> userCapture = ArgumentCaptor.forClass(DBCredential.class);
- verify(mockUserDao, Mockito.times(1))
+ verify(mockCredentialDao, Mockito.times(1))
.getBeforePasswordExpireUsersForAlerts(period.capture(), interval.capture(), batchSize.capture());
verify(mockAlertService, Mockito.times(1))
- .alertBeforeUsernamePasswordExpire(userCapture.capture());
+ .alertBeforeCredentialExpire(userCapture.capture());
assertEquals(iPeriod, period.getValue());
assertEquals(iInterval, interval.getValue());
assertEquals(iBatchSize, batchSize.getValue());
- assertEquals(user, userCapture.getValue());
+ assertEquals(userCredentials, userCapture.getValue());
}
@Test
public void validateCredentialsForExpiredUsernames() {
- DBUser user = Mockito.mock(DBUser.class);
+ DBCredential userCredentials = Mockito.mock(DBCredential.class);
Integer iPeriod = 10;
Integer iInterval = 15;
Integer iBatchSize = 20;
@@ -94,7 +95,7 @@ public class CredentialValidatorServiceTest {
doReturn(iPeriod).when(mockConfigService).getAlertExpiredPasswordPeriod();
doReturn(iInterval).when(mockConfigService).getAlertExpiredPasswordInterval();
doReturn(iBatchSize).when(mockConfigService).getAlertCredentialsBatchSize();
- doReturn(Collections.singletonList(user)).when(mockUserDao).getPasswordExpiredUsersForAlerts(anyInt(), anyInt(), anyInt());
+ doReturn(Collections.singletonList(userCredentials)).when(mockCredentialDao).getPasswordExpiredUsersForAlerts(anyInt(), anyInt(), anyInt());
testInstance.validateCredentialsForExpiredUsernames();
@@ -102,23 +103,23 @@ public class CredentialValidatorServiceTest {
ArgumentCaptor<Integer> period = ArgumentCaptor.forClass(Integer.class);
ArgumentCaptor<Integer> interval = ArgumentCaptor.forClass(Integer.class);
ArgumentCaptor<Integer> batchSize = ArgumentCaptor.forClass(Integer.class);
- ArgumentCaptor<DBUser> userCapture = ArgumentCaptor.forClass(DBUser.class);
+ ArgumentCaptor<DBCredential> userCapture = ArgumentCaptor.forClass(DBCredential.class);
- verify(mockUserDao, Mockito.times(1))
+ verify(mockCredentialDao, Mockito.times(1))
.getPasswordExpiredUsersForAlerts(period.capture(), interval.capture(), batchSize.capture());
verify(mockAlertService, Mockito.times(1))
- .alertUsernamePasswordExpired(userCapture.capture());
+ .alertCredentialExpired(userCapture.capture());
assertEquals(iPeriod, period.getValue());
assertEquals(iInterval, interval.getValue());
assertEquals(iBatchSize, batchSize.getValue());
- assertEquals(user, userCapture.getValue());
+ assertEquals(userCredentials, userCapture.getValue());
}
@Test
public void validateCredentialsForBeforeExpireAccessToken() {
- DBUser user = Mockito.mock(DBUser.class);
+ DBCredential userCredentials = Mockito.mock(DBCredential.class);
Integer iPeriod = 10;
Integer iInterval = 15;
Integer iBatchSize = 20;
@@ -127,7 +128,7 @@ public class CredentialValidatorServiceTest {
doReturn(iPeriod).when(mockConfigService).getAlertBeforeExpireAccessTokenPeriod();
doReturn(iInterval).when(mockConfigService).getAlertBeforeExpireAccessTokenInterval();
doReturn(iBatchSize).when(mockConfigService).getAlertCredentialsBatchSize();
- doReturn(Collections.singletonList(user)).when(mockUserDao).getBeforeAccessTokenExpireUsersForAlerts(anyInt(), anyInt(), anyInt());
+ doReturn(Collections.singletonList(userCredentials)).when(mockCredentialDao).getBeforeAccessTokenExpireUsersForAlerts(anyInt(), anyInt(), anyInt());
testInstance.validateCredentialsForBeforeExpireAccessToken();
@@ -135,23 +136,23 @@ public class CredentialValidatorServiceTest {
ArgumentCaptor<Integer> period = ArgumentCaptor.forClass(Integer.class);
ArgumentCaptor<Integer> interval = ArgumentCaptor.forClass(Integer.class);
ArgumentCaptor<Integer> batchSize = ArgumentCaptor.forClass(Integer.class);
- ArgumentCaptor<DBUser> userCapture = ArgumentCaptor.forClass(DBUser.class);
+ ArgumentCaptor<DBCredential> userCapture = ArgumentCaptor.forClass(DBCredential.class);
- verify(mockUserDao, Mockito.times(1))
+ verify(mockCredentialDao, Mockito.times(1))
.getBeforeAccessTokenExpireUsersForAlerts(period.capture(), interval.capture(), batchSize.capture());
verify(mockAlertService, Mockito.times(1))
- .alertBeforeAccessTokenExpire(userCapture.capture());
+ .alertBeforeCredentialExpire(userCapture.capture());
assertEquals(iPeriod, period.getValue());
assertEquals(iInterval, interval.getValue());
assertEquals(iBatchSize, batchSize.getValue());
- assertEquals(user, userCapture.getValue());
+ assertEquals(userCredentials, userCapture.getValue());
}
@Test
public void validateCredentialsForExpiredAccessToken() {
- DBUser user = Mockito.mock(DBUser.class);
+ DBCredential userCredentials = Mockito.mock(DBCredential.class);
Integer iPeriod = 10;
Integer iInterval = 15;
Integer iBatchSize = 20;
@@ -160,7 +161,7 @@ public class CredentialValidatorServiceTest {
doReturn(iPeriod).when(mockConfigService).getAlertExpiredAccessTokenPeriod();
doReturn(iInterval).when(mockConfigService).getAlertExpiredAccessTokenInterval();
doReturn(iBatchSize).when(mockConfigService).getAlertCredentialsBatchSize();
- doReturn(Collections.singletonList(user)).when(mockUserDao).getAccessTokenExpiredUsersForAlerts(anyInt(), anyInt(), anyInt());
+ doReturn(Collections.singletonList(userCredentials)).when(mockCredentialDao).getAccessTokenExpiredUsersForAlerts(anyInt(), anyInt(), anyInt());
testInstance.validateCredentialsForExpiredAccessToken();
@@ -168,23 +169,23 @@ public class CredentialValidatorServiceTest {
ArgumentCaptor<Integer> period = ArgumentCaptor.forClass(Integer.class);
ArgumentCaptor<Integer> interval = ArgumentCaptor.forClass(Integer.class);
ArgumentCaptor<Integer> batchSize = ArgumentCaptor.forClass(Integer.class);
- ArgumentCaptor<DBUser> userCapture = ArgumentCaptor.forClass(DBUser.class);
+ ArgumentCaptor<DBCredential> userCapture = ArgumentCaptor.forClass(DBCredential.class);
- verify(mockUserDao, Mockito.times(1))
+ verify(mockCredentialDao, Mockito.times(1))
.getAccessTokenExpiredUsersForAlerts(period.capture(), interval.capture(), batchSize.capture());
verify(mockAlertService, Mockito.times(1))
- .alertAccessTokenExpired(userCapture.capture());
+ .alertCredentialExpired(userCapture.capture());
assertEquals(iPeriod, period.getValue());
assertEquals(iInterval, interval.getValue());
assertEquals(iBatchSize, batchSize.getValue());
- assertEquals(user, userCapture.getValue());
+ assertEquals(userCredentials, userCapture.getValue());
}
@Test
public void validateCredentialsForBeforeExpireCertificate() {
- DBUser user = Mockito.mock(DBUser.class);
+ DBCredential userCredentials = Mockito.mock(DBCredential.class);
Integer iPeriod = 10;
Integer iInterval = 15;
Integer iBatchSize = 20;
@@ -193,7 +194,7 @@ public class CredentialValidatorServiceTest {
doReturn(iPeriod).when(mockConfigService).getAlertBeforeExpireCertificatePeriod();
doReturn(iInterval).when(mockConfigService).getAlertBeforeExpireCertificateInterval();
doReturn(iBatchSize).when(mockConfigService).getAlertCredentialsBatchSize();
- doReturn(Collections.singletonList(user)).when(mockUserDao).getBeforeCertificateExpireUsersForAlerts(anyInt(), anyInt(), anyInt());
+ doReturn(Collections.singletonList(userCredentials)).when(mockCredentialDao).getBeforeCertificateExpireUsersForAlerts(anyInt(), anyInt(), anyInt());
testInstance.validateCredentialsForBeforeExpireCertificate();
@@ -201,23 +202,23 @@ public class CredentialValidatorServiceTest {
ArgumentCaptor<Integer> period = ArgumentCaptor.forClass(Integer.class);
ArgumentCaptor<Integer> interval = ArgumentCaptor.forClass(Integer.class);
ArgumentCaptor<Integer> batchSize = ArgumentCaptor.forClass(Integer.class);
- ArgumentCaptor<DBUser> userCapture = ArgumentCaptor.forClass(DBUser.class);
+ ArgumentCaptor<DBCredential> userCapture = ArgumentCaptor.forClass(DBCredential.class);
- verify(mockUserDao, Mockito.times(1))
+ verify(mockCredentialDao, Mockito.times(1))
.getBeforeCertificateExpireUsersForAlerts(period.capture(), interval.capture(), batchSize.capture());
verify(mockAlertService, Mockito.times(1))
- .alertBeforeCertificateExpire(userCapture.capture());
+ .alertBeforeCredentialExpire(userCapture.capture());
assertEquals(iPeriod, period.getValue());
assertEquals(iInterval, interval.getValue());
assertEquals(iBatchSize, batchSize.getValue());
- assertEquals(user, userCapture.getValue());
+ assertEquals(userCredentials, userCapture.getValue());
}
@Test
public void validateCredentialsForExpiredCertificate() {
- DBUser user = Mockito.mock(DBUser.class);
+ DBCredential userCredentials = Mockito.mock(DBCredential.class);
Integer iPeriod = 10;
Integer iInterval = 15;
Integer iBatchSize = 20;
@@ -226,7 +227,7 @@ public class CredentialValidatorServiceTest {
doReturn(iPeriod).when(mockConfigService).getAlertExpiredCertificatePeriod();
doReturn(iInterval).when(mockConfigService).getAlertExpiredCertificateInterval();
doReturn(iBatchSize).when(mockConfigService).getAlertCredentialsBatchSize();
- doReturn(Collections.singletonList(user)).when(mockUserDao).getCertificateExpiredUsersForAlerts(anyInt(), anyInt(), anyInt());
+ doReturn(Collections.singletonList(userCredentials)).when(mockCredentialDao).getCertificateExpiredUsersForAlerts(anyInt(), anyInt(), anyInt());
testInstance.validateCredentialsForExpiredCertificate();
@@ -234,17 +235,17 @@ public class CredentialValidatorServiceTest {
ArgumentCaptor<Integer> period = ArgumentCaptor.forClass(Integer.class);
ArgumentCaptor<Integer> interval = ArgumentCaptor.forClass(Integer.class);
ArgumentCaptor<Integer> batchSize = ArgumentCaptor.forClass(Integer.class);
- ArgumentCaptor<DBUser> userCapture = ArgumentCaptor.forClass(DBUser.class);
+ ArgumentCaptor<DBCredential> userCapture = ArgumentCaptor.forClass(DBCredential.class);
- verify(mockUserDao, Mockito.times(1))
+ verify(mockCredentialDao, Mockito.times(1))
.getCertificateExpiredUsersForAlerts(period.capture(), interval.capture(), batchSize.capture());
verify(mockAlertService, Mockito.times(1))
- .alertCertificateExpired(userCapture.capture());
+ .alertCredentialExpired(userCapture.capture());
assertEquals(iPeriod, period.getValue());
assertEquals(iInterval, interval.getValue());
assertEquals(iBatchSize, batchSize.getValue());
- assertEquals(user, userCapture.getValue());
+ assertEquals(userCredentials, userCapture.getValue());
}
}
diff --git a/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/testutil/TestDBUtils.java b/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/testutil/TestDBUtils.java
index 7efc4cf24..83b2b0090 100644
--- a/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/testutil/TestDBUtils.java
+++ b/smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/testutil/TestDBUtils.java
@@ -191,10 +191,31 @@ public class TestDBUtils {
return createDBCredential("name", "value", CredentialType.USERNAME_PASSWORD, CredentialTargetType.UI);
}
- public static DBCredential createDBCredentialForUser(DBUser user) {
- return createDBCredential(user, user.getUsername(), "value", CredentialType.USERNAME_PASSWORD, CredentialTargetType.UI);
+ public static DBCredential createDBCredentialForUser(DBUser user, OffsetDateTime from , OffsetDateTime to, OffsetDateTime lastAlertSent ) {
+ DBCredential credential = createDBCredential(user, user.getUsername(), "value", CredentialType.USERNAME_PASSWORD, CredentialTargetType.UI);
+ credential.setExpireOn(to);
+ credential.setActiveFrom(from);
+ credential.setExpireAlertOn(lastAlertSent);
+ return credential;
}
+ public static DBCredential createDBCredentialForUserAccessToken(DBUser user, OffsetDateTime from , OffsetDateTime to, OffsetDateTime lastAlertSent ) {
+ DBCredential credential = createDBCredential(user, user.getUsername(), "value", CredentialType.ACCESS_TOKEN, CredentialTargetType.REST_API);
+ credential.setExpireOn(to);
+ credential.setActiveFrom(from);
+ credential.setExpireAlertOn(lastAlertSent);
+ return credential;
+ }
+
+ public static DBCredential createDBCredentialForUserCertificate(DBUser user, OffsetDateTime from , OffsetDateTime to, OffsetDateTime lastAlertSent ) {
+ DBCredential credential = createDBCredential(user, user.getUsername(), "value", CredentialType.CERTIFICATE, CredentialTargetType.REST_API);
+ credential.setExpireOn(to);
+ credential.setActiveFrom(from);
+ credential.setExpireAlertOn(lastAlertSent);
+ return credential;
+ }
+
+
public static DBCredential createDBCredential(DBUser dbUser, String name, String value, CredentialType credentialType, CredentialTargetType credentialTargetType) {
DBCredential dbCredential = new DBCredential();
dbCredential.setValue(value);
--
GitLab