Add option to save access tokens on database or not

Author: enricovianello

iam-common/src/main/java/it/infn/mw/iam/service/aup/DefaultAupSignatureCheckService.java

@@ -17,6 +17,7 @@
 
 import static java.util.Objects.isNull;
 
+import java.time.Clock;
 import java.util.Date;
 import java.util.Optional;
 import java.util.concurrent.TimeUnit;
@@ -25,7 +26,6 @@
 import org.slf4j.LoggerFactory;
 import org.springframework.stereotype.Service;
 
-import it.infn.mw.iam.core.time.TimeProvider;
 import it.infn.mw.iam.persistence.model.IamAccount;
 import it.infn.mw.iam.persistence.model.IamAup;
 import it.infn.mw.iam.persistence.repository.IamAupRepository;
@@ -38,20 +38,21 @@ public class DefaultAupSignatureCheckService implements AUPSignatureCheckService
 
   final IamAupRepository aupRepo;
   final IamAupSignatureRepository signatureRepo;
-  final TimeProvider timeProvider;
+  final Clock clock;
 
   public DefaultAupSignatureCheckService(IamAupRepository aupRepo,
-      IamAupSignatureRepository signatureRepo, TimeProvider timeProvider) {
+      IamAupSignatureRepository signatureRepo, Clock clock) {
     this.aupRepo = aupRepo;
     this.signatureRepo = signatureRepo;
-    this.timeProvider = timeProvider;
+    this.clock = clock;
   }
 
   @Override
   public boolean needsAupSignature(IamAccount account) {
+
     Optional<IamAup> aup = aupRepo.findDefaultAup();
 
-    Date now = new Date(timeProvider.currentTimeMillis());
+    Date now = Date.from(clock.instant());
 
     if (!aup.isPresent()) {
       LOG.debug("AUP signature not needed for account '{}': AUP is not defined",

iam-login-service/src/main/java/it/infn/mw/iam/api/aup/AupSignatureController.java

@@ -17,6 +17,7 @@
 
 import static java.lang.String.format;
 
+import java.time.Clock;
 import java.util.Date;
 import java.util.Optional;
 import java.util.function.Supplier;
@@ -50,7 +51,6 @@
 import it.infn.mw.iam.audit.events.aup.AupSignatureDeletedEvent;
 import it.infn.mw.iam.audit.events.aup.AupSignedEvent;
 import it.infn.mw.iam.audit.events.aup.AupSignedOnBehalfEvent;
-import it.infn.mw.iam.core.time.TimeProvider;
 import it.infn.mw.iam.notification.NotificationFactory;
 import it.infn.mw.iam.persistence.model.IamAccount;
 import it.infn.mw.iam.persistence.model.IamAup;
@@ -72,18 +72,18 @@ public class AupSignatureController {
   private final AccountUtils accountUtils;
   private final IamAupSignatureRepository signatureRepo;
   private final IamAupRepository aupRepo;
-  private final TimeProvider timeProvider;
+  private final Clock clock;
   private final ApplicationEventPublisher eventPublisher;
   private final NotificationFactory notificationFactory;
 
   public AupSignatureController(AupSignatureConverter conv, AccountUtils utils,
-      IamAupSignatureRepository signatureRepo, IamAupRepository aupRepo, TimeProvider timeProvider,
+      IamAupSignatureRepository signatureRepo, IamAupRepository aupRepo, Clock clock,
       ApplicationEventPublisher publisher, NotificationFactory notificationFactory) {
     this.signatureConverter = conv;
     this.accountUtils = utils;
     this.signatureRepo = signatureRepo;
     this.aupRepo = aupRepo;
-    this.timeProvider = timeProvider;
+    this.clock = clock;
     this.eventPublisher = publisher;
     this.notificationFactory = notificationFactory;
   }
@@ -109,7 +109,7 @@ public void signAup() throws AccountNotFoundException {
     IamAccount account = accountUtils.getAuthenticatedUserAccount()
       .orElseThrow(accountNotFoundException(ACCOUNT_NOT_FOUND_FOR_AUTHENTICATED_USER_MESSAGE));
 
-    Date now = new Date(timeProvider.currentTimeMillis());
+    Date now = Date.from(clock.instant());
     IamAupSignature signature = signatureRepo.createSignatureForAccount(aup, account, now);
     eventPublisher.publishEvent(new AupSignedEvent(this, signature));
   }
@@ -156,7 +156,7 @@ public AupSignatureDTO updateSignatureForAccount(@PathVariable String accountId,
     IamAup aup = aupRepo.findDefaultAup().orElseThrow(aupNotFoundException());
 
     Date signatureTime =
-        dto == null ? new Date(timeProvider.currentTimeMillis()) : dto.getSignatureTime();
+        dto == null ? Date.from(clock.instant()) : dto.getSignatureTime();
     IamAupSignature signature =
         signatureRepo.createSignatureForAccount(aup, account, signatureTime);
 

iam-login-service/src/main/java/it/infn/mw/iam/api/aup/AupSignaturePageController.java

@@ -20,6 +20,7 @@
 import static java.util.Objects.isNull;
 import static java.util.Optional.ofNullable;
 
+import java.time.Clock;
 import java.util.Date;
 import java.util.Optional;
 
@@ -41,7 +42,6 @@
 import it.infn.mw.iam.api.account.AccountUtils;
 import it.infn.mw.iam.api.common.ErrorDTO;
 import it.infn.mw.iam.audit.events.aup.AupSignedEvent;
-import it.infn.mw.iam.core.time.TimeProvider;
 import it.infn.mw.iam.persistence.model.IamAccount;
 import it.infn.mw.iam.persistence.model.IamAup;
 import it.infn.mw.iam.persistence.model.IamAupSignature;
@@ -56,16 +56,16 @@ public class AupSignaturePageController {
   final IamAupRepository repo;
   final IamAupSignatureRepository signatureRepo;
   final AccountUtils accountUtils;
-  final TimeProvider timeProvider;
+  final Clock clock;
   final ApplicationEventPublisher publisher;
 
   public AupSignaturePageController(IamAupRepository aupRepo,
-      IamAupSignatureRepository aupSignatureRepo, AccountUtils accountUtils,
-      TimeProvider timeProvider, ApplicationEventPublisher publisher) {
+      IamAupSignatureRepository aupSignatureRepo, AccountUtils accountUtils, Clock clock,
+      ApplicationEventPublisher publisher) {
     this.repo = aupRepo;
     this.signatureRepo = aupSignatureRepo;
     this.accountUtils = accountUtils;
-    this.timeProvider = timeProvider;
+    this.clock = clock;
     this.publisher = publisher;
   }
 
@@ -112,9 +112,10 @@ public ModelAndView signAup(HttpServletRequest request, HttpServletResponse resp
     }
 
     if (aup.isPresent()) {
-      Date now = new Date(timeProvider.currentTimeMillis());
-      IamAccount account = accountUtils.getAuthenticatedUserAccount().orElseThrow(
-          () -> new IllegalStateException("No iam account found for authenticated user"));
+      Date now = Date.from(clock.instant());
+      IamAccount account = accountUtils.getAuthenticatedUserAccount()
+        .orElseThrow(
+            () -> new IllegalStateException("No iam account found for authenticated user"));
 
       IamAupSignature signature = signatureRepo.createSignatureForAccount(aup.get(), account, now);
 

iam-login-service/src/main/java/it/infn/mw/iam/api/aup/DefaultAupService.java

@@ -15,10 +15,10 @@
  */
 package it.infn.mw.iam.api.aup;
 
+import java.time.Clock;
 import java.util.Date;
 import java.util.Optional;
 
-import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.ApplicationEventPublisher;
 import org.springframework.stereotype.Service;
 
@@ -28,7 +28,6 @@
 import it.infn.mw.iam.audit.events.aup.AupCreatedEvent;
 import it.infn.mw.iam.audit.events.aup.AupDeletedEvent;
 import it.infn.mw.iam.audit.events.aup.AupUpdatedEvent;
-import it.infn.mw.iam.core.time.TimeProvider;
 import it.infn.mw.iam.persistence.model.IamAup;
 import it.infn.mw.iam.persistence.repository.IamAupRepository;
 import it.infn.mw.iam.persistence.repository.IamAupSignatureRepository;
@@ -40,16 +39,15 @@ public class DefaultAupService implements AupService {
   private final IamAupSignatureRepository signatureRepo;
   private final AupConverter converter;
 
-  private final TimeProvider timeProvider;
+  private final Clock clock;
   private final ApplicationEventPublisher eventPublisher;
 
-  @Autowired
   public DefaultAupService(IamAupRepository repo, IamAupSignatureRepository signatureRepo,
-      AupConverter converter, TimeProvider timeProvider, ApplicationEventPublisher eventPublisher) {
+      AupConverter converter, Clock clock, ApplicationEventPublisher eventPublisher) {
     this.repo = repo;
     this.signatureRepo = signatureRepo;
     this.converter = converter;
-    this.timeProvider = timeProvider;
+    this.clock = clock;
     this.eventPublisher = eventPublisher;
   }
 
@@ -60,10 +58,9 @@ public Optional<IamAup> findAup() {
 
   @Override
   public IamAup saveAup(AupDTO aupDto) {
-    IamAup aup = converter.entityFromDto(aupDto);
-    long currentTimeMillis = timeProvider.currentTimeMillis();
 
-    Date now = new Date(currentTimeMillis);
+    IamAup aup = converter.entityFromDto(aupDto);
+    Date now = Date.from(clock.instant());
     aup.setCreationTime(now);
     aup.setLastUpdateTime(now);
 
@@ -105,8 +102,7 @@ public IamAup updateAup(AupDTO aupDto) {
   @Override
   public IamAup touchAup() {
 
-    long currentTimeMillis = timeProvider.currentTimeMillis();
-    Date now = new Date(currentTimeMillis);
+    Date now = Date.from(clock.instant());
 
     IamAup aup = repo.findDefaultAup().orElseThrow(AupNotFoundError::new);
 

iam-login-service/src/main/java/it/infn/mw/iam/api/client/management/service/DefaultClientManagementService.java

@@ -15,10 +15,14 @@
  */
 package it.infn.mw.iam.api.client.management.service;
 
+import static it.infn.mw.iam.api.client.util.ClientSuppliers.accountNotFound;
+import static it.infn.mw.iam.api.client.util.ClientSuppliers.clientNotFound;
+
 import java.text.ParseException;
 import java.time.Clock;
 import java.util.Date;
 import java.util.List;
+import java.util.Objects;
 import java.util.Optional;
 import java.util.stream.Collectors;
 
@@ -32,6 +36,7 @@
 import org.springframework.data.domain.Pageable;
 import org.springframework.security.oauth2.common.exceptions.InvalidRequestException;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
 import org.springframework.validation.annotation.Validated;
 
 import it.infn.mw.iam.api.client.management.validation.OnClientCreation;
@@ -40,8 +45,6 @@
 import it.infn.mw.iam.api.client.service.ClientDefaultsService;
 import it.infn.mw.iam.api.client.service.ClientService;
 import it.infn.mw.iam.api.client.util.ClientSuppliers;
-import static it.infn.mw.iam.api.client.util.ClientSuppliers.accountNotFound;
-import static it.infn.mw.iam.api.client.util.ClientSuppliers.clientNotFound;
 import it.infn.mw.iam.api.common.ListResponseDTO;
 import it.infn.mw.iam.api.common.PagingUtils;
 import it.infn.mw.iam.api.common.client.RegisteredClientDTO;
@@ -62,6 +65,7 @@
 
 @Service
 @Validated
+@Transactional
 public class DefaultClientManagementService implements ClientManagementService {
 
   private final Clock clock;
@@ -233,6 +237,7 @@ public ListResponseDTO<ScimUser> getClientOwners(String clientId, Pageable pagea
 
   @Override
   public void assignClientOwner(String clientId, String accountId) {
+
     ClientDetailsEntity client =
         clientService.findClientByClientId(clientId).orElseThrow(clientNotFound(clientId));
     IamAccount account = accountRepo.findByUuid(accountId).orElseThrow(accountNotFound(accountId));
@@ -243,6 +248,7 @@ public void assignClientOwner(String clientId, String accountId) {
 
   @Override
   public void removeClientOwner(String clientId, String accountId) {
+
     ClientDetailsEntity client =
         clientService.findClientByClientId(clientId).orElseThrow(clientNotFound(clientId));
     IamAccount account = accountRepo.findByUuid(accountId).orElseThrow(accountNotFound(accountId));
@@ -254,19 +260,22 @@ public void removeClientOwner(String clientId, String accountId) {
 
   private OAuth2AccessTokenEntity createRegistrationAccessTokenForClient(
       ClientDetailsEntity client) {
+
     OAuth2AccessTokenEntity token = oidcTokenService.createRegistrationAccessToken(client);
     return tokenService.saveAccessToken(token);
 
   }
 
   @Override
   public RegisteredClientDTO rotateRegistrationAccessToken(@NotBlank String clientId) {
+
     ClientDetailsEntity client =
         clientService.findClientByClientId(clientId).orElseThrow(clientNotFound(clientId));
 
-    OAuth2AccessTokenEntity rat =
-        Optional.ofNullable(oidcTokenService.rotateRegistrationAccessTokenForClient(client))
-          .orElse(createRegistrationAccessTokenForClient(client));
+    OAuth2AccessTokenEntity rat = oidcTokenService.rotateRegistrationAccessTokenForClient(client);
+    if (Objects.isNull(rat)) {
+      rat = createRegistrationAccessTokenForClient(client);
+    }
 
     tokenService.saveAccessToken(rat);