Merge Snapshot 10.3 branch changes to develop

sdm/src/main/java/com/sap/cds/sdm/handler/TokenHandler.java

@@ -56,24 +56,35 @@ public String toString(byte[] bytes) {
   }
 
   public SDMCredentials getSDMCredentials() {
+    logger.debug("START: getSDMCredentials - loading SDM credentials from service binding");
     Map<String, Object> uaaCredentials = getUaaCredentials();
     Map<String, Object> uaa = (Map<String, Object>) uaaCredentials.get("uaa");
     SDMCredentials sdmCredentials = new SDMCredentials();
     sdmCredentials.setBaseTokenUrl(uaa.get("url").toString());
     sdmCredentials.setUrl(uaaCredentials.get("uri").toString());
     sdmCredentials.setClientId(uaa.get("clientid").toString());
     sdmCredentials.setClientSecret(uaa.get("clientsecret").toString());
+    logger.debug("END: getSDMCredentials - SDM URL: {}", sdmCredentials.getUrl());
     return sdmCredentials;
   }
 
   public Map<String, Object> getUaaCredentials() {
+    logger.debug("START: getUaaCredentials - scanning service bindings for 'sdm' tag");
     List<ServiceBinding> allServiceBindings =
         DefaultServiceBindingAccessor.getInstance().getServiceBindings();
+    logger.debug("Total service bindings found: {}", allServiceBindings.size());
     ServiceBinding sdmBinding =
         allServiceBindings.stream()
             .filter(binding -> binding.getTags().contains("sdm"))
             .findFirst()
-            .orElseThrow(() -> new IllegalStateException("SDM binding not found"));
+            .orElseThrow(
+                () -> {
+                  logger.error(
+                      "No service binding with 'sdm' tag found among {} bindings",
+                      allServiceBindings.size());
+                  return new IllegalStateException("SDM binding not found");
+                });
+    logger.debug("END: getUaaCredentials - SDM binding found");
     return sdmBinding.getCredentials();
   }
 
@@ -83,37 +94,55 @@ public HttpClient getHttpClient(
       String subdomain,
       String type) {
 
+    logger.debug(
+        "START: getHttpClient - type: {}, subdomain: {}, connectionPoolConfig: {}",
+        type,
+        subdomain,
+        connectionPoolConfig != null ? "configured" : "null(using defaults)");
+
     Map<String, Object> uaaCredentials;
     if (binding != null && !binding.getCredentials().isEmpty()) {
+      logger.debug("getHttpClient - using credentials from provided ServiceBinding");
       uaaCredentials = binding.getCredentials();
     } else {
+      logger.debug(
+          "getHttpClient - binding not provided or empty, fetching from service binding registry");
       uaaCredentials = getUaaCredentials();
     }
 
     Map<String, Object> uaa = (Map<String, Object>) uaaCredentials.get("uaa");
 
     ClientCredentials clientCredentials =
         new ClientCredentials(uaa.get(CLIENT_ID).toString(), uaa.get(CLIENT_SECRET).toString());
+    logger.debug("getHttpClient - clientId: {}", uaa.get(CLIENT_ID).toString());
 
     String baseTokenUrl = uaa.get(SDM_TOKEN_ENDPOINT).toString();
+    logger.debug("getHttpClient - base token URL: {}", baseTokenUrl);
     if (subdomain != null && !subdomain.isEmpty()) {
       String providerSubdomain =
           baseTokenUrl.substring(baseTokenUrl.indexOf("/") + 2, baseTokenUrl.indexOf("."));
       baseTokenUrl = baseTokenUrl.replace(providerSubdomain, subdomain);
+      logger.debug(
+          "getHttpClient - token URL adjusted for subdomain '{}': {}", subdomain, baseTokenUrl);
     }
 
+    String sdmTargetUrl = uaaCredentials.get(SDM_URL).toString();
+    logger.debug("getHttpClient - SDM target URL: {}", sdmTargetUrl);
+
     DefaultHttpDestination destination;
     if (NAMED_USER_FLOW.equals(type)) {
+      logger.debug("getHttpClient - building NAMED_USER (token exchange) destination");
       destination =
-          OAuth2DestinationBuilder.forTargetUrl(uaaCredentials.get(SDM_URL).toString())
+          OAuth2DestinationBuilder.forTargetUrl(sdmTargetUrl)
               .withTokenEndpoint(baseTokenUrl)
               .withClient(clientCredentials, OnBehalfOf.NAMED_USER_CURRENT_TENANT)
               .property(
                   SDMConstants.SDM_DESTINATION_KEY, SDMConstants.SDM_TOKEN_EXCHANGE_DESTINATION)
               .build();
     } else {
+      logger.debug("getHttpClient - building TECHNICAL_USER (client credentials) destination");
       destination =
-          OAuth2DestinationBuilder.forTargetUrl(uaaCredentials.get(SDM_URL).toString())
+          OAuth2DestinationBuilder.forTargetUrl(sdmTargetUrl)
               .withTokenEndpoint(baseTokenUrl)
               .withClient(clientCredentials, OnBehalfOf.TECHNICAL_USER_CURRENT_TENANT)
               .property(
@@ -130,20 +159,36 @@ public HttpClient getHttpClient(
       builder.timeoutMilliseconds((int) timeout.toMillis());
       builder.maxConnectionsPerRoute(SDMConstants.MAX_CONNECTIONS);
       builder.maxConnectionsTotal(SDMConstants.MAX_CONNECTIONS);
+      logger.debug(
+          "getHttpClient - using default connection pool: timeout={}ms, maxConnPerRoute={},"
+              + " maxConnTotal={}",
+          timeout.toMillis(),
+          SDMConstants.MAX_CONNECTIONS,
+          SDMConstants.MAX_CONNECTIONS);
     } else {
       builder.timeoutMilliseconds((int) connectionPoolConfig.getTimeout().toMillis());
       builder.maxConnectionsPerRoute(connectionPoolConfig.getMaxConnectionsPerRoute());
       builder.maxConnectionsTotal(connectionPoolConfig.getMaxConnections());
+      logger.debug(
+          "getHttpClient - using configured connection pool: timeout={}ms, maxConnPerRoute={},"
+              + " maxConnTotal={}",
+          connectionPoolConfig.getTimeout().toMillis(),
+          connectionPoolConfig.getMaxConnectionsPerRoute(),
+          connectionPoolConfig.getMaxConnections());
     }
 
-    return builder.build().createHttpClient(destination);
+    HttpClient httpClient = builder.build().createHttpClient(destination);
+    logger.debug("END: getHttpClient - HttpClient created for type: {}", type);
+    return httpClient;
   }
 
   public HttpClient getHttpClientForAuthoritiesFlow(
       CdsProperties.ConnectionPool connectionPoolConfig, String user) {
 
+    logger.debug("START: getHttpClientForAuthoritiesFlow - user: {}", user);
     Optional<HttpDestination> destinations = getHttpDestination(user);
     if (destinations.isPresent()) {
+      logger.debug("getHttpClientForAuthoritiesFlow - HttpDestination resolved for user: {}", user);
       DefaultHttpClientFactory.DefaultHttpClientFactoryBuilder builder =
           DefaultHttpClientFactory.builder();
 
@@ -152,25 +197,40 @@ public HttpClient getHttpClientForAuthoritiesFlow(
         builder.timeoutMilliseconds((int) timeout.toMillis());
         builder.maxConnectionsPerRoute(SDMConstants.MAX_CONNECTIONS);
         builder.maxConnectionsTotal(SDMConstants.MAX_CONNECTIONS);
+        logger.debug(
+            "getHttpClientForAuthoritiesFlow - using default pool: timeout={}ms",
+            timeout.toMillis());
       } else {
         builder.timeoutMilliseconds((int) connectionPoolConfig.getTimeout().toMillis());
         builder.maxConnectionsPerRoute(connectionPoolConfig.getMaxConnectionsPerRoute());
         builder.maxConnectionsTotal(connectionPoolConfig.getMaxConnections());
+        logger.debug(
+            "getHttpClientForAuthoritiesFlow - using configured pool: timeout={}ms",
+            connectionPoolConfig.getTimeout().toMillis());
       }
 
-      return builder.build().createHttpClient(destinations.get());
+      HttpClient httpClient = builder.build().createHttpClient(destinations.get());
+      logger.debug("END: getHttpClientForAuthoritiesFlow - HttpClient created for user: {}", user);
+      return httpClient;
     }
+    logger.warn(
+        "getHttpClientForAuthoritiesFlow - no HttpDestination found for user: {},"
+            + " returning null",
+        user);
     return null;
   }
 
   private Optional<HttpDestination> getHttpDestination(String userName) {
+    logger.debug("START: getHttpDestination - resolving destination for user: {}", userName);
     HttpDestination httpDestination;
     try {
       httpDestination =
           ServiceBindingDestinationLoader.defaultLoaderChain()
               .getDestination(getSDMDestinationOptions(userName));
+      logger.debug("END: getHttpDestination - destination resolved for user: {}", userName);
     } catch (Exception exception) {
-      logger.error("Error with fetching httpdestination " + exception.getCause());
+      logger.error(
+          "Error with fetching httpdestination for user {}: {}", userName, exception.getCause());
       httpDestination = null;
     }
     return Optional.ofNullable(httpDestination);

sdm/src/main/java/com/sap/cds/sdm/handler/applicationservice/SDMReadAttachmentsHandler.java

@@ -133,95 +133,108 @@ public void processBefore(CdsReadEventContext context) throws IOException {
       return;
     }
     setErrorMessagesInCache(context);
-    if (context.getTarget().getAnnotationValue(SDMConstants.ANNOTATION_IS_MEDIA_DATA, false)) {
-      try {
-        // update the uploadStatus of all blank attachments with success this is for existing
-        // attachments
-        logger.debug("Target is a media entity, processing attachment logic");
-        RepoValue repoValue = checkRepositoryTypeWithFallback(repositoryId, context);
-
-        // Only process virus scan logic if repository info is available
-        if (repoValue != null) {
-          logger.debug(
-              "Repository value found. Async virus scan enabled: {}",
-              repoValue.getIsAsyncVirusScanEnabled());
-          Optional<CdsEntity> attachmentDraftEntity =
-              context.getModel().findEntity(context.getTarget().getQualifiedName() + "_drafts");
-          String upIdKey = "", upID = "";
-          if (attachmentDraftEntity.isPresent()) {
-            upIdKey = SDMUtils.getUpIdKey(attachmentDraftEntity.get());
-            CqnSelect select = (CqnSelect) context.get("cqn");
-            upID = SDMUtils.fetchUPIDFromCQN(select, attachmentDraftEntity.get());
-            logger.debug("Processing attachments for upID: {}", upID);
-
-            if (!repoValue.getIsAsyncVirusScanEnabled()) {
-              logger.debug("Sync virus scan mode: updating in-progress upload status to success");
-              dbQuery.updateInProgressUploadStatusToSuccess(
-                  attachmentDraftEntity.get(), persistenceService, upID, upIdKey);
-            }
-            if (repoValue.getIsAsyncVirusScanEnabled()) {
-              logger.debug("Async virus scan mode: processing virus scan in-progress attachments");
-              processVirusScanInProgressAttachments(context, upID, upIdKey);
-            }
-          }
-
-          // Get attachment associations to handle deep reads with expand
-          CdsModel cdsModel = context.getModel();
-          List<String> fieldNames =
-              getAttachmentAssociations(cdsModel, context.getTarget(), "", new ArrayList<>());
-          logger.debug("Found {} attachment associations", fieldNames.size());
-
-          // Create a combined modifier that handles both expand scenarios and repositoryId filter
-          final SDMBeforeReadItemsModifier itemsModifier =
-              new SDMBeforeReadItemsModifier(fieldNames);
-          final Predicate repositoryFilter =
-              CQL.or(CQL.get("repositoryId").eq(repositoryId), CQL.get("repositoryId").isNull());
-          logger.debug(
-              "Creating CQN modifier with {} field names and repository filter", fieldNames.size());
-
-          CqnSelect modifiedCqn =
-              CQL.copy(
-                  context.getCqn(),
-                  new Modifier() {
-                    @SuppressWarnings({"rawtypes", "unchecked"})
-                    @Override
-                    public List items(List items) {
-                      // Always handle items for expand scenarios
-                      return itemsModifier.items(items);
-                    }
-
-                    @Override
-                    public Predicate where(Predicate where) {
-                      // Always apply repositoryId filter for all reads
-                      if (where == null) {
-                        return repositoryFilter;
-                      }
-                      return CQL.and(where, repositoryFilter);
-                    }
-                  });
-          context.setCqn(modifiedCqn);
-          logger.debug("CQN query modified with repository filter and required fields");
-        } else {
-          logger.warn(
-              "Repository value is null for repository ID: {}. Proceeding with limited functionality",
-              repositoryId);
-          context.setCqn(context.getCqn());
-        }
-      } catch (Exception e) {
-        logger.error("Error in SDMReadAttachmentsHandler.processBefore: {}", e.getMessage(), e);
-        // Re-throw to maintain error handling behavior
-        throw e;
-      }
-
-    } else {
+    if (!SDMApplicationHandlerHelper.isMediaEntity(context.getTarget())) {
       logger.debug(
           "Target entity {} is not a media entity, skipping attachment processing",
           context.getTarget().getQualifiedName());
-      context.setCqn(context.getCqn());
+      return;
+    }
+    try {
+      logger.debug("Target is a media entity, processing attachment logic");
+      RepoValue repoValue = checkRepositoryTypeWithFallback(repositoryId, context);
+      if (repoValue != null) {
+        processMediaEntityRead(context, repositoryId, repoValue);
+      } else {
+        logger.warn(
+            "Repository value is null for repository ID: {}. Proceeding with limited functionality",
+            repositoryId);
+      }
+    } catch (Exception e) {
+      logger.error("Error in SDMReadAttachmentsHandler.processBefore: {}", e.getMessage(), e);
+      throw e;
     }
     logger.debug("END: Read attachments processing completed");
   }
 
+  private void processMediaEntityRead(
+      CdsReadEventContext context, String repositoryId, RepoValue repoValue) {
+    logger.debug(
+        "Repository value found. Async virus scan enabled: {}",
+        repoValue.getIsAsyncVirusScanEnabled());
+    Optional<CdsEntity> attachmentActiveEntity =
+        context.getModel().findEntity(context.getTarget().getQualifiedName());
+    logger.debug(
+        "Active entity: {}",
+        attachmentActiveEntity.isPresent()
+            ? attachmentActiveEntity.get().getQualifiedName()
+            : "No active entity");
+    Optional<CdsEntity> attachmentDraftEntity =
+        context
+            .getModel()
+            .findEntity(context.getTarget().getQualifiedName() + "_drafts")
+            .or(() -> attachmentActiveEntity);
+    logger.debug(
+        "Draft entity: {}",
+        attachmentDraftEntity.isPresent()
+            ? attachmentDraftEntity.get().getQualifiedName()
+            : "No draft entity");
+
+    if (attachmentDraftEntity.isPresent()) {
+      processUploadStatus(context, repoValue, attachmentDraftEntity.get());
+    }
+
+    List<String> fieldNames =
+        getAttachmentAssociations(context.getModel(), context.getTarget(), "", new ArrayList<>());
+    logger.debug("Found {} attachment associations", fieldNames.size());
+
+    CqnSelect modifiedCqn = buildModifiedCqn(context, repositoryId, fieldNames);
+    context.setCqn(modifiedCqn);
+    logger.debug("CQN query modified with repository filter and required fields");
+  }
+
+  private void processUploadStatus(
+      CdsReadEventContext context, RepoValue repoValue, CdsEntity attachmentEntity) {
+    String upIdKey = SDMUtils.getUpIdKey(attachmentEntity);
+    CqnSelect select = (CqnSelect) context.get("cqn");
+    String upID = SDMUtils.fetchUPIDFromCQN(select, attachmentEntity);
+    logger.debug("Processing attachments for upID: {}", upID);
+
+    if (!repoValue.getIsAsyncVirusScanEnabled()) {
+      logger.debug("Sync virus scan mode: updating in-progress upload status to success");
+      dbQuery.updateInProgressUploadStatusToSuccess(
+          attachmentEntity, persistenceService, upID, upIdKey);
+    } else {
+      logger.debug("Async virus scan mode: processing virus scan in-progress attachments");
+      processVirusScanInProgressAttachments(context, upID, upIdKey);
+    }
+  }
+
+  private CqnSelect buildModifiedCqn(
+      CdsReadEventContext context, String repositoryId, List<String> fieldNames) {
+    final SDMBeforeReadItemsModifier itemsModifier = new SDMBeforeReadItemsModifier(fieldNames);
+    final Predicate repositoryFilter =
+        CQL.or(CQL.get("repositoryId").eq(repositoryId), CQL.get("repositoryId").isNull());
+    logger.debug(
+        "Creating CQN modifier with {} field names and repository filter", fieldNames.size());
+    return CQL.copy(
+        context.getCqn(),
+        new Modifier() {
+          @SuppressWarnings({"rawtypes", "unchecked"})
+          @Override
+          public List items(List items) {
+            return itemsModifier.items(items);
+          }
+
+          @Override
+          public Predicate where(Predicate where) {
+            if (where == null) {
+              return repositoryFilter;
+            }
+            return CQL.and(where, repositoryFilter);
+          }
+        });
+  }
+
   /**
    * Recursively get all attachment associations in the entity tree. This is needed to properly
    * handle deep navigation like Books/covers with $expand=statusNav