Merge remote-tracking branch 'refs/remotes/origin/main' into navramov_MM

# Conflicts:
#	bellatrix.web/src/main/java/solutions/bellatrix/web/components/shadowdom/ShadowDomService.java

Author: NikolayAvramov

bellatrix.core/src/main/java/solutions/bellatrix/core/configuration/ConfigurationService.java

@@ -86,4 +86,4 @@ public static String getFileAsString(String fileName) {
             return "";
         }
     }
-}
+}

bellatrix.core/src/main/java/solutions/bellatrix/core/utilities/ObjectFactory.java

@@ -22,11 +22,15 @@
 public abstract class ObjectFactory {
     protected static <T> T newInstance(Class<T> clazz, Object... args) throws InvocationTargetException, InstantiationException, IllegalAccessException, ConstructorNotFoundException {
         Constructor<T> suitableConstructor = getSuitableConstructor(clazz, args);
-
-        if (suitableConstructor.isVarArgs() && args.length < suitableConstructor.getParameterCount()) {
-            return (T)suitableConstructor.newInstance(addNullVarArgsTo(args));
-        } else
-            return (T)suitableConstructor.newInstance(args);
+        try {
+            if (suitableConstructor.isVarArgs() && args.length < suitableConstructor.getParameterCount()) {
+                return (T)suitableConstructor.newInstance(addNullVarArgsTo(args));
+            } else
+                return (T)suitableConstructor.newInstance(args);
+        } catch (Exception e) {
+            var exception = (InvocationTargetException)e;
+            throw new InvocationTargetException(exception.getTargetException());
+        }
     }
 
     private static Object[] addNullVarArgsTo(Object... args) {
@@ -37,8 +41,12 @@ private static <T> Constructor<T> getSuitableConstructor(Class<T> clazz, Object[
         var argumentTypes = getArgumentTypes(arguments);
 
         try {
-            return (Constructor<T>)findConstructorMatch(clazz, argumentTypes);
+            return findConstructorMatch(clazz, argumentTypes);
         } catch (NoSuchMethodException e) {
+            if (argumentTypes == null || argumentTypes.length == 0) {
+                throw new ConstructorNotFoundException();
+            }
+
             var types = new StringBuilder();
             for (var type : argumentTypes) {
                 types.append(type.getName() + System.lineSeparator());
@@ -73,7 +81,7 @@ private static <T> Constructor<T> findVarArgsConstructor(Class clazz, Class[] ar
             args[args.length - 1] = getVarArgsType(clazz, argumentTypes);
 
             return clazz.getDeclaredConstructor(args);
-        } catch (NoSuchMethodException ignored) {
+        } catch (NoSuchMethodException | NullPointerException ignored) {
         }
 
         throw new NoSuchMethodException("No matching constructor found for the provided argument types.");
@@ -97,7 +105,7 @@ private static boolean lengthMatches(Parameter[] parameters, Class[] argumentTyp
     }
 
     private static boolean parameterTypesMatch(Parameter[] parameters, Class[] argumentTypes) {
-        for (int i = 0; i < argumentTypes.length; i ++) {
+        for (int i = 0; i < argumentTypes.length; i++) {
             if (!parameters[i].getType().equals(argumentTypes[i]))
                 return false;
         }
@@ -113,7 +121,9 @@ public ConstructorNotFoundException(int numberOfTypes, String types) {
                     Given argument types:\n%s
                     """).formatted(numberOfTypes, types));
         }
+
         public ConstructorNotFoundException() {
+            super("No default constructor was found." + System.lineSeparator());
         }
 
         public ConstructorNotFoundException(String message) {
@@ -132,4 +142,4 @@ public ConstructorNotFoundException(String message, Throwable cause, boolean ena
             super(message, cause, enableSuppression, writableStackTrace);
         }
     }
-}
+}

bellatrix.core/src/main/java/solutions/bellatrix/core/utilities/SingletonFactory.java

@@ -38,9 +38,12 @@ public static <T> T getInstance(Class<T> classOf, Object... initargs) {
     private static <T> T tryGetInstance(Class<T> classOf, Object... initargs) {
         try {
             return newInstance(classOf, initargs);
-        } catch (InvocationTargetException | InstantiationException | IllegalAccessException |
+        } catch (InvocationTargetException e) {
+            Log.error(e.getTargetException().getMessage(), e);
+            return null;
+        } catch (InstantiationException | IllegalAccessException |
                  ConstructorNotFoundException e) {
-            Log.error("Failed to create instance of the class %s.\nException was:\n%s".formatted(classOf.getName(), e));
+            Log.error("Failed to create instance of the class %s.\nException was:\n%s".formatted(classOf.getName(), e.getMessage()));
             return null;
         }
     }
@@ -62,8 +65,8 @@ public static boolean containsKey(Class<?> classOf) {
     public static boolean containsValue(Object object) {
         return mapHolder.get().containsValue(object);
     }
-    
+
     public static void clear() {
         mapHolder.get().clear();
     }
-}
+}

bellatrix.data/pom.xml

@@ -0,0 +1,48 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>solutions.bellatrix</groupId>
+        <artifactId>bellatrix</artifactId>
+        <version>1.0-SNAPSHOT</version>
+    </parent>
+
+    <artifactId>bellatrix.data</artifactId>
+
+    <properties>
+        <maven.compiler.source>19</maven.compiler.source>
+        <maven.compiler.target>19</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <rest.assured.version>5.5.5</rest.assured.version>
+        <gson.version>2.13.1</gson.version>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.google.code.gson</groupId>
+            <artifactId>gson</artifactId>
+            <version>${gson.version}</version>
+            <scope>compile</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <version>${lombok.version}</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>solutions.bellatrix</groupId>
+            <artifactId>bellatrix.core</artifactId>
+            <version>1.0</version>
+            <scope>compile</scope>
+        </dependency>
+        <dependency>
+            <groupId>io.rest-assured</groupId>
+            <artifactId>rest-assured</artifactId>
+            <version>${rest.assured.version}</version>
+            <scope>compile</scope>
+        </dependency>
+    </dependencies>
+</project>

bellatrix.data/src/main/java/solutions/bellatrix/data/configuration/DataSettings.java

@@ -0,0 +1,13 @@
+package solutions.bellatrix.data.configuration;
+
+import com.google.gson.annotations.SerializedName;
+import lombok.Data;
+import solutions.bellatrix.data.http.configuration.HttpSettings;
+
+@Data
+public class DataSettings {
+    @SerializedName("dataSourceType")
+    private String datasourceType;
+    @SerializedName("httpSettings")
+    private HttpSettings httpSettings;
+}

bellatrix.data/src/main/java/solutions/bellatrix/data/configuration/RepositoryFactory.java

@@ -0,0 +1,29 @@
+package solutions.bellatrix.data.configuration;
+
+import solutions.bellatrix.core.utilities.SingletonFactory;
+import solutions.bellatrix.data.contracts.Repository;
+import solutions.bellatrix.data.http.infrastructure.Entity;
+
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.ConcurrentHashMap;
+
+public enum RepositoryFactory {
+    INSTANCE;
+
+    private final Map<Class<? extends Entity>, Class<? extends Repository>> repositories = new ConcurrentHashMap<>();
+
+    public <T extends Entity> void registerRepository(Class<T> entityClass, Class<? extends Repository<T>> repositoryClass) {
+        repositories.put(entityClass, repositoryClass);
+    }
+
+    public <T extends Entity> Repository<T> getRepository(Class<T> entityClass) {
+        var repositoryClassType = repositories.get(entityClass);
+
+        if (Objects.isNull(repositoryClassType)) {
+            throw new IllegalArgumentException("No repository registered for entity class: " + entityClass.getName());
+        }
+
+        return (Repository<T>)SingletonFactory.getInstance(repositoryClassType);
+    }
+}

bellatrix.data/src/main/java/solutions/bellatrix/data/contracts/Repository.java

@@ -0,0 +1,17 @@
+package solutions.bellatrix.data.contracts;
+
+import solutions.bellatrix.data.http.infrastructure.Entity;
+
+import java.util.List;
+
+public interface Repository<T extends Entity> {
+    T getById(T entity);
+
+    List<T> getAll();
+
+    T create(T entity);
+
+    T update(T entity);
+
+    void delete(T entity);
+}

bellatrix.data/src/main/java/solutions/bellatrix/data/http/authentication/AuthSchemaFactory.java

@@ -0,0 +1,39 @@
+package solutions.bellatrix.data.http.authentication;
+
+import io.restassured.authentication.AuthenticationScheme;
+import io.restassured.authentication.BasicAuthScheme;
+import io.restassured.authentication.NoAuthScheme;
+import io.restassured.authentication.PreemptiveOAuth2HeaderScheme;
+
+public class AuthSchemaFactory {
+    public static AuthenticationScheme getAuthenticationScheme(Authentication authentication) {
+        var authType = authentication.getAuthenticationMethod();
+        var option = authentication.getAuthenticationOptions().stream().filter(x -> x.get("type").equals(authType.getMethod())).findFirst();
+        if (option.isEmpty()) {
+            throw new IllegalArgumentException("Authentication type not found: %s, Supported types : ".formatted(authType));
+        }
+
+        switch (authType) {
+            case BASIC -> {
+                var basicAuth = option.get();
+                String username = basicAuth.get("username").toString();
+                String password = basicAuth.get("password").toString();
+                var basicSchema = new BasicAuthScheme();
+                basicSchema.setUserName(username);
+                basicSchema.setPassword(password);
+                return basicSchema;
+            }
+            case BEARER -> {
+                var bearerAuth = option.get();
+                String token = bearerAuth.get("token").toString();
+                var bearerSchema = new PreemptiveOAuth2HeaderScheme();
+                bearerSchema.setAccessToken(token);
+                return bearerSchema;
+            }
+            case QUERY_PARAMETER -> {
+                return new NoAuthScheme();
+            }
+            default -> throw new IllegalArgumentException("Unsupported authentication type: %s".formatted(authType));
+        }
+    }
+}

bellatrix.data/src/main/java/solutions/bellatrix/data/http/authentication/Authentication.java

@@ -0,0 +1,24 @@
+package solutions.bellatrix.data.http.authentication;
+
+import com.google.gson.annotations.SerializedName;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.LinkedHashMap;
+import java.util.LinkedList;
+
+public class Authentication {
+    @SerializedName("method")
+    private String method;
+    @SerializedName("options")
+    @Getter private LinkedList<LinkedHashMap<String, Object>> authenticationOptions;
+
+    @Setter(AccessLevel.PRIVATE)
+    private transient AuthenticationMethod authenticationMethod;
+
+    public AuthenticationMethod getAuthenticationMethod() {
+        setAuthenticationMethod(AuthenticationMethod.parse(method));
+        return authenticationMethod;
+    }
+}

bellatrix.data/src/main/java/solutions/bellatrix/data/http/authentication/AuthenticationMethod.java

@@ -0,0 +1,27 @@
+package solutions.bellatrix.data.http.authentication;
+
+import lombok.Getter;
+
+@Getter
+public enum AuthenticationMethod {
+    BEARER("Bearer"),
+    BASIC("Basic"),
+    QUERY_PARAMETER("QueryParameters");
+
+    private final String method;
+
+    AuthenticationMethod(String method) {
+        this.method = method;
+    }
+
+    public static AuthenticationMethod parse(String y) {
+        for (var state : values()) {
+            String enumDisplayValue = state.getMethod();
+            if (enumDisplayValue != null && enumDisplayValue.equalsIgnoreCase(y)) {
+                return state;
+            }
+        }
+
+        throw new IllegalArgumentException("No enum constant with value: %s".formatted(y));
+    }
+}