Merged PR 77: pagination + filters exec list

src/main/java/com/olympus/hermione/controllers/ExecutionController.java

@@ -24,15 +24,4 @@ public class ExecutionController {
         return scenarioExecutionRepository.findById(id).get();
     }   
 
-    // @PostMapping("/updateRating")
-    // public String updateScenarioExecRating(@RequestBody ScenarioExecution scenarioExecution){
-    //    String result = scenarioExecutionService.updateRating2(scenarioExecution);
-    //     return result;
-    // }
-
-    @GetMapping("/updateRating")
-    public String updateScenarioExecRating(@RequestParam   String id, @RequestParam String rating){
-        String result = scenarioExecutionService.updateRating(id, rating);
-        return result;
-    }  
 }

src/main/java/com/olympus/hermione/controllers/ScenarioController.java

@@ -1,13 +1,22 @@
 package com.olympus.hermione.controllers;
 
+import java.net.URLDecoder;
+import java.nio.charset.StandardCharsets;
+import java.time.LocalDate;
 import java.util.List;
+import java.util.Map;
 
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.format.annotation.DateTimeFormat;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RestController;
 
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonMappingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
 import com.olympus.hermione.dto.ScenarioExecutionInput;
 import com.olympus.hermione.dto.ScenarioOutput;
 import com.olympus.hermione.models.Scenario;
@@ -20,6 +29,7 @@ import com.olympus.model.Application;
 import com.olympus.model.Project;
 
 import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestParam;
 
 @RestController
 public class ScenarioController {
@@ -33,6 +43,7 @@ public class ScenarioController {
     @Autowired
     ScenarioService scenarioService;
 
+
     @GetMapping("/scenarios")
     public Iterable<Scenario> getScenarios() {
         return scenarioRepository.findAll();
@@ -112,9 +123,11 @@ public class ScenarioController {
     return scenarioExecution;
 }
 
-        @GetMapping("/scenariosByUser")
+    @PostMapping("/executions")
-        public List<ScenarioExecution> getScenarioByUser() {
+    public Page<ScenarioExecution> getAdvancedExecutions(
-        return scenarioExecutionService.getListExecutionScenarioByUser();
+        @RequestBody Map<String, Object> allParams) { 
+
+        return scenarioExecutionService.getFilteredExecutions(allParams);
     }
 
     @GetMapping("/getScenariosForRE")
@@ -122,6 +135,10 @@ public class ScenarioController {
         return scenarioService.getListScenariosForRE();
     }
    
-
+    @GetMapping("/updateRating")
+    public String updateScenarioExecRating(@RequestParam   String id, @RequestParam String rating){
+        String result = scenarioService.updateRating(id, rating);
+        return result;
+    }  
 
 }

src/main/java/com/olympus/hermione/repository/ScenarioExecutionRepository.java

@@ -2,6 +2,8 @@ package com.olympus.hermione.repository;
 
 import java.util.List;
 
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
 import org.springframework.data.domain.Sort;
 import org.springframework.data.mongodb.repository.MongoRepository;
 import org.springframework.data.mongodb.repository.Query;
@@ -21,13 +23,30 @@ public interface ScenarioExecutionRepository extends MongoRepository<ScenarioExe
     @Query("{ $and: [ { 'executedByUserId': ?0 }, { 'scenarioExecutionInput.inputs.selected_project': ?1 }, { 'scenarioExecutionInput.inputs.selected_application': ?2 } ] }")
     List<ScenarioExecution> findByExecutedByUserIdAndInputs(String userId, String selectedProject, String selectedApplication);
 
-    @Query("{ $and: [ { 'executedByUserId': ?0 }, { 'scenarioExecutionInput.inputs.selected_project': ?1 }, { 'scenarioExecutionInput.inputs.selected_application': ?2 } ] }")
+    // @Query("{ $and: [ { 'executedByUserId': ?0 }, { 'scenarioExecutionInput.inputs.selected_project': ?1 }, { 'scenarioExecutionInput.inputs.selected_application': ?2 } ] }")
-    List<ScenarioExecution> getFromProjectAndAPP(String userId, String value1, String value2, Sort sort);
+    // List<ScenarioExecution> getFromProjectAndAPP(String userId, String value1, String value2, Sort sort);
-    //findByExecutedByUserIdAndInputsOrderByStartDateDesc
+    // //findByExecutedByUserIdAndInputsOrderByStartDateDesc
 
-    @Query("{ $and: [ { 'executedByUserId': ?0 }, { 'scenarioExecutionInput.inputs.selected_project': ?1 } ] }")
+    @Query("{ $and: [ { 'scenarioExecutionInput.inputs.selected_project': ?0 }, { 'scenarioExecutionInput.inputs.selected_application': ?1 } ] }")
-    List<ScenarioExecution> getFromProject(String userId, String value1, Sort sort);
+    Page<ScenarioExecution> getFromProjectAndAPP( String value1, String value2, Pageable pageable);
     
+    @Query("{ $and: [ "
+     + " { 'scenarioExecutionInput.inputs.selected_project': ?0 }, "
+     + " { 'scenarioExecutionInput.inputs.selected_application': ?1 }, "
+     + " { $or: [ { 'scenarioExecutionInput.inputs.optional_field': ?2 }, { 'scenarioExecutionInput.inputs.optional_field': { $exists: false } } ] } "
+     + "] }")
+    Page<ScenarioExecution> getFromProjectAndAPPOptional(
+    String value1, 
+    String value2, 
+    String optionalValue, 
+    Pageable pageable);
+
+
+    // @Query("{ $and: [ { 'executedByUserId': ?0 }, { 'scenarioExecutionInput.inputs.selected_project': ?1 } ] }")
+    // List<ScenarioExecution> getFromProject(String userId, String value1, Sort sort);
+
+    @Query("{ $and: [ { 'scenarioExecutionInput.inputs.selected_project': ?0 } ] }")
+    Page<ScenarioExecution> getFromProject( String value1, Pageable pageable);
 
 
 }

src/main/java/com/olympus/hermione/services/ScenarioExecutionService.java

@@ -4,14 +4,18 @@ import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.nio.file.Files;
+import java.time.LocalDate;
+import java.util.ArrayList;
 import java.util.Base64;
 import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.Optional;
 import java.util.OptionalInt;
 import java.util.stream.IntStream;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipOutputStream;
+import org.springframework.data.domain.PageRequest;
 
 import org.slf4j.LoggerFactory;
 import org.springframework.ai.azure.openai.AzureOpenAiChatModel;
@@ -29,7 +33,14 @@ import org.springframework.ai.vectorstore.VectorStore;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.cloud.client.discovery.DiscoveryClient;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageImpl;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
 import org.springframework.data.domain.Sort;
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.core.query.Query;
 import org.springframework.scheduling.annotation.Async;
 import org.springframework.security.core.context.SecurityContextHolder;
 import org.springframework.stereotype.Service;
@@ -46,6 +57,7 @@ import com.olympus.hermione.repository.ScenarioRepository;
 import com.olympus.hermione.security.entity.User;
 import com.olympus.hermione.stepSolvers.AdvancedAIPromptSolver;
 import com.olympus.hermione.stepSolvers.SummarizeDocSolver;
+import com.olympus.hermione.stepSolvers.TestExternalCodeGenieSolver;
 import com.olympus.hermione.stepSolvers.BasicAIPromptSolver;
 import com.olympus.hermione.stepSolvers.BasicQueryRagSolver;
 import com.olympus.hermione.stepSolvers.DeleteDocTempSolver;
@@ -54,6 +66,7 @@ import com.olympus.hermione.stepSolvers.QueryNeo4JSolver;
 import com.olympus.hermione.stepSolvers.SourceCodeRagSolver;
 import com.olympus.hermione.stepSolvers.StepSolver;
 
+import org.bson.types.ObjectId;
 import org.neo4j.driver.Driver;
 import org.slf4j.Logger;
 
@@ -64,15 +77,15 @@ import com.olympus.hermione.stepSolvers.ExternalAgentSolver;
 import com.olympus.hermione.stepSolvers.ExternalCodeGenieSolver;
 import com.olympus.hermione.stepSolvers.OlynmpusChatClientSolver;
 
-
-
-
 @Service
 public class ScenarioExecutionService {
 
     @Value("${file.upload-dir}")
     private String uploadDir;
 
+    @Autowired
+    private MongoTemplate mongoTemplate;
+
     @Autowired
     private ScenarioRepository scenarioRepository;
 
@@ -88,7 +101,6 @@ public class ScenarioExecutionService {
     @Autowired
     DiscoveryClient discoveryClient;
 
-
     @Autowired
     Driver graphDriver;
 
@@ -108,7 +120,8 @@ public class ScenarioExecutionService {
             ScenarioExecution scenarioExecution = o_scenarioExecution.get();
             scenarioExecution.setCurrentStepId(scenarioExecution.getCurrentStepId());
 
-            if(scenarioExecution.getExecSharedMap()!=null && scenarioExecution.getExecSharedMap().get("scenario_output")!=null){
+            if (scenarioExecution.getExecSharedMap() != null
+                    && scenarioExecution.getExecSharedMap().get("scenario_output") != null) {
                 scenarioOutput.setScenarioExecution_id(scenarioExecution.getId());
                 scenarioOutput.setStatus("OK");
                 scenarioOutput.setStringOutput(scenarioExecution.getExecSharedMap().get("scenario_output").toString());
@@ -119,19 +132,23 @@ public class ScenarioExecutionService {
 
                 if (scenarioExecution.getCurrentStepId() != null) {
                     OptionalInt indexOpt = IntStream.range(0, scenarioExecution.getScenario().getSteps().size())
-                    .filter(i -> scenarioExecution.getScenario().getSteps().get(i).getStepId().equals(scenarioExecution.getCurrentStepId()))
+                            .filter(i -> scenarioExecution.getScenario().getSteps().get(i).getStepId()
+                                    .equals(scenarioExecution.getCurrentStepId()))
                             .map(i -> i + 1)
                             .findFirst();
 
                     scenarioOutput.setCurrentStepId(scenarioExecution.getCurrentStepId());
                     scenarioOutput.setCurrentStepDescription(scenarioExecution.getCurrentStepDescription());
-                    scenarioOutput.setMessage("Executing step "+indexOpt.getAsInt()+"/"+scenarioExecution.getScenario().getSteps().size()+": "+scenarioOutput.getCurrentStepDescription()+".");
+                    scenarioOutput.setMessage("Executing step " + indexOpt.getAsInt() + "/"
+                            + scenarioExecution.getScenario().getSteps().size() + ": "
+                            + scenarioOutput.getCurrentStepDescription() + ".");
                 } else {
                     scenarioOutput.setMessage("Starting execution...");
                 }
             }
 
-            if(scenarioExecution.getLatestStepStatus()!= null && scenarioExecution.getLatestStepStatus().equals("ERROR")){
+            if (scenarioExecution.getLatestStepStatus() != null
+                    && scenarioExecution.getLatestStepStatus().equals("ERROR")) {
                 scenarioOutput.setScenarioExecution_id(scenarioExecution.getId());
                 scenarioOutput.setStatus("ERROR");
                 scenarioOutput.setMessage(scenarioExecution.getLatestStepOutput());
@@ -180,7 +197,6 @@ public class ScenarioExecutionService {
 
             scenarioExecutionRepository.save(scenarioExecution);
 
-
             if (scenario.isUseChatMemory()) {
                 logger.info("Initializing chatClient with chat-memory advisor");
 
@@ -188,8 +204,7 @@ public class ScenarioExecutionService {
                 chatClient = ChatClient.builder(chatModel)
                         .defaultAdvisors(
                                 new MessageChatMemoryAdvisor(chatMemory), // chat-memory advisor
-                    new SimpleLoggerAdvisor()
+                                new SimpleLoggerAdvisor())
-                )
                         .build();
 
             } else {
@@ -197,22 +212,22 @@ public class ScenarioExecutionService {
 
                 chatClient = ChatClient.builder(chatModel)
                         .defaultAdvisors(
-                    new SimpleLoggerAdvisor()
+                                new SimpleLoggerAdvisor())
-                )
                         .build();
             }
 
-            
             List<ScenarioStep> steps = scenario.getSteps();
             String startStepId = scenario.getStartWithStepId();
 
-            ScenarioStep startStep = steps.stream().filter(step -> step.getStepId().equals(startStepId)).findFirst().orElse(null);
+            ScenarioStep startStep = steps.stream().filter(step -> step.getStepId().equals(startStepId)).findFirst()
+                    .orElse(null);
 
             executeScenarioStep(startStep, scenarioExecution);
             Integer usedTokens = (scenarioExecution.getUsedTokens() != null) ? scenarioExecution.getUsedTokens() : 0;
 
             while (scenarioExecution.getNextStepId() != null) {
-                ScenarioStep step = steps.stream().filter(s -> s.getStepId().equals(scenarioExecution.getNextStepId())).findFirst().orElse(null);
+                ScenarioStep step = steps.stream().filter(s -> s.getStepId().equals(scenarioExecution.getNextStepId()))
+                        .findFirst().orElse(null);
                 executeScenarioStep(step, scenarioExecution);
 
                 if (scenarioExecution.getUsedTokens() != null && scenarioExecution.getUsedTokens() != 0) {
@@ -221,7 +236,8 @@ public class ScenarioExecutionService {
                     scenarioExecution.setUsedTokens(0); // resetting value for next step if is not an AI step
                 }
 
-                if(scenarioExecution.getLatestStepStatus() != null && scenarioExecution.getLatestStepStatus().equals("ERROR")){
+                if (scenarioExecution.getLatestStepStatus() != null
+                        && scenarioExecution.getLatestStepStatus().equals("ERROR")) {
                     logger.error("Error while executing step: " + step.getStepId());
                     break;
                 }
@@ -233,10 +249,6 @@ public class ScenarioExecutionService {
         }
     }
 
-
-
-
-
     private void executeScenarioStep(ScenarioStep step, ScenarioExecution scenarioExecution) {
         logger.info("Start working on step: " + step.getName() + " with type: " + step.getType());
         StepSolver solver = new StepSolver();
@@ -278,7 +290,6 @@ public class ScenarioExecutionService {
                 break;
         }
 
-
         logger.info("Initializing step: " + step.getStepId());
         logger.info("Solving step: " + step.getStepId());
         scenarioExecution.setCurrentStepId(step.getStepId());
@@ -288,8 +299,7 @@ public class ScenarioExecutionService {
 
         try {
             solver.init(step, scenarioExecution,
-                    vectorStore,chatModel,chatClient,graphDriver,neo4JUitilityService
+                    vectorStore, chatModel, chatClient, graphDriver, neo4JUitilityService, discoveryClient);
-                    ,discoveryClient);
 
             scenarioExecutionNew = solver.solveStep();
 
@@ -303,11 +313,9 @@ public class ScenarioExecutionService {
             scenarioExecutionNew.setLatestStepOutput(e.getMessage());
         }
 
-        
         scenarioExecutionRepository.save(scenarioExecutionNew);
     }
 
-
     public ScenarioOutput prepareScrenarioExecution(ScenarioExecutionInput scenarioExecutionInput) {
 
         String scenarioId = scenarioExecutionInput.getScenario_id();
@@ -324,7 +332,8 @@ public class ScenarioExecutionService {
 
             ScenarioExecution scenarioExecution = new ScenarioExecution();
             scenarioExecution.setScenario(scenario);
-            //prendi i file dalla cartella temporanea se è presente una chiave con name "MultiFileUpload"
+            // prendi i file dalla cartella temporanea se è presente una chiave con name
+            // "MultiFileUpload"
             if (scenarioExecutionInput.getInputs().containsKey("MultiFileUpload")) {
                 folder_name = scenarioExecutionInput.getInputs().get("MultiFileUpload");
                 if (folder_name != null && !folder_name.equals("")) {
@@ -337,30 +346,31 @@ public class ScenarioExecutionService {
                 }
             }
             if (scenarioExecutionInput.getInputs().containsKey("SingleFileUpload")) {
-                scenarioExecutionInput.getInputs().put("SingleFileUpload", uploadDir + folder_name + "/" + scenarioExecutionInput.getInputs().get("SingleFileUpload"));
+                scenarioExecutionInput.getInputs().put("SingleFileUpload",
+                        uploadDir + folder_name + "/" + scenarioExecutionInput.getInputs().get("SingleFileUpload"));
             }
             scenarioExecution.setScenarioExecutionInput(scenarioExecutionInput);
 
             try {
                 if (SecurityContextHolder.getContext() != null
                         && SecurityContextHolder.getContext().getAuthentication() != null
-                                && SecurityContextHolder.getContext().getAuthentication().getPrincipal()!= null
+                        && SecurityContextHolder.getContext().getAuthentication().getPrincipal() != null) {
-                                ){
 
                     User principal = (User) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
                     scenarioExecution.setExecutedByUserId(principal.getId().toString());
                     scenarioExecution.setExecutedByUsername(principal.getUsername());
                     if (principal.getSelectedApplication() != null) {
-                        scenarioExecutionInput.getInputs().put("selected_application", principal.getSelectedApplication().getInternal_name());
+                        scenarioExecutionInput.getInputs().put("selected_application",
+                                principal.getSelectedApplication().getInternal_name());
                     }
-                    scenarioExecutionInput.getInputs().put("selected_project", principal.getSelectedProject().getInternal_name());
+                    scenarioExecutionInput.getInputs().put("selected_project",
+                            principal.getSelectedProject().getInternal_name());
                 }
 
             } catch (Exception e) {
                 logger.error("Error while saving user information in scenario execution: " + e.getMessage());
             }
 
-
             scenarioExecutionRepository.save(scenarioExecution);
 
             scenarioOutput.setScenarioExecution_id(scenarioExecution.getId());
@@ -421,7 +431,6 @@ public class ScenarioExecutionService {
         }
     }
 
-
     private ChatModel createChatModel(AiModel aiModel) {
         switch (aiModel.getApiProvider()) {
             case "AzureOpenAI":
@@ -429,7 +438,6 @@ public class ScenarioExecutionService {
                         .credential(new AzureKeyCredential(aiModel.getApiKey()))
                         .endpoint(aiModel.getEndpoint());
 
-
                 AzureOpenAiChatOptions openAIChatOptions = AzureOpenAiChatOptions.builder()
                         .deploymentName(aiModel.getModel())
                         .maxTokens(aiModel.getMaxTokens())
@@ -441,8 +449,6 @@ public class ScenarioExecutionService {
                 logger.info("AI model used: " + aiModel.getModel());
                 return azureOpenaichatModel;
 
-         
-    
             case "OpenAI":
                 OpenAiApi openAiApi = new OpenAiApi(aiModel.getApiKey());
                 OpenAiChatOptions openAiChatOptions = OpenAiChatOptions.builder()
@@ -455,20 +461,19 @@ public class ScenarioExecutionService {
                 logger.info("AI model used: " + aiModel.getModel());
                 return openaichatModel;
 
-
             case "GoogleGemini":
                 OpenAIClientBuilder openAIClient2 = new OpenAIClientBuilder()
                         .credential(new AzureKeyCredential(aiModel.getApiKey()))
                         .endpoint(aiModel.getEndpoint());
 
-
                 AzureOpenAiChatOptions openAIChatOptions2 = AzureOpenAiChatOptions.builder()
                         .deploymentName(aiModel.getModel())
                         .maxTokens(aiModel.getMaxTokens())
                         .temperature(Double.valueOf(aiModel.getTemperature()))
                         .build();
 
-                    AzureOpenAiChatModel azureOpenaichatModel2 = new AzureOpenAiChatModel(openAIClient2, openAIChatOptions2);
+                AzureOpenAiChatModel azureOpenaichatModel2 = new AzureOpenAiChatModel(openAIClient2,
+                        openAIChatOptions2);
 
                 logger.info("AI model used : " + aiModel.getModel());
                 return azureOpenaichatModel2;
@@ -477,51 +482,206 @@ public class ScenarioExecutionService {
         }
     }
 
-    public List<ScenarioExecution> getListExecutionScenarioByUser(){
+    /*
-        logger.info("getListProjectByUser function:");
+     * public List<ScenarioExecution> getListExecutionScenario(){
+     * logger.info("getListProjectByUser function:");
+     * 
+     * List<ScenarioExecution> lstScenarioExecution = null;
+     * 
+     * User principal = (User)
+     * SecurityContextHolder.getContext().getAuthentication().getPrincipal();
+     * 
+     * if(principal.getSelectedApplication()!=null){
+     * lstScenarioExecution =
+     * scenarioExecutionRepository.getFromProjectAndAPP(principal.getId(),
+     * principal.getSelectedProject().getInternal_name(),
+     * principal.getSelectedApplication().getInternal_name(),
+     * Sort.by(Sort.Direction.DESC, "startDate"));
+     * 
+     * }else{
+     * lstScenarioExecution =
+     * scenarioExecutionRepository.getFromProject(principal.getId(),
+     * principal.getSelectedProject().getInternal_name(),
+     * Sort.by(Sort.Direction.DESC, "startDate"));
+     * }
+     * 
+     * return lstScenarioExecution;
+     * 
+     * }
+     */
 
-        List<ScenarioExecution> lstScenarioExecution = null;
+    public Page<ScenarioExecution> getListExecutionScenarioOptional(int page, int size, String scenarioName,
+            String executedBy, LocalDate startDate) {
+        logger.info("getListExecutionScenarioOptional function:");
 
+        List<Criteria> criteriaList = new ArrayList<>();
         User principal = (User) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
 
-        if(principal.getSelectedApplication()!=null){
+        // Filtro per progetto selezionato
-            lstScenarioExecution = scenarioExecutionRepository.getFromProjectAndAPP(principal.getId(), principal.getSelectedProject().getInternal_name(), principal.getSelectedApplication().getInternal_name(), Sort.by(Sort.Direction.DESC, "startDate"));
+        if (principal.getSelectedProject() != null && principal.getSelectedProject().getId() != null) {
+            criteriaList.add(Criteria.where("scenarioExecutionInput.inputs.selected_project")
+                    .is(principal.getSelectedProject().getInternal_name()));
+        }
 
+        // Filtro per applicazione selezionata
+        if (principal.getSelectedApplication() != null && principal.getSelectedApplication().getId() != null) {
+            criteriaList.add(Criteria.where("scenarioExecutionInput.inputs.selected_application")
+                    .is(principal.getSelectedApplication().getInternal_name()));
+        }
+
+        // Filtro per nome scenario
+        if (scenarioName != null) {
+            criteriaList.add(Criteria.where("scenarioExecutionInput.scenario.name").is(scenarioName));
+        }
+
+        // Filtro per utente che ha eseguito
+        if (executedBy != null) {
+            criteriaList.add(Criteria.where("executedByUsername").is(executedBy));
+        }
+
+        // Filtro per data di inizio
+        if (startDate != null) {
+            criteriaList.add(Criteria.where("startDate").gte(startDate));
+        }
+
+        // Costruisce la query solo con i criteri presenti
+        Criteria criteria = new Criteria();
+        if (!criteriaList.isEmpty()) {
+            criteria = new Criteria().andOperator(criteriaList.toArray(new Criteria[0]));
+        }
+
+        Query query = new Query(criteria);
+        long count = mongoTemplate.count(query, ScenarioExecution.class); // Conta i documenti senza paginazione
+
+        // Applica la paginazione solo per ottenere i risultati
+        Pageable pageable = PageRequest.of(page, size, Sort.by(Sort.Direction.DESC, "startDate"));
+        query.with(pageable);
+
+        List<ScenarioExecution> results = mongoTemplate.find(query, ScenarioExecution.class);
+
+        return new PageImpl<>(results, pageable, count);
+    }
+
+    public Page<ScenarioExecution> getFilteredExecutions(Map<String, Object> filters) {
+        logger.info("getFilteredExecutions function:");
+
+        List<Criteria> criteriaList = new ArrayList<>();
+
+        int page = 0;
+        int size = 10;
+        String sortField = "startDate";
+        int sortOrder = -1;
+
+        User principal = (User) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
+        criteriaList.add(Criteria.where("execSharedMap.user_input.selected_project")
+                .is(principal.getSelectedProject().getInternal_name()));
+        criteriaList.add(Criteria.where("execSharedMap.user_input.selected_application")
+                .is(principal.getSelectedApplication().getInternal_name()));
+        // here: 
+        // filtri
+        // here: 
+        // here: vedi perchè non funziona link di view
+        // here: da sistemare filtro data a backend e i vari equals
+        // here: add ordinamento
+        
+        for (Map.Entry<String, Object> entry : filters.entrySet()) {
+            String key = entry.getKey();
+            Object value = entry.getValue();
+
+            if ("page".equals(key)) {
+                page = (int) value;
+            } else if ("size".equals(key)) {
+                size = (int) value;
+            }else if ("sortField".equals(key)) {
+                if(value!=null) {
+                    sortField = (String) value;
+                }
+
+            }else if("sortOrder".equals(key)){
+                if(value!=null) {
+                    sortOrder = (int) value;
+                }
+            }else if (value instanceof Map) {
+                Map<String, Object> valueMap = (Map<String, Object>) value;
+                String operator = (String) valueMap.get("operator");
+                List<Map<String, Object>> constraints = (List<Map<String, Object>>) valueMap.get("constraints");
+
+                for (Map<String, Object> constraint : constraints) {
+                    Object constraintValue = constraint.get("value");
+                    String matchMode = (String) constraint.get("matchMode");
+
+                    if (constraintValue != null && !constraintValue.toString().isEmpty()) {
+                        switch (matchMode) {
+                            case "contains":
+                                if (key.equals("_id")) {
+                                    criteriaList.add(Criteria.where("_id").is(new ObjectId((String) constraintValue)));
                                 } else {
-            lstScenarioExecution = scenarioExecutionRepository.getFromProject(principal.getId(), principal.getSelectedProject().getInternal_name(), Sort.by(Sort.Direction.DESC, "startDate"));
+                                    criteriaList.add(Criteria.where(key).regex((String) constraintValue, "i"));
+                                }
+                                break;
+                            case "notContains":
+                                criteriaList.add(Criteria.where(key).not().regex((String) constraintValue, "i"));
+                                break;
+                            case "dateIs":
+                                criteriaList.add(Criteria.where(key).is(
+                                        LocalDate.parse(((String) constraintValue).substring(0, 10))));
+
+                                break;
+                            case "dateIsNot":
+                                criteriaList.add(Criteria.where(key).ne(Criteria.where(key).is(
+                                        LocalDate.parse(((String) constraintValue).substring(0, 10)))));
+                                break;
+                            case "dateBefore":
+                                criteriaList.add(Criteria.where(key).lt(Criteria.where(key).is(
+                                        LocalDate.parse(((String) constraintValue).substring(0, 10)))));
+                                break;
+                            case "dateAfter":
+                                criteriaList.add(Criteria.where(key).gt(Criteria.where(key).is(
+                                        LocalDate.parse(((String) constraintValue).substring(0, 10)))));
+                                break;
+                            case "equals":
+                                criteriaList.add(Criteria.where(key).is(constraintValue));
+                                break;
+                            case "notEquals":
+                                criteriaList.add(Criteria.where(key).ne(constraintValue));
+                                break;
+                            case "startsWith":
+                                criteriaList.add(Criteria.where(key).regex("^" + constraintValue, "i"));
+                                break;
+                            case "endsWith":
+                                criteriaList.add(Criteria.where(key).regex(constraintValue + "$", "i"));
+                                break;
+                            default:
+                                criteriaList.add(Criteria.where(key).is(constraintValue));
+                                break;
+                        }
+                    }
+                }
+            } else if (value instanceof String) {
+                criteriaList.add(Criteria.where(key).regex((String) value, "i"));
+            }
         }
 
-        return lstScenarioExecution;
+        Criteria criteria = new Criteria();
-
+        if (!criteriaList.isEmpty()) {
+            criteria = new Criteria().andOperator(criteriaList.toArray(new Criteria[0]));
         }
 
-    public String updateRating2(ScenarioExecution scenaExec){
+        Query query = new Query(criteria);
-        logger.info("updateRating function:");
+        long count = mongoTemplate.count(query, ScenarioExecution.class);
-        String result = "KO";
+
-        try{
+        Pageable pageable = null;
-            scenarioExecutionRepository.save(scenaExec);
+        if(sortOrder == -1) {
-            result = "OK";
+            pageable = PageRequest.of(page, size, Sort.by(Sort.Direction.DESC, sortField));
-        }catch(Exception e){
+        }else {
-            logger.error("Exception in updateRating: {}", e.getMessage());
+            pageable = PageRequest.of(page, size, Sort.by(Sort.Direction.ASC, sortField));
+        }
+        query.with(pageable);
+
+        List<ScenarioExecution> results = mongoTemplate.find(query, ScenarioExecution.class);
+
+        return new PageImpl<>(results, pageable, count);
     }
 
-        return result;
   
 }
-
-    public String updateRating(String id, String rating){
-        logger.info("updateRating function:");
-        String result = "KO";
-        try{
-            Optional<ScenarioExecution> o_scenarioExecution  = scenarioExecutionRepository.findById(id);
-            if(o_scenarioExecution.isPresent()){ 
-                o_scenarioExecution.get().setRating(rating);
-                scenarioExecutionRepository.save(o_scenarioExecution.get());
-                result = "OK";
-            }
-        }catch(Exception e){
-            logger.error("Exception in updateRating: {}", e.getMessage());
-        }
-        return result;  
-    }
-}

src/main/java/com/olympus/hermione/services/ScenarioService.java

@@ -7,13 +7,17 @@ import org.springframework.security.core.context.SecurityContextHolder;
 import org.springframework.stereotype.Service;
 
 import com.olympus.hermione.models.Scenario;
+import com.olympus.hermione.models.ScenarioExecution;
 import com.olympus.hermione.repository.ProjectRepository;
+import com.olympus.hermione.repository.ScenarioExecutionRepository;
 import com.olympus.hermione.repository.ScenarioRepository;
 import com.olympus.hermione.security.entity.User;
 import com.olympus.model.Project;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Optional;
+
 import org.bson.types.ObjectId;
 
 @Service
@@ -24,6 +28,9 @@ public class ScenarioService {
     @Autowired
     private ScenarioRepository scenarioRepo;
 
+    @Autowired
+    private ScenarioExecutionRepository scenarioExecutionRepository;
+
     public List<Scenario> getListScenariosByProject(String project){
         logger.info("getListProjectByUser function:");
         List<Scenario> lstScenarios = null;
@@ -117,4 +124,20 @@ public class ScenarioService {
         return lstScenarios;
 
     }
+
+    public String updateRating(String id, String rating) {
+        logger.info("updateRating function:");
+        String result = "KO";
+        try {
+            Optional<ScenarioExecution> o_scenarioExecution = scenarioExecutionRepository.findById(id);
+            if (o_scenarioExecution.isPresent()) {
+                o_scenarioExecution.get().setRating(rating);
+                scenarioExecutionRepository.save(o_scenarioExecution.get());
+                result = "OK";
+            }
+        } catch (Exception e) {
+            logger.error("Exception in updateRating: {}", e.getMessage());
+        }
+        return result;
+    }
 }