[NAE-1998] Implement transactions for events

- optimize DataService.getData

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

@@ -48,6 +48,7 @@ import com.netgrif.application.engine.workflow.domain.menu.MenuItemBody
 import com.netgrif.application.engine.workflow.domain.menu.MenuItemConstants
 import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams
 import com.netgrif.application.engine.workflow.domain.params.DeleteCaseParams
+import com.netgrif.application.engine.workflow.domain.params.GetDataParams
 import com.netgrif.application.engine.workflow.domain.params.TaskParams
 import com.netgrif.application.engine.workflow.service.FileFieldInputStream
 import com.netgrif.application.engine.workflow.service.TaskService
@@ -1024,13 +1025,22 @@ class ActionDelegate /*TODO: release/8.0.0: implements ActionAPI*/ {
 
     Map<String, Field> getData(Task task, IUser user = userService.loggedOrSystem, Map<String, String> params = [:]) {
         def useCase = workflowService.findOne(task.caseId)
-        return mapData(addGetDataOutcomeToOutcomesAndReturnData(dataService.getData(task, useCase, user, params)))
+        GetDataParams getDataParams = GetDataParams.builder()
+                .task(task)
+                .useCase(useCase)
+                .user(user)
+                .params(params)
+                .build()
+        return mapData(addGetDataOutcomeToOutcomesAndReturnData(dataService.getData(getDataParams)))
     }
 
     Map<String, Field> getData(String taskId, IUser user = userService.loggedOrSystem, Map<String, String> params = [:]) {
-        Task task = taskService.findById(taskId)
-        def useCase = workflowService.findOne(task.caseId)
-        return mapData(addGetDataOutcomeToOutcomesAndReturnData(dataService.getData(task, useCase, user, params)))
+        GetDataParams getDataParams = GetDataParams.builder()
+                .taskId(taskId)
+                .user(user)
+                .params(params)
+                .build()
+        return mapData(addGetDataOutcomeToOutcomesAndReturnData(dataService.getData(getDataParams)))
     }
 
     Map<String, Field> getData(Transition transition, IUser user = userService.loggedOrSystem, Map<String, String> params = [:]) {
@@ -1043,7 +1053,13 @@ class ActionDelegate /*TODO: release/8.0.0: implements ActionAPI*/ {
         if (!task) {
             return new HashMap<String, Field>()
         }
-        return mapData(addGetDataOutcomeToOutcomesAndReturnData(dataService.getData(task, useCase, user, params)))
+        GetDataParams getDataParams = GetDataParams.builder()
+                .task(task)
+                .useCase(useCase)
+                .user(user)
+                .params(params)
+                .build()
+        return mapData(addGetDataOutcomeToOutcomesAndReturnData(dataService.getData(getDataParams)))
     }
 
     private List<DataRef> addGetDataOutcomeToOutcomesAndReturnData(GetDataEventOutcome outcome) {

src/main/groovy/com/netgrif/application/engine/startup/ImportHelper.groovy

@@ -18,6 +18,7 @@ import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.tas
 import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.taskoutcomes.CancelTaskEventOutcome
 import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.taskoutcomes.FinishTaskEventOutcome
 import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams
+import com.netgrif.application.engine.workflow.domain.params.GetDataParams
 import com.netgrif.application.engine.workflow.domain.params.TaskParams
 import com.netgrif.application.engine.workflow.domain.repositories.CaseRepository
 import com.netgrif.application.engine.workflow.service.interfaces.IDataService
@@ -196,7 +197,7 @@ class ImportHelper {
     }
 
     List<DataRef> getTaskData(String taskTitle, String caseId) {
-        return dataService.getData(getTaskId(taskTitle, caseId), superCreator.getSuperUser()).getData()
+        return dataService.getData(new GetDataParams(getTaskId(taskTitle, caseId), superCreator.getSuperUser())).getData()
     }
 
     void updateSuperUser() {

src/main/java/com/netgrif/application/engine/workflow/domain/params/GetDataParams.java

@@ -0,0 +1,35 @@
+package com.netgrif.application.engine.workflow.domain.params;
+
+import com.netgrif.application.engine.auth.domain.IUser;
+import com.netgrif.application.engine.workflow.domain.Case;
+import com.netgrif.application.engine.workflow.domain.Task;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+
+import java.util.HashMap;
+import java.util.Map;
+
+@Data
+@Builder
+@AllArgsConstructor
+public class GetDataParams {
+
+    private String taskId;
+    private Task task;
+    private IUser user;
+    private Case useCase;
+    @Builder.Default
+    private Map<String, String> params = new HashMap<>();
+
+    public GetDataParams(Task task, Case useCase, IUser user) {
+        this.task = task;
+        this.useCase = useCase;
+        this.user = user;
+    }
+
+    public GetDataParams(String taskId, IUser user) {
+        this.taskId = taskId;
+        this.user = user;
+    }
+}

src/main/java/com/netgrif/application/engine/workflow/service/DataService.java

@@ -9,15 +9,13 @@
 import com.netgrif.application.engine.importer.model.DataEventType;
 import com.netgrif.application.engine.importer.model.DataType;
 import com.netgrif.application.engine.importer.model.LayoutType;
-import com.netgrif.application.engine.importer.service.FieldFactory;
 import com.netgrif.application.engine.petrinet.domain.Component;
 import com.netgrif.application.engine.petrinet.domain.*;
 import com.netgrif.application.engine.petrinet.domain.dataset.*;
 import com.netgrif.application.engine.petrinet.domain.dataset.logic.FieldBehavior;
 import com.netgrif.application.engine.petrinet.domain.dataset.logic.action.ActionRunner;
 import com.netgrif.application.engine.petrinet.domain.events.DataEvent;
 import com.netgrif.application.engine.petrinet.domain.events.EventPhase;
-import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService;
 import com.netgrif.application.engine.validation.service.interfaces.IValidationService;
 import com.netgrif.application.engine.workflow.domain.Case;
 import com.netgrif.application.engine.workflow.domain.DataFieldBehavior;
@@ -28,6 +26,7 @@
 import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.dataoutcomes.GetDataGroupsEventOutcome;
 import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.dataoutcomes.SetDataEventOutcome;
 import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.taskoutcomes.TaskEventOutcome;
+import com.netgrif.application.engine.workflow.domain.params.GetDataParams;
 import com.netgrif.application.engine.workflow.service.interfaces.IDataService;
 import com.netgrif.application.engine.workflow.service.interfaces.IEventService;
 import com.netgrif.application.engine.workflow.service.interfaces.ITaskService;
@@ -41,9 +40,9 @@
 import org.bson.types.ObjectId;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
-import org.springframework.context.ApplicationEventPublisher;
 import org.springframework.data.domain.Page;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
 import org.springframework.web.multipart.MultipartFile;
 
 import javax.imageio.ImageIO;
@@ -60,62 +59,46 @@
 public class DataService implements IDataService {
 
     @Autowired
-    protected ApplicationEventPublisher publisher;
+    private ITaskService taskService;
 
     @Autowired
-    protected ITaskService taskService;
+    private IWorkflowService workflowService;
 
     @Autowired
-    protected IWorkflowService workflowService;
+    private IUserService userService;
 
     @Autowired
-    protected IUserService userService;
+    private ActionRunner actionsRunner;
 
     @Autowired
-    protected FieldFactory fieldFactory;
+    private IEventService eventService;
 
     @Autowired
-    protected ActionRunner actionsRunner;
+    private IHistoryService historyService;
 
     @Autowired
-    protected IEventService eventService;
-
-    @Autowired
-    protected IHistoryService historyService;
-
-    @Autowired
-    protected IPetriNetService petriNetService;
-
-    @Autowired
-    protected IValidationService validation;
+    private IValidationService validation;
 
     @Value("${nae.image.preview.scaling.px:400}")
-    protected int imageScale;
+    private int imageScale;
 
     @Value("${nae.validation.setData.enable:false}")
-    protected boolean validationEnable;
+    private boolean validationEnable;
 
+    /**
+     * todo javadoc
+     * */
     @Override
-    public GetDataEventOutcome getData(String taskId, IUser user) {
-        return getData(taskId, user, new HashMap<>());
-    }
-
-    @Override
-    public GetDataEventOutcome getData(String taskId, IUser user, Map<String, String> params) {
-        Task task = taskService.findOne(taskId);
-        Case useCase = workflowService.findOne(task.getCaseId());
-
-        return getData(task, useCase, user, params);
-    }
+    @Transactional
+    public GetDataEventOutcome getData(GetDataParams getDataParams) {
+        fillMissingAttributes(getDataParams);
 
-    @Override
-    public GetDataEventOutcome getData(Task task, Case useCase, IUser user) {
-        return getData(task, useCase, user, new HashMap<>());
-    }
+        Case useCase = getDataParams.getUseCase();
+        Task task = getDataParams.getTask();
+        IUser user = getDataParams.getUser();
 
-    @Override
-    public GetDataEventOutcome getData(Task task, Case useCase, IUser user, Map<String, String> params) {
         log.info("[{}]: Getting data of task {} [{}]", useCase.getStringId(), task.getTransitionId(), task.getStringId());
+
         Transition transition = useCase.getPetriNet().getTransition(task.getTransitionId());
         Map<String, DataRef> dataRefs = transition.getDataSet();
         List<DataRef> dataSetFields = new ArrayList<>();
@@ -128,7 +111,9 @@ public GetDataEventOutcome getData(Task task, Case useCase, IUser user, Map<Stri
             if (behavior.isForbidden()) {
                 return;
             }
-            outcome.addOutcomes(resolveDataEvents(field, DataEventType.GET, EventPhase.PRE, useCase, task, null, params));
+            outcome.addOutcomes(resolveDataEvents(field, DataEventType.GET, EventPhase.PRE, useCase, task, null,
+                    getDataParams.getParams()));
+
             historyService.save(new GetDataEventLog(task, useCase, EventPhase.PRE, user));
 
             if (outcome.getMessage() == null) {
@@ -139,7 +124,9 @@ public GetDataEventOutcome getData(Task task, Case useCase, IUser user, Map<Stri
             dataRef.setBehavior(behavior);
             dataSetFields.add(dataRef);
             // TODO: release/8.0.0 params into outcome?
-            outcome.addOutcomes(resolveDataEvents(field, DataEventType.GET, EventPhase.POST, useCase, task, null, params));
+            outcome.addOutcomes(resolveDataEvents(field, DataEventType.GET, EventPhase.POST, useCase, task, null,
+                    getDataParams.getParams()));
+
             historyService.save(new GetDataEventLog(task, useCase, EventPhase.POST, user));
         });
 
@@ -148,6 +135,20 @@ public GetDataEventOutcome getData(Task task, Case useCase, IUser user, Map<Stri
         return outcome;
     }
 
+    private void fillMissingAttributes(GetDataParams getDataParams) throws IllegalArgumentException {
+        if (getDataParams.getUser() == null) {
+            throw new IllegalArgumentException("User must be provided on get data.");
+        }
+        if (getDataParams.getTask() == null) {
+            Task task = taskService.findOne(getDataParams.getTaskId());
+            getDataParams.setTask(task);
+        }
+        if (getDataParams.getUseCase() == null) {
+            Case useCase = workflowService.findOne(getDataParams.getTask().getCaseId());
+            getDataParams.setUseCase(useCase);
+        }
+    }
+
     @Override
     public SetDataEventOutcome setData(String taskId, DataSet dataSet, IUser user) {
         return setData(taskId, dataSet, user, new HashMap<>());
@@ -255,12 +256,14 @@ private void setOutcomeMessage(Task task, Case useCase, TaskEventOutcome outcome
     }
 
     @Override
+    @Transactional
     public GetDataGroupsEventOutcome getDataGroups(String taskId, Locale locale, LoggedUser loggedUser) {
         IUser user = userService.getUserFromLoggedUser(loggedUser);
         return getDataGroups(taskId, locale, user);
     }
 
     @Override
+    @Transactional
     public GetDataGroupsEventOutcome getDataGroups(String taskId, Locale locale, IUser user) {
         return getDataGroups(taskId, locale, new HashSet<>(), 0, null, user);
     }
@@ -273,7 +276,7 @@ private GetDataGroupsEventOutcome getDataGroups(String taskId, Locale locale, Se
         GetDataGroupsEventOutcome outcome = new GetDataGroupsEventOutcome(useCase, task);
         log.info("Getting groups of task " + taskId + " in case " + useCase.getTitle() + " level: " + level);
         List<DataGroup> resultDataGroups = new ArrayList<>();
-        List<DataRef> data = getData(task, useCase, user).getData();
+        List<DataRef> data = getData(new GetDataParams(task, useCase, user)).getData();
         Map<String, DataRef> dataFieldMap = data.stream().collect(Collectors.toMap(DataRef::getFieldId, field -> field));
         List<DataGroup> dataGroups = transition.getDataGroups().values().stream().map(DataGroup::clone).collect(Collectors.toList());
         for (DataGroup dataGroup : dataGroups) {
@@ -661,19 +664,19 @@ private void writeFile(MultipartFile multipartFile, File file) throws IOExceptio
         fout.close();
     }
 
-    protected boolean upload(Case useCase, FileField field, MultipartFile multipartFile) {
+    private boolean upload(Case useCase, FileField field, MultipartFile multipartFile) {
         throw new UnsupportedOperationException("Upload new file to the remote storage is not implemented yet.");
     }
 
-    protected boolean upload(Case useCase, FileListField field, MultipartFile[] multipartFiles) {
+    private boolean upload(Case useCase, FileListField field, MultipartFile[] multipartFiles) {
         throw new UnsupportedOperationException("Upload new files to the remote storage is not implemented yet.");
     }
 
-    protected boolean deleteRemote(Case useCase, FileField field) {
+    private boolean deleteRemote(Case useCase, FileField field) {
         throw new UnsupportedOperationException("Delete file from the remote storage is not implemented yet.");
     }
 
-    protected boolean deleteRemote(Case useCase, FileListField field, String name) {
+    private boolean deleteRemote(Case useCase, FileListField field, String name) {
         throw new UnsupportedOperationException("Delete file from the remote storage is not implemented yet.");
     }
 

src/main/java/com/netgrif/application/engine/workflow/service/TaskService.java

@@ -37,6 +37,7 @@
 import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.dataoutcomes.SetDataEventOutcome;
 import com.netgrif.application.engine.workflow.domain.outcomes.CreateTasksOutcome;
 import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.taskoutcomes.*;
+import com.netgrif.application.engine.workflow.domain.params.GetDataParams;
 import com.netgrif.application.engine.workflow.domain.params.TaskParams;
 import com.netgrif.application.engine.workflow.domain.repositories.TaskRepository;
 import com.netgrif.application.engine.workflow.domain.triggers.AutoTrigger;
@@ -119,8 +120,7 @@ public List<EventOutcome> executeTask(Task task, Case useCase) {
             AssignTaskEventOutcome assignOutcome = assignTask(new TaskParams(task));
             outcomes.add(assignOutcome);
             log.info("getData [{}] in case [{}]", task.getTitle(), useCase.getTitle());
-            GetDataEventOutcome getDataOutcome = dataService.getData(assignOutcome.getTask(), assignOutcome.getCase(),
-                    userService.getSystem());
+            GetDataEventOutcome getDataOutcome = dataService.getData(new GetDataParams(task, useCase, userService.getSystem()));
             outcomes.add(getDataOutcome);
             log.info("finishTask [{}] in case [{}]", task.getTitle(), useCase.getTitle());
             outcomes.add(finishTask(new TaskParams(getDataOutcome.getTask())));

src/main/java/com/netgrif/application/engine/workflow/service/interfaces/IDataService.java

@@ -11,6 +11,7 @@
 import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.dataoutcomes.GetDataEventOutcome;
 import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.dataoutcomes.GetDataGroupsEventOutcome;
 import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.dataoutcomes.SetDataEventOutcome;
+import com.netgrif.application.engine.workflow.domain.params.GetDataParams;
 import com.netgrif.application.engine.workflow.service.FileFieldInputStream;
 import com.netgrif.application.engine.workflow.web.responsebodies.DataSet;
 import org.springframework.data.domain.Page;
@@ -25,13 +26,7 @@
 
 public interface IDataService {
 
-    GetDataEventOutcome getData(String taskId, IUser user);
-
-    GetDataEventOutcome getData(String taskId, IUser user, Map<String, String> params);
-
-    GetDataEventOutcome getData(Task task, Case useCase, IUser user);
-
-    GetDataEventOutcome getData(Task task, Case useCase, IUser user, Map<String, String> params);
+    GetDataEventOutcome getData(GetDataParams getDataParams);
 
     SetDataEventOutcome setData(String taskId, DataSet values, IUser user);
 

src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicValidationPerformanceTest.groovy

@@ -8,6 +8,7 @@ import com.netgrif.application.engine.startup.SuperCreator
 import com.netgrif.application.engine.workflow.domain.Case
 import com.netgrif.application.engine.workflow.domain.Task
 import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome
+import com.netgrif.application.engine.workflow.domain.params.GetDataParams
 import com.netgrif.application.engine.workflow.service.interfaces.IDataService
 import com.netgrif.application.engine.workflow.service.interfaces.ITaskService
 import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowService
@@ -77,7 +78,7 @@ class DynamicValidationPerformanceTest {
 
     Map<String, Field> getData(Case useCase) {
         Task task = task(useCase)
-        return dataService.getData(task, useCase, superCreator.getSuperUser()).getData().collectEntries { [(it.fieldId): (it)] }
+        return dataService.getData(new GetDataParams(task, useCase, superCreator.getSuperUser())).getData().collectEntries { [(it.fieldId): (it)] }
     }
 
     Task task(Case useCase) {