[NAE-2235] Improve Efficiency of Database Reads and Saves

application-engine/src/main/groovy/com/netgrif/application/engine/migration/ActionMigration.groovy

@@ -4,6 +4,7 @@ import com.netgrif.application.engine.auth.service.UserService
 import com.netgrif.application.engine.objects.auth.domain.ActorTransformer
 import com.netgrif.application.engine.objects.petrinet.domain.PetriNet
 import com.netgrif.application.engine.objects.petrinet.domain.VersionType
+import com.netgrif.application.engine.petrinet.params.ImportPetriNetParams
 import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService
 import com.netgrif.application.engine.objects.workflow.domain.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome
 import groovy.util.logging.Slf4j
@@ -24,42 +25,47 @@ class ActionMigration {
     private UserService userService;
 
     void migrateActions(String petriNetPath) {
-        InputStream netStream = new ClassPathResource(petriNetPath).inputStream
-        ImportPetriNetEventOutcome newPetriNet = petriNetService.importPetriNet(netStream, VersionType.MAJOR, ActorTransformer.toLoggedUser(userService.getLoggedOrSystem()))
-        List<PetriNet> oldPetriNets
+        try (InputStream netStream = new ClassPathResource(petriNetPath).inputStream) {
+            ImportPetriNetEventOutcome newPetriNet = petriNetService.importPetriNet(ImportPetriNetParams.with()
+                    .xmlFile(netStream)
+                    .releaseType(VersionType.MAJOR)
+                    .author(ActorTransformer.toLoggedUser(userService.getLoggedOrSystem()))
+                    .build())
+            List<PetriNet> oldPetriNets
 
-        if(newPetriNet.getNet() != null) {
-            String message = "Petri net from file [" + petriNetPath + "] was not imported"
-            log.error(message)
-            throw new IllegalArgumentException(message)
-        } else {
-            oldPetriNets = petriNetService.getByIdentifier(newPetriNet.getNet().importId)
-                    .stream().filter({ net -> (net.version != newPetriNet.getNet().version)})
-                    .collect(Collectors.toList())
-        }
+            if (newPetriNet.getNet() == null) {
+                String message = "Petri net from file [" + petriNetPath + "] was not imported"
+                log.error(message)
+                throw new IllegalArgumentException(message)
+            } else {
+                oldPetriNets = petriNetService.getByIdentifier(newPetriNet.getNet().importId)
+                        .stream().filter({ net -> (net.version != newPetriNet.getNet().version)})
+                        .collect(Collectors.toList())
+            }
 
-        if(oldPetriNets.size() == 0){
-            String message = "Older version of Petri net with ID [" + newPetriNet.getNet().importId + "] is not present in MongoDB."
-            log.error(message)
-            throw new IllegalArgumentException(message)
-        } else {
-            oldPetriNets.each {net ->
-                migrateDataSetActions(newPetriNet.getNet(), net)
-                migrateDataRefActions(newPetriNet.getNet(), net)
-                petriNetService.save(net)
+            if (oldPetriNets.size() == 0){
+                String message = "Older version of Petri net with ID [" + newPetriNet.getNet().importId + "] is not present in MongoDB."
+                log.error(message)
+                throw new IllegalArgumentException(message)
+            } else {
+                oldPetriNets.each {net ->
+                    migrateDataSetActions(newPetriNet.getNet(), net)
+                    migrateDataRefActions(newPetriNet.getNet(), net)
+                    petriNetService.save(net)
+                }
             }
         }
     }
 
-    private void migrateDataSetActions(PetriNet newPetriNet, PetriNet oldPetriNet) {
+    private static void migrateDataSetActions(PetriNet newPetriNet, PetriNet oldPetriNet) {
         newPetriNet.dataSet.each { key, data ->
             if (data.events != null && data.events.size() > 0) {
                 oldPetriNet.dataSet[key].events = data.events
             }
         }
     }
 
-    private void migrateDataRefActions(PetriNet newPetriNet, PetriNet oldPetriNet) {
+    private static void migrateDataRefActions(PetriNet newPetriNet, PetriNet oldPetriNet) {
         newPetriNet.transitions.each { transKey, trans ->
             trans.dataSet.each { dataKey, data ->
                 if (data.events != null && data.events.size() > 0) {

application-engine/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy

@@ -49,10 +49,13 @@ import com.netgrif.application.engine.objects.utils.MenuItemUtils
 import com.netgrif.application.engine.objects.workflow.domain.Case
 import com.netgrif.application.engine.objects.workflow.domain.Task
 import com.netgrif.application.engine.objects.workflow.domain.eventoutcomes.EventOutcome
+import com.netgrif.application.engine.objects.workflow.domain.eventoutcomes.caseoutcomes.ChangeCasePropertyOutcome
 import com.netgrif.application.engine.objects.workflow.domain.eventoutcomes.caseoutcomes.CreateCaseEventOutcome
+import com.netgrif.application.engine.objects.workflow.domain.eventoutcomes.caseoutcomes.DeleteCaseEventOutcome
 import com.netgrif.application.engine.objects.workflow.domain.eventoutcomes.dataoutcomes.GetDataEventOutcome
 import com.netgrif.application.engine.objects.workflow.domain.eventoutcomes.dataoutcomes.SetDataEventOutcome
 import com.netgrif.application.engine.objects.workflow.domain.eventoutcomes.taskoutcomes.AssignTaskEventOutcome
+import com.netgrif.application.engine.objects.workflow.domain.eventoutcomes.taskoutcomes.FinishTaskEventOutcome
 import com.netgrif.application.engine.objects.workflow.domain.eventoutcomes.taskoutcomes.TaskEventOutcome
 import com.netgrif.application.engine.objects.workflow.domain.menu.FilterBody
 import com.netgrif.application.engine.objects.workflow.domain.menu.MenuItemBody
@@ -70,7 +73,11 @@ import com.netgrif.application.engine.plugin.meta.PluginHolder
 import com.netgrif.application.engine.startup.ImportHelper
 import com.netgrif.application.engine.startup.runner.DefaultFiltersRunner
 import com.netgrif.application.engine.startup.runner.FilterRunner
+import com.netgrif.application.engine.startup.runner.MenuProcessRunner
 import com.netgrif.application.engine.utils.FullPageRequest
+import com.netgrif.application.engine.workflow.params.CreateCaseParams
+import com.netgrif.application.engine.workflow.params.DeleteCaseParams
+import com.netgrif.application.engine.workflow.params.TaskParams
 import com.netgrif.application.engine.workflow.service.FileFieldInputStream
 import com.netgrif.application.engine.workflow.service.InitValueExpressionEvaluator
 import com.netgrif.application.engine.workflow.service.TaskService
@@ -627,9 +634,12 @@ class ActionDelegate {
     }
 
     private addTaskOutcomes(Task task, Map dataSet) {
-        this.outcomes.add(taskService.assignTask(task.stringId))
-        this.outcomes.add(dataService.setData(task.stringId, ImportHelper.populateDataset(dataSet as Map<String, Map<String, String>>)))
-        this.outcomes.add(taskService.finishTask(task.stringId))
+        AssignTaskEventOutcome assignOutcome = taskService.assignTask(new TaskParams(task.stringId))
+        this.outcomes.add(assignOutcome)
+        SetDataEventOutcome setDataOutcome = dataService.setData(assignOutcome.getTask(), ImportHelper.populateDataset(dataSet as Map<String, Map<String, String>>))
+        this.outcomes.add(setDataOutcome)
+        FinishTaskEventOutcome finishOutcome = taskService.finishTask(new TaskParams(setDataOutcome.getTask()))
+        this.outcomes.add(finishOutcome)
     }
 
     List<String> searchCases(Closure<Predicate> predicates) {
@@ -869,6 +879,8 @@ class ActionDelegate {
                 }
                 taskService.save(tasks)
             }
+
+            outcomes.add(new ChangeCasePropertyOutcome(useCase))
         }]
     }
 
@@ -937,25 +949,63 @@ class ActionDelegate {
         return workflowService.findOne(stringId)
     }
 
-    Case createCase(String identifier, String title = null, String color = "", AbstractUser author = userService.loggedOrSystem, Locale locale = LocaleContextHolder.getLocale(), Map<String, String> params = [:]) {
-        return workflowService.createCaseByIdentifier(identifier, title, color, ActorTransformer.toLoggedUser(author), locale, params).getCase()
+    Case createCase(String identifier, String title = null, String color = "", AbstractUser author = userService.loggedOrSystem,
+                    Locale locale = LocaleContextHolder.getLocale(), Map<String, String> params = [:]) {
+        CreateCaseEventOutcome outcome = workflowService.createCase(CreateCaseParams.with()
+                .processIdentifier(identifier)
+                .title(title)
+                .color(color)
+                .author(ActorTransformer.toLoggedUser(author))
+                .locale(locale)
+                .params(params)
+                .build())
+        this.outcomes.add(outcome)
+        return outcome.getCase()
     }
 
-    Case createCase(PetriNet net, String title = net.defaultCaseName.getTranslation(locale), String color = "", AbstractUser author = userService.loggedOrSystem, Locale locale = LocaleContextHolder.getLocale(), Map<String, String> params = [:]) {
-        CreateCaseEventOutcome outcome = workflowService.createCase(net.stringId, title, color, ActorTransformer.toLoggedUser(author), params)
+    Case createCase(PetriNet net, String title = net.defaultCaseName.getTranslation(locale), String color = "",
+                    AbstractUser author = userService.loggedOrSystem, Locale locale = LocaleContextHolder.getLocale(), Map<String, String> params = [:]) {
+        CreateCaseEventOutcome outcome = workflowService.createCase(CreateCaseParams.with()
+                .process(net)
+                .title(title)
+                .color(color)
+                .author(ActorTransformer.toLoggedUser(author))
+                .locale(locale)
+                .params(params)
+                .build())
         this.outcomes.add(outcome)
         return outcome.getCase()
     }
 
+    Case deleteCase(Case useCase) {
+        DeleteCaseEventOutcome outcome = workflowService.deleteCase(new DeleteCaseParams(useCase))
+        this.outcomes.add(outcome)
+        return outcome.case
+    }
+
+    Case deleteCase(String caseId) {
+        DeleteCaseEventOutcome outcome = workflowService.deleteCase(new DeleteCaseParams(caseId))
+        this.outcomes.add(outcome)
+        return outcome.case
+    }
+
     Task assignTask(String transitionId, Case aCase = useCase, AbstractUser user = userService.loggedOrSystem, Map<String, String> params = [:]) {
         String taskId = getTaskId(transitionId, aCase)
-        AssignTaskEventOutcome outcome = taskService.assignTask(ActorTransformer.toLoggedUser(user), taskId, params)
+        AssignTaskEventOutcome outcome = taskService.assignTask(TaskParams.with()
+                .taskId(taskId)
+                .user(user)
+                .params(params)
+                .build())
         this.outcomes.add(outcome)
         return outcome.getTask()
     }
 
     Task assignTask(Task task, AbstractUser user = userService.loggedOrSystem, Map<String, String> params = [:]) {
-        return addTaskOutcomeAndReturnTask(taskService.assignTask(task, user, params))
+        return addTaskOutcomeAndReturnTask(taskService.assignTask(TaskParams.with()
+                .task(task)
+                .user(user)
+                .params(params)
+                .build()))
     }
 
     void assignTasks(List<Task> tasks, AbstractUser assignee = userService.loggedOrSystem, Map<String, String> params = [:]) {
@@ -964,11 +1014,19 @@ class ActionDelegate {
 
     Task cancelTask(String transitionId, Case aCase = useCase, AbstractUser user = userService.loggedOrSystem, Map<String, String> params = [:]) {
         String taskId = getTaskId(transitionId, aCase)
-        return addTaskOutcomeAndReturnTask(taskService.cancelTask(ActorTransformer.toLoggedUser(user), taskId, params))
+        return addTaskOutcomeAndReturnTask(taskService.cancelTask(TaskParams.with()
+                .taskId(taskId)
+                .user(user)
+                .params(params)
+                .build()))
     }
 
     Task cancelTask(Task task, AbstractUser user = userService.loggedOrSystem, Map<String, String> params = [:]) {
-        return addTaskOutcomeAndReturnTask(taskService.cancelTask(task, user, params))
+        return addTaskOutcomeAndReturnTask(taskService.cancelTask(TaskParams.with()
+                .task(task)
+                .user(user)
+                .params(params)
+                .build()))
     }
 
     void cancelTasks(List<Task> tasks, AbstractUser user = userService.loggedOrSystem, Map<String, String> params = [:]) {
@@ -982,11 +1040,19 @@ class ActionDelegate {
 
     void finishTask(String transitionId, Case aCase = useCase, AbstractUser user = userService.loggedOrSystem, Map<String, String> params = [:]) {
         String taskId = getTaskId(transitionId, aCase)
-        addTaskOutcomeAndReturnTask(taskService.finishTask(ActorTransformer.toLoggedUser(user), taskId, params))
+        addTaskOutcomeAndReturnTask(taskService.finishTask(TaskParams.with()
+                .taskId(taskId)
+                .user(user)
+                .params(params)
+                .build()))
     }
 
     void finishTask(Task task, AbstractUser user = userService.loggedOrSystem, Map<String, String> params = [:]) {
-        addTaskOutcomeAndReturnTask(taskService.finishTask(task, user, params))
+        addTaskOutcomeAndReturnTask(taskService.finishTask(TaskParams.with()
+                .task(task)
+                .user(user)
+                .params(params)
+                .build()))
     }
 
     void finishTasks(List<Task> tasks, AbstractUser finisher = userService.loggedOrSystem, Map<String, String> params = [:]) {
@@ -1078,6 +1144,7 @@ class ActionDelegate {
         return addSetDataOutcomeToOutcomes(dataService.setData(taskId, ImportHelper.populateDataset(dataSet), params))
     }
 
+    // todo: remove all deprecated
     @Deprecated
     SetDataEventOutcome setDataWithPropagation(String transitionId, Case caze, Map dataSet) {
         Task task = taskService.findOne(caze.tasks.find { it.transition == transitionId }.task)
@@ -1120,8 +1187,7 @@ class ActionDelegate {
 
     Map<String, Field> getData(String taskId, Map<String, String> params = [:]) {
         Task task = taskService.findById(taskId)
-        def useCase = workflowService.findOne(task.caseId)
-        return mapData(addGetDataOutcomeToOutcomesAndReturnData(dataService.getData(task, useCase, params)))
+        return getData(task, params)
     }
 
     Map<String, Field> getData(Transition transition, Map<String, String> params = [:]) {
@@ -1321,8 +1387,11 @@ class ActionDelegate {
     }
 
     def changeUserByEmail(String email, String attribute, def cl) {
-        AbstractUser user = userService.findUserByUsername(email, null)
-        changeUser(user, attribute, cl)
+        Optional<AbstractUser> userOpt = userService.findUserByUsername(email, null)
+        if (userOpt.isEmpty()) {
+            throw new IllegalArgumentException("Such user with email %s does not exists.".formatted(email))
+        }
+        changeUser(userOpt.get(), attribute, cl)
     }
 
     def changeUser(String id, String attribute, def cl) {
@@ -1365,8 +1434,10 @@ class ActionDelegate {
 
     void deleteUser(String email) {
         AbstractUser user = userService.findByEmail(email, null)
-        if (user == null)
+        if (user == null) {
             log.error("Cannot find user with email [" + email + "]")
+            return
+        }
         deleteUser(user)
     }
 
@@ -1384,12 +1455,12 @@ class ActionDelegate {
     }
 
     AbstractUser findUserByEmail(String email) {
-        AbstractUser user = userService.findUserByUsername(email, null)
-        if (user == null) {
+        Optional<AbstractUser> userOpt = userService.findUserByUsername(email, null)
+        if (userOpt.isEmpty()) {
             log.error("Cannot find user with email [" + email + "]")
             return null
         } else {
-            return user
+            return userOpt.get()
         }
     }
 
@@ -1709,7 +1780,7 @@ class ActionDelegate {
      * @return
      */
     def deleteFilter(Case filter) {
-        workflowService.deleteCase(filter.stringId)
+        workflowService.deleteCase(new DeleteCaseParams(filter.stringId))
     }
 
     /**
@@ -1947,7 +2018,7 @@ class ActionDelegate {
      */
     def deleteMenuItem(Case item) {
         async.run {
-            workflowService.deleteCase(item.stringId)
+            workflowService.deleteCase(new DeleteCaseParams(item.stringId))
         }
     }
 
@@ -2736,12 +2807,12 @@ class ActionDelegate {
 
         options.putAll(splitPathList.collectEntries { [(it): new I18nString(it)] })
 
-        Case caseByPath = findCaseElastic("processIdentifier:$FilterRunner.MENU_NET_IDENTIFIER AND dataSet.nodePath.textValue.keyword:\"$path\"")
+        Case caseByPath = findCaseElastic("processIdentifier:$MenuProcessRunner.MENU_NET_IDENTIFIER AND dataSet.nodePath.textValue.keyword:\"$path\"")
         Set<String> childrenIds = caseByPath.dataSet[MenuItemConstants.FIELD_CHILD_ITEM_IDS].value as Set
         if (!childrenIds.isEmpty()) {
             for (String id : childrenIds) {
                 Case childFolderCase = workflowService.findOne(id)
-                options.put(childFolderCase.dataSet[MenuItemConstants.FIELD_CHILD_ITEM_IDS.value].value as String, new I18nString(childFolderCase.dataSet[MenuItemConstants.PREFERENCE_ITEM_FIELD_NODE_NAME.value].value as String))
+                options.put(childFolderCase.dataSet[MenuItemConstants.FIELD_CHILD_ITEM_IDS.value].value as String, new I18nString(childFolderCase.dataSet[MenuItemConstants.FIELD_NODE_NAME.value].value as String))
             }
         }