feat: restore dry run

dbaas/dbaas-aggregator/src/main/java/com/netcracker/cloud/dbaas/controller/error/OperationAlreadyRunningExceptionMapper.java

@@ -0,0 +1,22 @@
+package com.netcracker.cloud.dbaas.controller.error;
+
+import com.netcracker.cloud.dbaas.exceptions.OperationAlreadyRunningException;
+import jakarta.ws.rs.core.Context;
+import jakarta.ws.rs.core.Response;
+import jakarta.ws.rs.core.UriInfo;
+import jakarta.ws.rs.ext.ExceptionMapper;
+import jakarta.ws.rs.ext.Provider;
+
+import static com.netcracker.cloud.dbaas.controller.error.Utils.buildDefaultResponse;
+
+@Provider
+public class OperationAlreadyRunningExceptionMapper implements ExceptionMapper<OperationAlreadyRunningException> {
+
+    @Context
+    UriInfo uriInfo;
+
+    @Override
+    public Response toResponse(OperationAlreadyRunningException e) {
+        return buildDefaultResponse(uriInfo, e, Response.Status.CONFLICT);
+    }
+}

dbaas/dbaas-aggregator/src/main/java/com/netcracker/cloud/dbaas/converter/ClassifierConverter.java

@@ -3,8 +3,8 @@
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.databind.ObjectMapper;
-
 import jakarta.persistence.AttributeConverter;
+
 import java.io.IOException;
 import java.util.SortedMap;
 
@@ -24,7 +24,8 @@ public String convertToDatabaseColumn(SortedMap<Object, Object> attribute) {
     @Override
     public SortedMap<Object, Object> convertToEntityAttribute(String dbData) {
         try {
-            return objectMapper.readValue(dbData, new TypeReference<SortedMap<Object, Object>>() {});
+            return objectMapper.readValue(dbData, new TypeReference<SortedMap<Object, Object>>() {
+            });
         } catch (IOException e) {
             throw new RuntimeException(e);
         }

dbaas/dbaas-aggregator/src/main/java/com/netcracker/cloud/dbaas/dao/jpa/DatabaseRegistryDbaasRepositoryImpl.java

@@ -1,5 +1,6 @@
 package com.netcracker.cloud.dbaas.dao.jpa;
 
+import com.netcracker.cloud.dbaas.dto.backupV2.Filter;
 import com.netcracker.cloud.dbaas.entity.pg.Database;
 import com.netcracker.cloud.dbaas.entity.pg.DatabaseRegistry;
 import com.netcracker.cloud.dbaas.repositories.dbaas.DatabaseRegistryDbaasRepository;
@@ -12,23 +13,18 @@
 import jakarta.persistence.EntityManager;
 import jakarta.transaction.Transactional;
 import lombok.extern.slf4j.Slf4j;
-
 import net.jodah.failsafe.Failsafe;
 import net.jodah.failsafe.RetryPolicy;
 import org.apache.commons.lang.StringUtils;
 
+import javax.annotation.Nullable;
 import java.time.Duration;
 import java.util.*;
 import java.util.concurrent.Callable;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 
-import javax.annotation.Nullable;
-
-import static com.netcracker.cloud.dbaas.Constants.MICROSERVICE_NAME;
-import static com.netcracker.cloud.dbaas.Constants.ROLE;
-import static com.netcracker.cloud.dbaas.Constants.SCOPE;
-import static com.netcracker.cloud.dbaas.Constants.SCOPE_VALUE_TENANT;
+import static com.netcracker.cloud.dbaas.Constants.*;
 import static com.netcracker.cloud.dbaas.config.ServicesConfig.DBAAS_REPOSITORIES_MUTEX;
 import static jakarta.transaction.Transactional.TxType.REQUIRES_NEW;
 
@@ -141,6 +137,11 @@ public List<DatabaseRegistry> findAllTransactionalDatabaseRegistries(String name
         return databaseRegistryRepository.findAllByNamespaceAndDatabase_BgVersionNull(namespace);
     }
 
+    @Override
+    public List<DatabaseRegistry> findAllDatabasesByFilter(List<Filter> filters) {
+        return databaseRegistryRepository.findAllDatabasesByFilter(filters);
+    }
+
     @Override
     public void delete(DatabaseRegistry databaseRegistry) {
         log.debug("Delete logical database with classifier {} and type {}", databaseRegistry.getClassifier(), databaseRegistry.getType());

dbaas/dbaas-aggregator/src/main/java/com/netcracker/cloud/dbaas/dto/backupV2/BackupDatabaseResponse.java

@@ -11,11 +11,18 @@
 import java.util.List;
 import java.util.Map;
 import java.util.SortedMap;
+import java.util.UUID;
 
 @Data
 @AllArgsConstructor
 @Schema(description = "Logical database backup details")
 public class BackupDatabaseResponse {
+    @Schema(
+            description = "Identifier of the backup database",
+            examples = {"550e8400-e29b-41d4-a716-446655440000"},
+            required = true
+    )
+    private UUID id;
     @Schema(
             description = "Name of the database",
             examples = {
@@ -31,12 +38,12 @@ public class BackupDatabaseResponse {
     private List<SortedMap<String, Object>> classifiers;
     @Schema(
             description = "Database settings as a key-value map",
-            examples = "{\"key\":value, \"key\":value}"
+            examples = "{\"key\": \"value\", \"key\": \"value\"}"
     )
     private Map<String, Object> settings;
     @Schema(
             description = "List of database users",
-            examples = "[{\"name\":\"username\",\"role\":\"admin\"}"
+            examples = "[{\"name\":\"username\",\"role\":\"admin\"}]"
     )
     private List<User> users;
     @Schema(

dbaas/dbaas-aggregator/src/main/java/com/netcracker/cloud/dbaas/dto/backupV2/BackupExternalDatabaseResponse.java

@@ -6,11 +6,18 @@
 
 import java.util.List;
 import java.util.SortedMap;
+import java.util.UUID;
 
 @Data
 @NoArgsConstructor
 @Schema(description = "External database details")
 public class BackupExternalDatabaseResponse {
+    @Schema(
+            description = "Identifier of the external backup database",
+            examples = {"550e8400-e29b-41d4-a716-446655440000"},
+            required = true
+    )
+    private UUID id;
     @Schema(description = "Name of the external database", examples = "mydb", required = true)
     private String name;
     @Schema(

dbaas/dbaas-aggregator/src/main/java/com/netcracker/cloud/dbaas/dto/backupV2/BackupRequest.java

@@ -1,12 +1,11 @@
 package com.netcracker.cloud.dbaas.dto.backupV2;
 
 import com.netcracker.cloud.dbaas.enums.ExternalDatabaseStrategy;
-import com.netcracker.cloud.dbaas.utils.validation.BackupGroup;
+import com.netcracker.cloud.dbaas.utils.validation.group.BackupGroup;
 import jakarta.validation.Valid;
 import jakarta.validation.constraints.NotBlank;
 import jakarta.validation.constraints.NotNull;
 import jakarta.validation.groups.ConvertGroup;
-import jakarta.validation.groups.Default;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 import org.eclipse.microprofile.openapi.annotations.media.Schema;
@@ -17,7 +16,7 @@
 public class BackupRequest {
     @NotBlank
     @Schema(
-            description = "Unique identifier of the backup",
+            description = "Unique name of the backup",
             examples = {
                     "before-prod-update-20251013T1345-G5s8"
             },
@@ -45,7 +44,7 @@ public class BackupRequest {
     )
     @Valid
     @NotNull
-    @ConvertGroup(from = Default.class, to = BackupGroup.class)
+    @ConvertGroup(to = BackupGroup.class)
     private FilterCriteria filterCriteria;
     @Schema(
             description = "How to handle external databases during backup",

dbaas/dbaas-aggregator/src/main/java/com/netcracker/cloud/dbaas/dto/backupV2/BackupResponse.java

@@ -3,12 +3,11 @@
 import com.fasterxml.jackson.annotation.JsonIgnore;
 import com.netcracker.cloud.dbaas.enums.BackupStatus;
 import com.netcracker.cloud.dbaas.enums.ExternalDatabaseStrategy;
-import com.netcracker.cloud.dbaas.utils.validation.BackupGroup;
+import com.netcracker.cloud.dbaas.utils.validation.group.BackupGroup;
 import jakarta.validation.Valid;
 import jakarta.validation.constraints.NotBlank;
 import jakarta.validation.constraints.NotNull;
 import jakarta.validation.groups.ConvertGroup;
-import jakarta.validation.groups.Default;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 import org.eclipse.microprofile.openapi.annotations.enums.SchemaType;
@@ -21,32 +20,32 @@
 @Schema(description = "Response containing backup operation details")
 public class BackupResponse {
 
-    @NotBlank
     @Schema(
-            description = "Unique identifier of the backup",
+            description = "Unique name of the backup",
             examples = {
                     "before-prod-update-20251013T1345-G5s8"
             },
             required = true
     )
-    private String backupName;
     @NotBlank
+    private String backupName;
     @Schema(
             description = "Name of the storage backend containing the backup",
             examples = {
                     "s3-backend"
             },
             required = true
     )
-    private String storageName;
     @NotBlank
+    private String storageName;
     @Schema(
             description = "Path to the backup file in the storage",
             examples = {
                     "/backups"
             },
             required = true
     )
+    @NotBlank
     private String blobPath;
     @Schema(
             description = "How to handle external databases during backup",
@@ -57,20 +56,20 @@ public class BackupResponse {
     )
     @NotNull
     private ExternalDatabaseStrategy externalDatabaseStrategy;
-    @NotNull
     @Schema(
-            description = "Whether external databases were skipped during the backup",
+            description = "Whether non‑backupable databases were ignored during backup",
             examples = {
                     "false"
             }
     )
+    @NotNull
     private boolean ignoreNotBackupableDatabases;
     @Schema(
             description = "Filter criteria",
             implementation = FilterCriteria.class
     )
     @Valid
-    @ConvertGroup(from = Default.class, to = BackupGroup.class)
+    @ConvertGroup(to = BackupGroup.class)
     private FilterCriteria filterCriteria;
 
     @Schema(
@@ -84,20 +83,23 @@ public class BackupResponse {
                     "5"
             }
     )
+    @NotNull
     private Integer total;
     @Schema(
             description = "Number of databases successfully backed up",
             examples = {
                     "3"
             }
     )
+    @NotNull
     private Integer completed;
     @Schema(
             description = "Total size of the backup in bytes",
             examples = {
                     "1073741824"
             }
     )
+    @NotNull
     private Long size;
     @Schema(
             description = "Error details if the backup failed",

dbaas/dbaas-aggregator/src/main/java/com/netcracker/cloud/dbaas/dto/backupV2/ClassifierDetailsResponse.java

@@ -0,0 +1,45 @@
+package com.netcracker.cloud.dbaas.dto.backupV2;
+
+import com.netcracker.cloud.dbaas.enums.ClassifierType;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import org.eclipse.microprofile.openapi.annotations.media.Schema;
+
+import java.util.SortedMap;
+
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Schema(description = "Classifier details used during restore operation")
+public class ClassifierDetailsResponse {
+    @Schema(
+            description = "Type of classifier in restore context",
+            required = true,
+            implementation = ClassifierType.class
+    )
+    private ClassifierType type;
+
+    @Schema(
+            description = "Name of the existing database previously associated with this classifier," +
+                    " used when the classifier replaces or transiently replaces another database during restore",
+            nullable = true,
+            examples = {"dbaas_12345"}
+    )
+    private String previousDatabase;
+
+    @Schema(
+            description = "Final classifier used to create a database in the target environment.",
+            examples = "{\"namespace\":\"namespace\", \"microserviceName\":\"microserviceName\", \"scope\":\"service\"}",
+            required = true
+    )
+    private SortedMap<String, Object> classifier;
+
+    @Schema(
+            description = "Original (pre-mapping) classifier from backup database preserved " +
+                    "to track how mapping changed the classifier during restore",
+            examples = "{\"namespace\":\"namespace\", \"microserviceName\":\"microserviceName\", \"scope\":\"service\"}",
+            nullable = true
+    )
+    private SortedMap<String, Object> classifierBeforeMapper;
+}

dbaas/dbaas-aggregator/src/main/java/com/netcracker/cloud/dbaas/dto/backupV2/Filter.java

@@ -1,5 +1,8 @@
 package com.netcracker.cloud.dbaas.dto.backupV2;
 
+import com.netcracker.cloud.dbaas.utils.validation.NotEmptyFilter;
+import com.netcracker.cloud.dbaas.utils.validation.group.BackupGroup;
+import com.netcracker.cloud.dbaas.utils.validation.group.RestoreGroup;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 import org.eclipse.microprofile.openapi.annotations.enums.SchemaType;
@@ -9,6 +12,7 @@
 import java.util.List;
 
 @Data
+@NotEmptyFilter(groups = {BackupGroup.class, RestoreGroup.class})
 @NoArgsConstructor
 @Schema(description = "Single filter criteria for backup and restore operations")
 public class Filter {

dbaas/dbaas-aggregator/src/main/java/com/netcracker/cloud/dbaas/dto/backupV2/FilterCriteria.java

@@ -1,35 +1,34 @@
 package com.netcracker.cloud.dbaas.dto.backupV2;
 
-import com.netcracker.cloud.dbaas.utils.validation.BackupGroup;
+import com.netcracker.cloud.dbaas.utils.validation.group.BackupGroup;
+import jakarta.validation.Valid;
 import jakarta.validation.constraints.NotNull;
 import jakarta.validation.constraints.Size;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 import org.eclipse.microprofile.openapi.annotations.media.Schema;
 
+import java.util.ArrayList;
 import java.util.List;
 
 @Data
 @NoArgsConstructor
 @Schema(description = "Group of filters for backup and restore operations. Filters are applied in the following order:\n" +
         "\n" +
-        "1. `filter`: Apply the filter to the databases.\n" +
-        "2. `include`: Include databases that match any of the filters in the list.\n" +
-        "3. `exclude`: Exclude databases that match any of the filters in the list.")
+        "1. `include`\n" +
+        "2. `exclude`")
 public class FilterCriteria {
-    @Schema(
-            description = "Apply the filter to the remaining databases",
-            required = true
-    )
-    @NotNull(groups = {BackupGroup.class})
-    @Size(min = 1, groups = {BackupGroup.class})
-    private List<Filter> filter;
     @Schema(
             description = "Include databases that match any of the filters in the list"
     )
-    private List<Filter> include;
+    @NotNull(groups = {BackupGroup.class})
+    @Size(min = 1, groups = {BackupGroup.class}, message = "there should be at least one filter specified")
+    @Valid
+    private List<Filter> include = new ArrayList<>();
+
     @Schema(
             description = "Exclude databases that match any of the filters in the list"
     )
-    private List<Filter> exclude;
+    @Valid
+    private List<Filter> exclude = new ArrayList<>();
 }