[NAE-1998] Implement transactions for events

- fix TransactionTest.testBasicTransactionWithFailure
- implement transactional option in DataService.setData
- implement new tests in DataServiceTest

src/main/java/com/netgrif/application/engine/transaction/NaeTransaction.java

@@ -36,6 +36,10 @@ public class NaeTransaction {
      * Transaction code to be executed under transaction.
      * */
     private Closure<?> event;
+    /**
+     * Return value of the {@link #event}
+     * */
+    private Object resultOfEvent;
     /**
      * Callback, that is called when {@link NaeTransaction#event} is successful.
      * */
@@ -72,7 +76,7 @@ public void begin() {
             protected void doInTransactionWithoutResult(TransactionStatus status) {
                 try {
                     registerTransactionCallBacks();
-                    event.call();
+                    resultOfEvent = event.call();
                     throwIfDeadlineReached(); // Transaction API does not check the timeout declared in transaction template
                 } catch (Exception rethrow) {
                     onEventException = rethrow;

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

@@ -22,6 +22,8 @@ public class SetDataParams {
     private DataSet dataSet;
     private IUser user;
     @Builder.Default
+    private boolean isTransactional = false;
+    @Builder.Default
     private Map<String, String> params = new HashMap<>();
 
     public SetDataParams(Task task, DataSet dataSet, IUser user) {

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

@@ -16,6 +16,7 @@
 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.transaction.NaeTransaction;
 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;
@@ -33,6 +34,7 @@
 import com.netgrif.application.engine.workflow.service.interfaces.ITaskService;
 import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowService;
 import com.netgrif.application.engine.workflow.web.responsebodies.DataSet;
+import groovy.lang.Closure;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.tuple.ImmutablePair;
 import org.apache.pdfbox.pdmodel.PDDocument;
@@ -42,7 +44,10 @@
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.data.domain.Page;
+import org.springframework.data.mongodb.MongoTransactionManager;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.TransactionDefinition;
+import org.springframework.transaction.annotation.Transactional;
 import org.springframework.web.multipart.MultipartFile;
 
 import javax.imageio.ImageIO;
@@ -76,6 +81,9 @@ public class DataService implements IDataService {
     @Autowired
     private IHistoryService historyService;
 
+    @Autowired
+    private MongoTransactionManager transactionManager;
+
     @Autowired
     private IValidationService validation;
 
@@ -158,6 +166,9 @@ private void fillMissingAttributes(GetDataParams getDataParams) throws IllegalAr
         }
     }
 
+    /**
+     * todo javadoc
+     * */
     @Override
     public SetDataEventOutcome setData(SetDataParams setDataParams) {
         fillMissingAttributes(setDataParams);
@@ -168,11 +179,34 @@ public SetDataEventOutcome setData(SetDataParams setDataParams) {
         if (task.getUserId() != null) {
             task.setUser(userService.findById(task.getUserId()));
         }
+
+        if (setDataParams.isTransactional()) {
+            NaeTransaction transaction = NaeTransaction.builder()
+                    .timeout(TransactionDefinition.TIMEOUT_DEFAULT)
+                    .forceCreation(false)
+                    .transactionManager(transactionManager)
+                    .event(new Closure<SetDataEventOutcome>(null) {
+                        @Override
+                        public SetDataEventOutcome call() {
+                            return doSetData(setDataParams);
+                        }
+                    })
+                    .build();
+            transaction.begin();
+            return (SetDataEventOutcome) transaction.getResultOfEvent();
+        } else {
+            return doSetData(setDataParams);
+        }
+    }
+
+    private SetDataEventOutcome doSetData(SetDataParams setDataParams) {
+        Task task = setDataParams.getTask();
         List<EventOutcome> outcomes = new ArrayList<>();
         for (Map.Entry<String, Field<?>> stringFieldEntry : setDataParams.getDataSet().getFields().entrySet()) {
             String fieldId = stringFieldEntry.getKey();
             Field<?> newDataField = stringFieldEntry.getValue();
-            outcomes.add(setDataField(task, fieldId, newDataField, setDataParams.getUser()));
+            SetDataEventOutcome setDataEventOutcome = setDataField(task, fieldId, newDataField, setDataParams.getUser());
+            outcomes.add(setDataEventOutcome);
         }
         Case useCase = workflowService.findOne(task.getCaseId());
         return new SetDataEventOutcome(useCase, task, outcomes);

src/test/groovy/com/netgrif/application/engine/transaction/TransactionTest.groovy

@@ -107,8 +107,8 @@ class TransactionTest {
 
     @Test
     void testBasicTransactionWithFailure() {
-        Case useCase = createTestCaseAndSetButton("test", "testBasicTransactionWithFailure")
         importHelper.createCase("toBeRemoved", testNet)
+        Case useCase = createTestCaseAndSetButton("test", "testBasicTransactionWithFailure")
 
         assert findAllByIdentifier("transaction_test").size() == 4
 

src/test/groovy/com/netgrif/application/engine/workflow/DataServiceTest.groovy

@@ -6,13 +6,18 @@ import com.netgrif.application.engine.petrinet.domain.DataGroup
 import com.netgrif.application.engine.petrinet.domain.DataRef
 import com.netgrif.application.engine.petrinet.domain.PetriNet
 import com.netgrif.application.engine.petrinet.domain.VersionType
+import com.netgrif.application.engine.petrinet.domain.dataset.ButtonField
+import com.netgrif.application.engine.petrinet.domain.dataset.Field
 import com.netgrif.application.engine.petrinet.domain.params.ImportPetriNetParams
 import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService
 import com.netgrif.application.engine.startup.ImportHelper
 import com.netgrif.application.engine.startup.SuperCreator
+import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.dataoutcomes.SetDataEventOutcome
 import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome
+import com.netgrif.application.engine.workflow.domain.params.SetDataParams
 import com.netgrif.application.engine.workflow.service.interfaces.IDataService
 import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowService
+import com.netgrif.application.engine.workflow.web.responsebodies.DataSet
 import groovy.transform.CompileStatic
 import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Disabled
@@ -24,6 +29,8 @@ import org.springframework.mock.web.MockMultipartFile
 import org.springframework.test.context.ActiveProfiles
 import org.springframework.test.context.junit.jupiter.SpringExtension
 
+import static org.junit.jupiter.api.Assertions.assertThrows
+
 @ExtendWith(SpringExtension.class)
 @ActiveProfiles(["test"])
 @SpringBootTest
@@ -125,6 +132,74 @@ class DataServiceTest {
         assert dataGroups.get(3).getParentTaskRefId() == "taskRef_0"
     }
 
+    @Test
+    void testTransactionalSetDataOutcomes() {
+        def aCase = importHelper.createCase("Case", this.setDataNet)
+        ButtonField buttonWithValueOne = new ButtonField()
+        buttonWithValueOne.setRawValue(1)
+
+        assert aCase != null
+
+        SetDataParams setDataParams = SetDataParams.with()
+                .useCase(aCase)
+                .user(superCreator.superUser)
+                .isTransactional(true)
+                .dataSet(new DataSet(Map.of(
+                        "button_1", (Field<Integer>) buttonWithValueOne,
+                        "button_0", (Field<Integer>) buttonWithValueOne
+                )))
+                .build()
+        SetDataEventOutcome outcome = dataService.setData(setDataParams)
+        assert outcome
+        assert outcome.getOutcomes().size() == 2
+    }
+
+    @Test
+    void testTransactionalSetDataFailure() {
+        def aCase = importHelper.createCase("Case", this.setDataNet)
+        ButtonField buttonWithValueOne = new ButtonField()
+        buttonWithValueOne.setRawValue(1)
+
+        assert aCase != null
+
+        SetDataParams setDataParams = SetDataParams.with()
+                .useCase(aCase)
+                .user(superCreator.superUser)
+                .isTransactional(true)
+                .dataSet(new DataSet(Map.of(
+                        "button_1", (Field<Integer>) buttonWithValueOne,
+                        "non_existing_button", (Field<Integer>) buttonWithValueOne
+                )))
+                .build()
+        assertThrows(IllegalArgumentException.class, { dataService.setData(setDataParams) })
+
+        aCase = workflowService.findOne(aCase.stringId)
+        assert aCase.getDataSet().get("button_1").getRawValue() != 1
+    }
+
+    @Test
+    void testTransactionalSetDataSuccess() {
+        def aCase = importHelper.createCase("Case", this.setDataNet)
+        ButtonField buttonWithValueOne = new ButtonField()
+        buttonWithValueOne.setRawValue(1)
+
+        assert aCase != null
+
+        SetDataParams setDataParams = SetDataParams.with()
+                .useCase(aCase)
+                .user(superCreator.superUser)
+                .isTransactional(false)
+                .dataSet(new DataSet(Map.of(
+                        "button_1", (Field<Integer>) buttonWithValueOne,
+                        "non_existing_button", (Field<Integer>) buttonWithValueOne
+                )))
+                .build()
+        assertThrows(IllegalArgumentException.class, { dataService.setData(setDataParams) })
+
+        aCase = workflowService.findOne(aCase.stringId)
+        assert aCase.getDataSet().get("button_1").getRawValue() == 1
+    }
+
 //    @Test
 //    void testSetDataAllowednets() {
 //        def aCase = importHelper.createCase("test allowed nets", setDataNet)