From c1b53c8a4f85f085bf43f970e5efb79283dcebc7 Mon Sep 17 00:00:00 2001 From: chvostek Date: Tue, 23 Jul 2024 16:37:30 +0200 Subject: [PATCH 01/48] [NAE-1998] Implement transactions for events - init transaction implementation --- .../logic/action/ActionDelegate.groovy | 42 +++++++++++- .../dataset/logic/action/ActionRunner.groovy | 17 ++++- .../engine/transaction/NaeTransaction.java | 67 +++++++++++++++++++ .../application/engine/ApplicationEngine.java | 3 +- .../configuration/mongo/MongoConfig.java | 27 ++++++++ .../domain/roles/ProcessRolePermission.java | 4 ++ 6 files changed, 156 insertions(+), 4 deletions(-) create mode 100644 src/main/groovy/com/netgrif/application/engine/transaction/NaeTransaction.java create mode 100644 src/main/java/com/netgrif/application/engine/configuration/mongo/MongoConfig.java diff --git a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy index 8dcf9319d63..ab5400810e0 100644 --- a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy +++ b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy @@ -34,6 +34,7 @@ import com.netgrif.application.engine.petrinet.service.interfaces.IUriService import com.netgrif.application.engine.rules.domain.RuleRepository import com.netgrif.application.engine.startup.DefaultFiltersRunner import com.netgrif.application.engine.startup.FilterRunner +import com.netgrif.application.engine.transaction.NaeTransaction import com.netgrif.application.engine.utils.FullPageRequest import com.netgrif.application.engine.workflow.domain.* import com.netgrif.application.engine.workflow.domain.eventoutcomes.EventOutcome @@ -56,15 +57,16 @@ import groovy.util.logging.Slf4j import org.bson.types.ObjectId import org.quartz.Scheduler import org.springframework.beans.factory.annotation.Autowired +import org.springframework.beans.factory.annotation.Qualifier import org.springframework.beans.factory.annotation.Value import org.springframework.context.i18n.LocaleContextHolder import org.springframework.data.domain.Page import org.springframework.data.domain.PageRequest import org.springframework.data.domain.Pageable +import org.springframework.data.mongodb.MongoTransactionManager import java.text.Normalizer import java.util.stream.Collectors - /** * ActionDelegate class contains Actions API methods. */ @@ -177,6 +179,9 @@ class ActionDelegate /*TODO: release/8.0.0: implements ActionAPI*/ { @Autowired PublicViewProperties publicViewProperties + @Autowired + MongoTransactionManager transactionManager + FrontendActionOutcome Frontend /** @@ -209,6 +214,41 @@ class ActionDelegate /*TODO: release/8.0.0: implements ActionAPI*/ { this.Frontend = new FrontendActionOutcome(this.useCase, this.task, this.outcomes) } + /** + * todo + * */ + def transaction(boolean forceCreation = false, int timeout, Closure event) { + def transactionBuilder = NaeTransaction.builder() + .timeout(timeout) + .forceCreation(forceCreation) + .event(event) + .transactionManager(transactionManager) + return [ + onCommit : { Closure onCommitClosure -> + transactionBuilder.onCommit(onCommitClosure) + [ + onRollBack: { Closure onRollBackClosure -> + transactionBuilder.onRollBack(onRollBackClosure) + executeTransaction(transactionBuilder.build()) + } + ] + }, + onRollBack: { Closure onRollBackClosure -> + transactionBuilder.onRollBack(onRollBackClosure) + executeTransaction(transactionBuilder.build()) + } + ] + } + + protected void executeTransaction(NaeTransaction transaction) { + try { + transaction.begin() + } catch (Exception e) { + log.error("Transaction failed with error: %", e.getMessage(), e) + // todo log also action.toString() + } + } + void initFieldsMap(Map fieldIds, Case useCase) { fieldIds.each { name, id -> set(name, useCase.getDataSet().get(id)) diff --git a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionRunner.groovy b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionRunner.groovy index 6c6aea0f0cc..0ae9a245848 100644 --- a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionRunner.groovy +++ b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionRunner.groovy @@ -1,8 +1,8 @@ package com.netgrif.application.engine.petrinet.domain.dataset.logic.action - import com.netgrif.application.engine.petrinet.domain.Function import com.netgrif.application.engine.petrinet.domain.dataset.Field +import com.netgrif.application.engine.transaction.NaeTransaction import com.netgrif.application.engine.workflow.domain.Case import com.netgrif.application.engine.workflow.domain.Task import com.netgrif.application.engine.workflow.domain.eventoutcomes.EventOutcome @@ -10,7 +10,9 @@ import com.netgrif.application.engine.workflow.service.interfaces.IFieldActionsC import groovy.util.logging.Slf4j import org.springframework.beans.factory.annotation.Autowired import org.springframework.beans.factory.annotation.Lookup +import org.springframework.data.mongodb.MongoTransactionManager import org.springframework.stereotype.Component +import org.springframework.transaction.support.TransactionSynchronizationManager @Slf4j @Component @@ -23,6 +25,8 @@ abstract class ActionRunner { @Autowired private IFieldActionsCacheService actionsCacheService + @Autowired MongoTransactionManager transactionManager + private Map actionsCache = new HashMap<>() List run(Action action, Case useCase, Map params, List functions = []) { @@ -37,7 +41,16 @@ abstract class ActionRunner { def code = getActionCode(action, functions) try { code.init(action, useCase, task, changes, this, params) - code() + if (TransactionSynchronizationManager.isSynchronizationActive()) { + def transaction = NaeTransaction.builder() + .forceCreation(false) + .transactionManager(transactionManager) + .event(code) + .build() + transaction.begin() + } else { + code() + } } catch (Exception e) { log.error("Action: $action.definition") throw e diff --git a/src/main/groovy/com/netgrif/application/engine/transaction/NaeTransaction.java b/src/main/groovy/com/netgrif/application/engine/transaction/NaeTransaction.java new file mode 100644 index 00000000000..2b78025ba1c --- /dev/null +++ b/src/main/groovy/com/netgrif/application/engine/transaction/NaeTransaction.java @@ -0,0 +1,67 @@ +package com.netgrif.application.engine.transaction; + +import groovy.lang.Closure; +import lombok.Builder; +import lombok.Data; +import org.springframework.data.mongodb.MongoTransactionManager; +import org.springframework.transaction.TransactionDefinition; +import org.springframework.transaction.TransactionStatus; +import org.springframework.transaction.support.*; + +/** + * todo + * */ +@Data +@Builder +public class NaeTransaction { + + private int timeout; + private boolean forceCreation; + @SuppressWarnings("rawtypes") + private Closure event; + @SuppressWarnings("rawtypes") + private Closure onCommit; + @SuppressWarnings("rawtypes") + private Closure onRollBack; + + /** + * todo + * */ + private final MongoTransactionManager transactionManager; + + /** + * todo + * */ + public void begin() { + TransactionTemplate transactionTemplate = new TransactionTemplate(transactionManager); + transactionTemplate.setTimeout(timeout); + + if (forceCreation) { + transactionTemplate.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW); + } else { + transactionTemplate.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED); + } + + transactionTemplate.execute(new TransactionCallbackWithoutResult() { + protected void doInTransactionWithoutResult(TransactionStatus status) { + registerTransactionCallBacks(); + event.call(); + } + }); + } + + /** + * todo + * */ + private void registerTransactionCallBacks() { + TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization(){ + public void afterCompletion(int status) { + if (status == STATUS_COMMITTED) { + onCommit.run(); + } else if (status == STATUS_ROLLED_BACK) { + onRollBack.run(); + } + } + }); + } +} diff --git a/src/main/java/com/netgrif/application/engine/ApplicationEngine.java b/src/main/java/com/netgrif/application/engine/ApplicationEngine.java index fc55e78133a..9dbe68e7436 100644 --- a/src/main/java/com/netgrif/application/engine/ApplicationEngine.java +++ b/src/main/java/com/netgrif/application/engine/ApplicationEngine.java @@ -17,8 +17,8 @@ import org.springframework.data.mongodb.config.EnableMongoAuditing; import org.springframework.data.mongodb.core.convert.MongoCustomConversions; import org.springframework.hateoas.config.EnableHypermediaSupport; -import org.springframework.hateoas.server.LinkRelationProvider; import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity; +import org.springframework.transaction.annotation.EnableTransactionManagement; import java.util.ArrayList; import java.util.List; @@ -26,6 +26,7 @@ @EnableCaching @EnableHypermediaSupport(type = EnableHypermediaSupport.HypermediaType.HAL) @EnableGlobalMethodSecurity(prePostEnabled = true) +@EnableTransactionManagement @EnableAspectJAutoProxy @SpringBootApplication(exclude = {DataSourceAutoConfiguration.class}) @EnableMongoAuditing diff --git a/src/main/java/com/netgrif/application/engine/configuration/mongo/MongoConfig.java b/src/main/java/com/netgrif/application/engine/configuration/mongo/MongoConfig.java new file mode 100644 index 00000000000..e2125c52792 --- /dev/null +++ b/src/main/java/com/netgrif/application/engine/configuration/mongo/MongoConfig.java @@ -0,0 +1,27 @@ +package com.netgrif.application.engine.configuration.mongo; + +import lombok.RequiredArgsConstructor; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.autoconfigure.mongo.MongoProperties; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import org.springframework.data.mongodb.MongoTransactionManager; +import org.springframework.data.mongodb.MongoDatabaseFactory; +import org.springframework.data.mongodb.config.AbstractMongoClientConfiguration; + +@Configuration +@RequiredArgsConstructor +public class MongoConfig extends AbstractMongoClientConfiguration { + + private final MongoProperties properties; + + @Bean + MongoTransactionManager transactionManager(MongoDatabaseFactory dbFactory) { + return new MongoTransactionManager(dbFactory); + } + + @Override + protected String getDatabaseName() { + return properties.getDatabase(); + } +} diff --git a/src/main/java/com/netgrif/application/engine/petrinet/domain/roles/ProcessRolePermission.java b/src/main/java/com/netgrif/application/engine/petrinet/domain/roles/ProcessRolePermission.java index fb76dff6b2c..69facc652ba 100644 --- a/src/main/java/com/netgrif/application/engine/petrinet/domain/roles/ProcessRolePermission.java +++ b/src/main/java/com/netgrif/application/engine/petrinet/domain/roles/ProcessRolePermission.java @@ -11,4 +11,8 @@ public enum ProcessRolePermission { public String value() { return super.name().toLowerCase(); } + + public static ProcessRolePermission fromValue(String v) { + return valueOf(v); + } } From 75c9f6238aa2d3aa903070a2a99de1f478ee45b6 Mon Sep 17 00:00:00 2001 From: chvostek Date: Wed, 24 Jul 2024 15:46:39 +0200 Subject: [PATCH 02/48] [NAE-1998] Implement transactions for events - move and update NaeTransaction - rework transaction execution in ActionDelegate - add TransactionTest file with resource file --- .../logic/action/ActionDelegate.groovy | 42 +++---- .../dataset/logic/action/ActionRunner.groovy | 1 + .../engine/transaction/NaeTransaction.java | 67 ----------- .../engine/transaction/NaeTransaction.java | 99 ++++++++++++++++ .../engine/transaction/TransactionTest.java | 107 ++++++++++++++++++ .../transaction/transaction_test.xml | 51 +++++++++ 6 files changed, 280 insertions(+), 87 deletions(-) delete mode 100644 src/main/groovy/com/netgrif/application/engine/transaction/NaeTransaction.java create mode 100644 src/main/java/com/netgrif/application/engine/transaction/NaeTransaction.java create mode 100644 src/test/java/com/netgrif/application/engine/transaction/TransactionTest.java create mode 100644 src/test/resources/petriNets/transaction/transaction_test.xml diff --git a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy index ab5400810e0..b9406250d2e 100644 --- a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy +++ b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy @@ -57,13 +57,13 @@ import groovy.util.logging.Slf4j import org.bson.types.ObjectId import org.quartz.Scheduler import org.springframework.beans.factory.annotation.Autowired -import org.springframework.beans.factory.annotation.Qualifier import org.springframework.beans.factory.annotation.Value import org.springframework.context.i18n.LocaleContextHolder import org.springframework.data.domain.Page import org.springframework.data.domain.PageRequest import org.springframework.data.domain.Pageable import org.springframework.data.mongodb.MongoTransactionManager +import org.springframework.transaction.TransactionDefinition import java.text.Normalizer import java.util.stream.Collectors @@ -217,35 +217,37 @@ class ActionDelegate /*TODO: release/8.0.0: implements ActionAPI*/ { /** * todo * */ - def transaction(boolean forceCreation = false, int timeout, Closure event) { + @NamedVariant + void transaction(int timeout = TransactionDefinition.TIMEOUT_DEFAULT, boolean forceCreation = false, Closure code, + Closure onCommit = null, Closure onRollBack = null) { def transactionBuilder = NaeTransaction.builder() .timeout(timeout) .forceCreation(forceCreation) - .event(event) + .event(code) + .onCommit(onCommit) + .onRollBack(onRollBack) .transactionManager(transactionManager) - return [ - onCommit : { Closure onCommitClosure -> - transactionBuilder.onCommit(onCommitClosure) - [ - onRollBack: { Closure onRollBackClosure -> - transactionBuilder.onRollBack(onRollBackClosure) - executeTransaction(transactionBuilder.build()) - } - ] - }, - onRollBack: { Closure onRollBackClosure -> - transactionBuilder.onRollBack(onRollBackClosure) - executeTransaction(transactionBuilder.build()) - } - ] + + NaeTransaction transaction = transactionBuilder.build() + executeTransaction(transaction) + throwIfCallBackFailed(transaction) + } + + /** + * todo + * */ + protected void throwIfCallBackFailed(NaeTransaction transaction) { + if (transaction.onCallBackException != null) { + log.error("Transaction synchronization call back execution failed with message: {} ", transaction.onCallBackException.getMessage()) + throw transaction.onCallBackException + } } protected void executeTransaction(NaeTransaction transaction) { try { transaction.begin() } catch (Exception e) { - log.error("Transaction failed with error: %", e.getMessage(), e) - // todo log also action.toString() + log.error("Transaction failed with error: {}", e.getMessage(), e) } } diff --git a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionRunner.groovy b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionRunner.groovy index 0ae9a245848..b42dc490233 100644 --- a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionRunner.groovy +++ b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionRunner.groovy @@ -47,6 +47,7 @@ abstract class ActionRunner { .transactionManager(transactionManager) .event(code) .build() + transaction.setForceCreation(false) transaction.begin() } else { code() diff --git a/src/main/groovy/com/netgrif/application/engine/transaction/NaeTransaction.java b/src/main/groovy/com/netgrif/application/engine/transaction/NaeTransaction.java deleted file mode 100644 index 2b78025ba1c..00000000000 --- a/src/main/groovy/com/netgrif/application/engine/transaction/NaeTransaction.java +++ /dev/null @@ -1,67 +0,0 @@ -package com.netgrif.application.engine.transaction; - -import groovy.lang.Closure; -import lombok.Builder; -import lombok.Data; -import org.springframework.data.mongodb.MongoTransactionManager; -import org.springframework.transaction.TransactionDefinition; -import org.springframework.transaction.TransactionStatus; -import org.springframework.transaction.support.*; - -/** - * todo - * */ -@Data -@Builder -public class NaeTransaction { - - private int timeout; - private boolean forceCreation; - @SuppressWarnings("rawtypes") - private Closure event; - @SuppressWarnings("rawtypes") - private Closure onCommit; - @SuppressWarnings("rawtypes") - private Closure onRollBack; - - /** - * todo - * */ - private final MongoTransactionManager transactionManager; - - /** - * todo - * */ - public void begin() { - TransactionTemplate transactionTemplate = new TransactionTemplate(transactionManager); - transactionTemplate.setTimeout(timeout); - - if (forceCreation) { - transactionTemplate.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW); - } else { - transactionTemplate.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED); - } - - transactionTemplate.execute(new TransactionCallbackWithoutResult() { - protected void doInTransactionWithoutResult(TransactionStatus status) { - registerTransactionCallBacks(); - event.call(); - } - }); - } - - /** - * todo - * */ - private void registerTransactionCallBacks() { - TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization(){ - public void afterCompletion(int status) { - if (status == STATUS_COMMITTED) { - onCommit.run(); - } else if (status == STATUS_ROLLED_BACK) { - onRollBack.run(); - } - } - }); - } -} diff --git a/src/main/java/com/netgrif/application/engine/transaction/NaeTransaction.java b/src/main/java/com/netgrif/application/engine/transaction/NaeTransaction.java new file mode 100644 index 00000000000..7adc1490498 --- /dev/null +++ b/src/main/java/com/netgrif/application/engine/transaction/NaeTransaction.java @@ -0,0 +1,99 @@ +package com.netgrif.application.engine.transaction; + +import groovy.lang.Closure; +import lombok.Builder; +import lombok.Data; +import lombok.extern.slf4j.Slf4j; +import org.springframework.data.mongodb.MongoTransactionManager; +import org.springframework.transaction.TransactionStatus; +import org.springframework.transaction.annotation.Propagation; +import org.springframework.transaction.support.*; + +import static org.springframework.transaction.support.TransactionSynchronization.STATUS_COMMITTED; +import static org.springframework.transaction.support.TransactionSynchronization.STATUS_ROLLED_BACK; + +/** + * todo + * */ +@Data +@Slf4j +@Builder +public class NaeTransaction { + + private int timeout; + private boolean forceCreation; + private Closure event; + private Closure onCommit; + private Closure onRollBack; + private Exception onCallBackException; + private Propagation propagation; + + /** + * todo + * */ + private final MongoTransactionManager transactionManager; + + /** + * todo + * */ + public void begin() { + TransactionTemplate transactionTemplate = new TransactionTemplate(transactionManager); + transactionTemplate.setTimeout(timeout); + transactionTemplate.setPropagationBehavior(propagation.value()); + + transactionTemplate.execute(new TransactionCallbackWithoutResult() { + protected void doInTransactionWithoutResult(TransactionStatus status) { + registerTransactionCallBacks(); + event.call(); + } + }); + } + + /** + * todo + * does not log the error in the callback + * */ + private void registerTransactionCallBacks() { + TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization(){ + public void afterCompletion(int status) { + if (canCallOnCommit(status)) { + runTransactionCallBack(onCommit); + } else if (canCallOnRollBack(status)) { + runTransactionCallBack(onRollBack); + } + } + }); + } + + private boolean canCallOnCommit(int status) { + return status == STATUS_COMMITTED && onCommit != null; + } + + private boolean canCallOnRollBack(int status) { + return status == STATUS_ROLLED_BACK && onCommit != null; + } + + /** + * todo + * */ + private void runTransactionCallBack(Closure callBack) { + try { + callBack.run(); + } catch (Exception e) { + // Transaction manager API swallows the exception + onCallBackException = e; + throw e; + } + } + + /** + * todo + * */ + public static class NaeTransactionBuilder { + public NaeTransactionBuilder forceCreation(boolean forceCreation) { + propagation = forceCreation ? Propagation.REQUIRES_NEW : Propagation.REQUIRED; + this.forceCreation = forceCreation; + return this; + } + } +} diff --git a/src/test/java/com/netgrif/application/engine/transaction/TransactionTest.java b/src/test/java/com/netgrif/application/engine/transaction/TransactionTest.java new file mode 100644 index 00000000000..34ed5a211b3 --- /dev/null +++ b/src/test/java/com/netgrif/application/engine/transaction/TransactionTest.java @@ -0,0 +1,107 @@ +package com.netgrif.application.engine.transaction; + +import com.netgrif.application.engine.TestHelper; +import com.netgrif.application.engine.petrinet.domain.VersionType; +import com.netgrif.application.engine.petrinet.domain.throwable.MissingPetriNetMetaDataException; +import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService; +import com.netgrif.application.engine.startup.SuperCreator; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.test.context.ActiveProfiles; + +import java.io.FileInputStream; +import java.io.IOException; + +@SpringBootTest +@ActiveProfiles({"test"}) +public class TransactionTest { + + @Autowired + private TestHelper testHelper; + + @Autowired + private IPetriNetService petriNetService; + + @Autowired + private SuperCreator superCreator; + + @BeforeEach + public void before() throws IOException, MissingPetriNetMetaDataException { + testHelper.truncateDbs(); + petriNetService.importPetriNet(new FileInputStream("src/test/resources/test_transaction.xml"), + VersionType.MAJOR, superCreator.getLoggedSuper()); + } + + @Test + public void testBasicTransaction() { + // no multilevel + // assert onCommit + // consider onAlways + } + + @Test + public void testBasicTransactionWithFailure() { + // no multilevel + // assert onRollBack + // consider onAlways + } + + @Test + public void testFailureInCallBackThrowsError() { + // no multilevel + // assert onRollBack + } + + + @Test + public void testTimeout() { + // assert if after some time the transaction is rolled back + } + + @Test + public void testTransactionRaceCondition() { + // assert failure in one of two concurrent transactions + } + + @Test + public void testNestedJoinedTransactions() { + // assert if all happy paths are executed + // consider onAlways + } + + @Test + public void testNestedDifferentTransactions() { + // assert if all happy paths are executed + // consider onAlways + } + + @Test + public void testNestedJoinedTransactionsWithFailureInParentTransaction() { + // assert if runtime exception causes all onRollBacks + // consider onAlways + } + + @Test + public void testNestedJoinedTransactionsWithFailureInNestedTransaction() { + // assert if runtime exception causes all onRollBacks + // consider onAlways + } + + @Test + public void testNestedDifferentTransactionsWithFailureInParentTransaction() { + // assert if runtime exception (in parent action) causes only relevant onRollBacks + // consider onAlways + + // assert if runtime exception (in action where definition of different transition is) causes only relevant onRollBacks + // consider onAlways + } + + @Test + public void testNestedDifferentTransactionsWithFailureInNestedTransaction() { + // assert if runtime exception causes only relevant onRollBacks + // consider onAlways + } + +} diff --git a/src/test/resources/petriNets/transaction/transaction_test.xml b/src/test/resources/petriNets/transaction/transaction_test.xml new file mode 100644 index 00000000000..9246b4fbb48 --- /dev/null +++ b/src/test/resources/petriNets/transaction/transaction_test.xml @@ -0,0 +1,51 @@ + + transaction_test + 1.0.0 + TRN + transaction_test + device_hub + true + true + false + + + text_without_action + + </data> + <data type="text"> + <id>text_2</id> + <title/> + </data> + + <data type="button"> + <id>testBasicTransaction</id> + <title/> + <event type="set"> + <id>testBasicTransaction</id> + <actions phase="post"> + <action> + text_without_action: f.text_without_action; + + transaction( + timeout: 1000, + forceCreation: false, + code: { + createCase("test_transaction", "onButton") + change text_without_action value { "xxx" } + }, + onCommit: { createCase("test_transaction", "onCommit") }, + onRollBack: { createCase("test_transaction", "onRollBack1") } + ) + createCase("test_transaction", "onAlways") + </action> + </actions> + </event> + </data> + + <transition> + <id>t2</id> + <x>496</x> + <y>144</y> + <label>t2</label> + </transition> +</document> \ No newline at end of file From 4aa43439e419319a195ebd7cbf417fd43fa7268d Mon Sep 17 00:00:00 2001 From: chvostek <chvostek@netgrif.com> Date: Thu, 25 Jul 2024 14:47:44 +0200 Subject: [PATCH 03/48] [NAE-1998] Implement transactions for events - move and update TransactionTest --- .../engine/transaction/TransactionTest.groovy | 177 ++++++++++++++++++ .../engine/transaction/TransactionTest.java | 107 ----------- .../transaction/transaction_test.xml | 91 ++++++++- 3 files changed, 264 insertions(+), 111 deletions(-) create mode 100644 src/test/groovy/com/netgrif/application/engine/transaction/TransactionTest.groovy delete mode 100644 src/test/java/com/netgrif/application/engine/transaction/TransactionTest.java diff --git a/src/test/groovy/com/netgrif/application/engine/transaction/TransactionTest.groovy b/src/test/groovy/com/netgrif/application/engine/transaction/TransactionTest.groovy new file mode 100644 index 00000000000..9081001ddc5 --- /dev/null +++ b/src/test/groovy/com/netgrif/application/engine/transaction/TransactionTest.groovy @@ -0,0 +1,177 @@ +package com.netgrif.application.engine.transaction + +import com.netgrif.application.engine.TestHelper +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.throwable.MissingPetriNetMetaDataException +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.Case +import com.netgrif.application.engine.workflow.domain.QCase +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 org.junit.jupiter.api.BeforeEach +import org.junit.jupiter.api.Test +import org.springframework.beans.factory.annotation.Autowired +import org.springframework.boot.test.context.SpringBootTest +import org.springframework.data.domain.Page +import org.springframework.data.domain.PageRequest +import org.springframework.test.context.ActiveProfiles + +import static org.junit.jupiter.api.Assertions.assertThrows + +@SpringBootTest +@ActiveProfiles(["test"]) +class TransactionTest { + + @Autowired + private TestHelper testHelper + + @Autowired + private ImportHelper importHelper + + @Autowired + private IPetriNetService petriNetService + + @Autowired + private IDataService dataService + + @Autowired + private IWorkflowService workflowService + + @Autowired + private SuperCreator superCreator + + private PetriNet testNet + + @BeforeEach + void before() throws IOException, MissingPetriNetMetaDataException { + testHelper.truncateDbs() + testNet = petriNetService.importPetriNet(new FileInputStream("src/test/resources/petriNets/transaction/transaction_test.xml"), + VersionType.MAJOR, superCreator.getLoggedSuper()).getNet() + } + + private Case findByCaseTitle(String title) { + Page<Case> caseAsPage = workflowService.search(QCase.case$.title.eq(title), PageRequest.of(0, 1)) + if (caseAsPage.totalElements > 0) { + return caseAsPage.first() + } else { + return null + } + } + + private List<Case> findAllByIdentifier(String identifier) { + Page<Case> caseAsPage = workflowService.search(QCase.case$.processIdentifier.eq(identifier), PageRequest.of(0, Integer.MAX_VALUE)) + if (caseAsPage.totalElements > 0) { + return caseAsPage.getContent() + } else { + return List.of() + } + } + + @Test + void testBasicTransaction() { + Case useCase = importHelper.createCase("test", testNet) + useCase = dataService.setData(useCase, new DataSet(["testBasicTransaction": new ButtonField(rawValue: 1)] + as Map<String, Field<?>>), superCreator.getSuperUser()).case + + assert findAllByIdentifier("transaction_test").size() == 4 + assert findByCaseTitle("onButton") + assert findByCaseTitle("onCommit") + assert findByCaseTitle("onAlways") + assert !findByCaseTitle("onRollBack") + assert useCase.getDataSet().get("text_without_action").getValue().getValue() == "xxx" + } + + @Test + void testBasicTransactionWithFailure() { + Case useCase = importHelper.createCase("test", testNet) + useCase = dataService.setData(useCase, new DataSet(["testBasicTransactionWithFailure": new ButtonField(rawValue: 1)] + as Map<String, Field<?>>), superCreator.getSuperUser()).case + + assert findAllByIdentifier("transaction_test").size() == 3 + assert !findByCaseTitle("onButton") + assert !findByCaseTitle("onCommit") + assert findByCaseTitle("onAlways") + assert findByCaseTitle("onRollBack") + assert useCase.getDataSet().get("text_without_action").getValue().getValue() != "xxx" + } + + @Test + void testFailureInCallBackThrowsError() { + Case useCase = importHelper.createCase("test", testNet) + assertThrows(RuntimeException.class, { + dataService.setData(useCase, new DataSet(["testFailureInCallBackThrowsError": new ButtonField(rawValue: 1)] + as Map<String, Field<?>>), superCreator.getSuperUser()) + }) + assert findAllByIdentifier("transaction_test").size() == 1 + assert !findByCaseTitle("onAlways") + } + + @Test + void testTimeout() { + Case useCase = importHelper.createCase("test", testNet) + dataService.setData(useCase, new DataSet(["testTimeout": new ButtonField(rawValue: 1)] + as Map<String, Field<?>>), superCreator.getSuperUser()) + + assert findAllByIdentifier("transaction_test").size() == 3 + assert !findByCaseTitle("onButton") + assert !findByCaseTitle("onCommit") + assert findByCaseTitle("onAlways") + assert findByCaseTitle("onRollBack") + } + + @Test + void testElasticIndexingOnTransactionFailure() { + // assert if after failure exists case from transaction in elastic (it shouldnt) + } + + @Test + public void testTransactionRaceCondition() { + // assert failure in one of two concurrent transactions + } + + @Test + public void testNestedJoinedTransactions() { + // assert if all happy paths are executed + // consider onAlways + } + + @Test + public void testNestedDifferentTransactions() { + // assert if all happy paths are executed + // consider onAlways + } + + @Test + public void testNestedJoinedTransactionsWithFailureInParentTransaction() { + // assert if runtime exception causes all onRollBacks + // consider onAlways + } + + @Test + public void testNestedJoinedTransactionsWithFailureInNestedTransaction() { + // assert if runtime exception causes all onRollBacks + // consider onAlways + } + + @Test + public void testNestedDifferentTransactionsWithFailureInParentTransaction() { + // assert if runtime exception (in parent action) causes only relevant onRollBacks + // consider onAlways + + // assert if runtime exception (in action where definition of different transition is) causes only relevant onRollBacks + // consider onAlways + } + + @Test + public void testNestedDifferentTransactionsWithFailureInNestedTransaction() { + // assert if runtime exception causes only relevant onRollBacks + // consider onAlways + } + +} diff --git a/src/test/java/com/netgrif/application/engine/transaction/TransactionTest.java b/src/test/java/com/netgrif/application/engine/transaction/TransactionTest.java deleted file mode 100644 index 34ed5a211b3..00000000000 --- a/src/test/java/com/netgrif/application/engine/transaction/TransactionTest.java +++ /dev/null @@ -1,107 +0,0 @@ -package com.netgrif.application.engine.transaction; - -import com.netgrif.application.engine.TestHelper; -import com.netgrif.application.engine.petrinet.domain.VersionType; -import com.netgrif.application.engine.petrinet.domain.throwable.MissingPetriNetMetaDataException; -import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService; -import com.netgrif.application.engine.startup.SuperCreator; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import org.springframework.test.context.ActiveProfiles; - -import java.io.FileInputStream; -import java.io.IOException; - -@SpringBootTest -@ActiveProfiles({"test"}) -public class TransactionTest { - - @Autowired - private TestHelper testHelper; - - @Autowired - private IPetriNetService petriNetService; - - @Autowired - private SuperCreator superCreator; - - @BeforeEach - public void before() throws IOException, MissingPetriNetMetaDataException { - testHelper.truncateDbs(); - petriNetService.importPetriNet(new FileInputStream("src/test/resources/test_transaction.xml"), - VersionType.MAJOR, superCreator.getLoggedSuper()); - } - - @Test - public void testBasicTransaction() { - // no multilevel - // assert onCommit - // consider onAlways - } - - @Test - public void testBasicTransactionWithFailure() { - // no multilevel - // assert onRollBack - // consider onAlways - } - - @Test - public void testFailureInCallBackThrowsError() { - // no multilevel - // assert onRollBack - } - - - @Test - public void testTimeout() { - // assert if after some time the transaction is rolled back - } - - @Test - public void testTransactionRaceCondition() { - // assert failure in one of two concurrent transactions - } - - @Test - public void testNestedJoinedTransactions() { - // assert if all happy paths are executed - // consider onAlways - } - - @Test - public void testNestedDifferentTransactions() { - // assert if all happy paths are executed - // consider onAlways - } - - @Test - public void testNestedJoinedTransactionsWithFailureInParentTransaction() { - // assert if runtime exception causes all onRollBacks - // consider onAlways - } - - @Test - public void testNestedJoinedTransactionsWithFailureInNestedTransaction() { - // assert if runtime exception causes all onRollBacks - // consider onAlways - } - - @Test - public void testNestedDifferentTransactionsWithFailureInParentTransaction() { - // assert if runtime exception (in parent action) causes only relevant onRollBacks - // consider onAlways - - // assert if runtime exception (in action where definition of different transition is) causes only relevant onRollBacks - // consider onAlways - } - - @Test - public void testNestedDifferentTransactionsWithFailureInNestedTransaction() { - // assert if runtime exception causes only relevant onRollBacks - // consider onAlways - } - -} diff --git a/src/test/resources/petriNets/transaction/transaction_test.xml b/src/test/resources/petriNets/transaction/transaction_test.xml index 9246b4fbb48..0ae1d611027 100644 --- a/src/test/resources/petriNets/transaction/transaction_test.xml +++ b/src/test/resources/petriNets/transaction/transaction_test.xml @@ -30,13 +30,96 @@ timeout: 1000, forceCreation: false, code: { - createCase("test_transaction", "onButton") + createCase("transaction_test", "onButton") change text_without_action value { "xxx" } }, - onCommit: { createCase("test_transaction", "onCommit") }, - onRollBack: { createCase("test_transaction", "onRollBack1") } + onCommit: { createCase("transaction_test", "onCommit") }, + onRollBack: { createCase("transaction_test", "onRollBack") } ) - createCase("test_transaction", "onAlways") + createCase("transaction_test", "onAlways") + </action> + </actions> + </event> + </data> + + <data type="button"> + <id>testBasicTransactionWithFailure</id> + <title/> + <event type="set"> + <id>testBasicTransactionWithFailure</id> + <actions phase="post"> + <action> + text_without_action: f.text_without_action; + + transaction( + timeout: 1000, + forceCreation: false, + code: { + createCase("transaction_test", "onButton") + change text_without_action value { "xxx" } + // not runtime exception on purpose + throw new IllegalAccessException("error") + }, + onCommit: { createCase("transaction_test", "onCommit") }, + onRollBack: { createCase("transaction_test", "onRollBack") } + ) + createCase("transaction_test", "onAlways") + </action> + </actions> + </event> + </data> + + <data type="button"> + <id>testFailureInCallBackThrowsError</id> + <title/> + <event type="set"> + <id>testFailureInCallBackThrowsError</id> + <actions phase="post"> + <action> + text_without_action: f.text_without_action; + + transaction( + timeout: 1000, + forceCreation: false, + code: { + createCase("transaction_test", "onButton") + change text_without_action value { "xxx" } + throw new RuntimeException("error") + }, + onCommit: { createCase("transaction_test", "onCommit") }, + onRollBack: { + throw new RuntimeException("error") + createCase("transaction_test", "onRollBack") + } + ) + createCase("transaction_test", "onAlways") + </action> + </actions> + </event> + </data> + + <data type="button"> + <id>testTimeout</id> + <title/> + <event type="set"> + <id>testTimeout</id> + <actions phase="post"> + <action> + text_without_action: f.text_without_action; + + transaction( + timeout: 1, + forceCreation: false, + code: { + createCase("transaction_test", "onButton") + println "before sleep ${new Date().toString()}" + Thread.sleep(10000) + println "after sleep ${new Date().toString()}" + }, + onCommit: { createCase("transaction_test", "onCommit") }, + onRollBack: { createCase("transaction_test", "onRollBack") } + ) + createCase("transaction_test", "onAlways") </action> </actions> </event> From f0cdb492f8e3c27a19bb6093d8bbfcc8acf21273 Mon Sep 17 00:00:00 2001 From: chvostek <chvostek@netgrif.com> Date: Fri, 26 Jul 2024 10:38:48 +0200 Subject: [PATCH 04/48] [NAE-1998] Implement transactions for events - implement transaction timeout in NaeTransaction - rename ActionDelegate.transaction parameter --- .../logic/action/ActionDelegate.groovy | 4 +- .../engine/transaction/NaeTransaction.java | 38 ++++++++++++++++++- .../transaction/transaction_test.xml | 8 ++-- 3 files changed, 43 insertions(+), 7 deletions(-) diff --git a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy index b9406250d2e..a7d58f2f163 100644 --- a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy +++ b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy @@ -218,12 +218,12 @@ class ActionDelegate /*TODO: release/8.0.0: implements ActionAPI*/ { * todo * */ @NamedVariant - void transaction(int timeout = TransactionDefinition.TIMEOUT_DEFAULT, boolean forceCreation = false, Closure code, + void transaction(int timeout = TransactionDefinition.TIMEOUT_DEFAULT, boolean forceCreation = false, Closure event, Closure onCommit = null, Closure onRollBack = null) { def transactionBuilder = NaeTransaction.builder() .timeout(timeout) .forceCreation(forceCreation) - .event(code) + .event(event) .onCommit(onCommit) .onRollBack(onRollBack) .transactionManager(transactionManager) diff --git a/src/main/java/com/netgrif/application/engine/transaction/NaeTransaction.java b/src/main/java/com/netgrif/application/engine/transaction/NaeTransaction.java index 7adc1490498..82178e6934b 100644 --- a/src/main/java/com/netgrif/application/engine/transaction/NaeTransaction.java +++ b/src/main/java/com/netgrif/application/engine/transaction/NaeTransaction.java @@ -5,10 +5,14 @@ import lombok.Data; import lombok.extern.slf4j.Slf4j; import org.springframework.data.mongodb.MongoTransactionManager; +import org.springframework.transaction.TransactionDefinition; import org.springframework.transaction.TransactionStatus; +import org.springframework.transaction.TransactionTimedOutException; import org.springframework.transaction.annotation.Propagation; import org.springframework.transaction.support.*; +import java.util.Date; + import static org.springframework.transaction.support.TransactionSynchronization.STATUS_COMMITTED; import static org.springframework.transaction.support.TransactionSynchronization.STATUS_ROLLED_BACK; @@ -20,6 +24,9 @@ @Builder public class NaeTransaction { + /** + * todo + * */ private int timeout; private boolean forceCreation; private Closure<?> event; @@ -27,6 +34,7 @@ public class NaeTransaction { private Closure<?> onRollBack; private Exception onCallBackException; private Propagation propagation; + private Date deadline; /** * todo @@ -38,13 +46,14 @@ public class NaeTransaction { * */ public void begin() { TransactionTemplate transactionTemplate = new TransactionTemplate(transactionManager); - transactionTemplate.setTimeout(timeout); transactionTemplate.setPropagationBehavior(propagation.value()); + setTimeoutInMillis(timeout); transactionTemplate.execute(new TransactionCallbackWithoutResult() { protected void doInTransactionWithoutResult(TransactionStatus status) { registerTransactionCallBacks(); event.call(); + throwIfDeadlineReached(); // Transaction API does not check the timeout declared in transaction template } }); } @@ -86,6 +95,33 @@ private void runTransactionCallBack(Closure<?> callBack) { } } + /** + * todo + * */ + private void setTimeoutInMillis(long millis) throws IllegalArgumentException { + if (timeout == TransactionDefinition.TIMEOUT_DEFAULT) { + return; + } + if (timeout <= 0) { + throw new IllegalArgumentException(String.format("Timeout can be %s or positive number to represent millis.", + TransactionDefinition.TIMEOUT_DEFAULT)); + } + this.deadline = new Date(System.currentTimeMillis() + millis); + } + + /** + * todo + */ + private void throwIfDeadlineReached() throws TransactionTimedOutException { + if (this.deadline == null) { + return; + } + long timeToLive = this.deadline.getTime() - System.currentTimeMillis(); + if (timeToLive <= 0) { + throw new TransactionTimedOutException("Transaction timed out: deadline was " + this.deadline); + } + } + /** * todo * */ diff --git a/src/test/resources/petriNets/transaction/transaction_test.xml b/src/test/resources/petriNets/transaction/transaction_test.xml index 0ae1d611027..b098bed858b 100644 --- a/src/test/resources/petriNets/transaction/transaction_test.xml +++ b/src/test/resources/petriNets/transaction/transaction_test.xml @@ -29,7 +29,7 @@ transaction( timeout: 1000, forceCreation: false, - code: { + event: { createCase("transaction_test", "onButton") change text_without_action value { "xxx" } }, @@ -54,7 +54,7 @@ transaction( timeout: 1000, forceCreation: false, - code: { + event: { createCase("transaction_test", "onButton") change text_without_action value { "xxx" } // not runtime exception on purpose @@ -81,7 +81,7 @@ transaction( timeout: 1000, forceCreation: false, - code: { + event: { createCase("transaction_test", "onButton") change text_without_action value { "xxx" } throw new RuntimeException("error") @@ -110,7 +110,7 @@ transaction( timeout: 1, forceCreation: false, - code: { + event: { createCase("transaction_test", "onButton") println "before sleep ${new Date().toString()}" Thread.sleep(10000) From 6402c4bdee315e883e16b2042a16229be05eb5d0 Mon Sep 17 00:00:00 2001 From: chvostek <chvostek@netgrif.com> Date: Mon, 29 Jul 2024 13:32:51 +0200 Subject: [PATCH 05/48] [NAE-1998] Implement transactions for events - update return type of ActionDelegate.transaction - fix transaction timeout in ActionRunner - refactor elastic indexing of case, task and petriNet - implement ElasticPetriNetService.findAllByIdentifier - rework PetriNetEventHandler, CaseEventHandler, TaskEventHandler - update and implement some tests in TransactionTest --- .../logic/action/ActionDelegate.groovy | 4 +- .../dataset/logic/action/ActionRunner.groovy | 2 + .../ElasticsearchConfiguration.java | 4 - .../domain/ElasticPetriNetRepository.java | 2 + .../service/ElasticPetriNetService.java | 6 + .../interfaces/IElasticPetriNetService.java | 2 + .../service/PetriNetEventHandler.java | 36 ++- .../petrinet/service/PetriNetService.java | 9 - .../engine/transaction/NaeTransaction.java | 3 + .../workflow/service/CaseEventHandler.java | 36 ++- .../workflow/service/TaskEventHandler.java | 35 +-- .../engine/workflow/service/TaskService.java | 16 -- .../workflow/service/WorkflowService.java | 11 +- .../engine/transaction/TransactionTest.groovy | 229 ++++++++++++++---- .../transaction/transaction_test.xml | 106 ++++++-- .../transaction_test_secondary.xml | 34 +++ 16 files changed, 405 insertions(+), 130 deletions(-) create mode 100644 src/test/resources/petriNets/transaction/transaction_test_secondary.xml diff --git a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy index a7d58f2f163..d86c4bf9aaf 100644 --- a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy +++ b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy @@ -218,7 +218,7 @@ class ActionDelegate /*TODO: release/8.0.0: implements ActionAPI*/ { * todo * */ @NamedVariant - void transaction(int timeout = TransactionDefinition.TIMEOUT_DEFAULT, boolean forceCreation = false, Closure event, + NaeTransaction transaction(int timeout = TransactionDefinition.TIMEOUT_DEFAULT, boolean forceCreation = false, Closure event, Closure onCommit = null, Closure onRollBack = null) { def transactionBuilder = NaeTransaction.builder() .timeout(timeout) @@ -231,6 +231,8 @@ class ActionDelegate /*TODO: release/8.0.0: implements ActionAPI*/ { NaeTransaction transaction = transactionBuilder.build() executeTransaction(transaction) throwIfCallBackFailed(transaction) + + return transaction } /** diff --git a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionRunner.groovy b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionRunner.groovy index b42dc490233..d80b305c3bc 100644 --- a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionRunner.groovy +++ b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionRunner.groovy @@ -12,6 +12,7 @@ import org.springframework.beans.factory.annotation.Autowired import org.springframework.beans.factory.annotation.Lookup import org.springframework.data.mongodb.MongoTransactionManager import org.springframework.stereotype.Component +import org.springframework.transaction.TransactionDefinition import org.springframework.transaction.support.TransactionSynchronizationManager @Slf4j @@ -43,6 +44,7 @@ abstract class ActionRunner { code.init(action, useCase, task, changes, this, params) if (TransactionSynchronizationManager.isSynchronizationActive()) { def transaction = NaeTransaction.builder() + .timeout(TransactionDefinition.TIMEOUT_DEFAULT) .forceCreation(false) .transactionManager(transactionManager) .event(code) diff --git a/src/main/java/com/netgrif/application/engine/configuration/ElasticsearchConfiguration.java b/src/main/java/com/netgrif/application/engine/configuration/ElasticsearchConfiguration.java index dbd923e5a51..9d960678b72 100644 --- a/src/main/java/com/netgrif/application/engine/configuration/ElasticsearchConfiguration.java +++ b/src/main/java/com/netgrif/application/engine/configuration/ElasticsearchConfiguration.java @@ -75,8 +75,4 @@ public ElasticsearchOperations elasticsearchTemplate() { return new ElasticsearchRestTemplate(client()); } - @Bean - public CaseEventHandler caseEventHandler() { - return new CaseEventHandler(); - } } diff --git a/src/main/java/com/netgrif/application/engine/elastic/domain/ElasticPetriNetRepository.java b/src/main/java/com/netgrif/application/engine/elastic/domain/ElasticPetriNetRepository.java index 023b877ccad..e9afe7a221e 100644 --- a/src/main/java/com/netgrif/application/engine/elastic/domain/ElasticPetriNetRepository.java +++ b/src/main/java/com/netgrif/application/engine/elastic/domain/ElasticPetriNetRepository.java @@ -13,4 +13,6 @@ public interface ElasticPetriNetRepository extends ElasticsearchRepository<Elast List<ElasticPetriNet> findAllByUriNodeId(String uriNodeId); void deleteAllByStringId(String id); + + List<ElasticPetriNet> findAllByIdentifier(String identifier); } diff --git a/src/main/java/com/netgrif/application/engine/elastic/service/ElasticPetriNetService.java b/src/main/java/com/netgrif/application/engine/elastic/service/ElasticPetriNetService.java index 3777f1ddb86..dcae951d8ec 100644 --- a/src/main/java/com/netgrif/application/engine/elastic/service/ElasticPetriNetService.java +++ b/src/main/java/com/netgrif/application/engine/elastic/service/ElasticPetriNetService.java @@ -89,4 +89,10 @@ public List<PetriNet> findAllByUriNodeId(String uriNodeId) { List<ElasticPetriNet> elasticPetriNets = repository.findAllByUriNodeId(uriNodeId); return petriNetService.findAllById(elasticPetriNets.stream().map(ElasticPetriNet::getStringId).collect(Collectors.toList())); } + + @Override + public List<PetriNet> findAllByIdentifier(String identifier) { + List<ElasticPetriNet> elasticPetriNets = repository.findAllByIdentifier(identifier); + return petriNetService.findAllById(elasticPetriNets.stream().map(ElasticPetriNet::getStringId).collect(Collectors.toList())); + } } diff --git a/src/main/java/com/netgrif/application/engine/elastic/service/interfaces/IElasticPetriNetService.java b/src/main/java/com/netgrif/application/engine/elastic/service/interfaces/IElasticPetriNetService.java index 6be7daaf0a3..a0e83c8dfb8 100644 --- a/src/main/java/com/netgrif/application/engine/elastic/service/interfaces/IElasticPetriNetService.java +++ b/src/main/java/com/netgrif/application/engine/elastic/service/interfaces/IElasticPetriNetService.java @@ -19,4 +19,6 @@ public interface IElasticPetriNetService { List<PetriNet> findAllByUriNodeId(String uriNodeId); + List<PetriNet> findAllByIdentifier(String identifier); + } diff --git a/src/main/java/com/netgrif/application/engine/petrinet/service/PetriNetEventHandler.java b/src/main/java/com/netgrif/application/engine/petrinet/service/PetriNetEventHandler.java index cacc8b352f2..e0cc5c3a6ab 100644 --- a/src/main/java/com/netgrif/application/engine/petrinet/service/PetriNetEventHandler.java +++ b/src/main/java/com/netgrif/application/engine/petrinet/service/PetriNetEventHandler.java @@ -1,23 +1,51 @@ package com.netgrif.application.engine.petrinet.service; +import com.netgrif.application.engine.elastic.service.interfaces.IElasticPetriNetMappingService; import com.netgrif.application.engine.elastic.service.interfaces.IElasticPetriNetService; import com.netgrif.application.engine.petrinet.domain.PetriNet; +import com.netgrif.application.engine.workflow.domain.Case; +import lombok.RequiredArgsConstructor; import lombok.extern.slf4j.Slf4j; import org.bson.Document; import org.bson.types.ObjectId; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.data.mongodb.core.mapping.event.AbstractMongoEventListener; import org.springframework.data.mongodb.core.mapping.event.AfterDeleteEvent; +import org.springframework.data.mongodb.core.mapping.event.AfterSaveEvent; import org.springframework.stereotype.Component; +import org.springframework.transaction.event.TransactionalEventListener; @Slf4j @Component -public class PetriNetEventHandler extends AbstractMongoEventListener<PetriNet> { +@RequiredArgsConstructor +public class PetriNetEventHandler { - @Autowired - private IElasticPetriNetService service; + private final IElasticPetriNetService service; + private final IElasticPetriNetMappingService petriNetMappingService; - @Override + /** + * todo + * todo does not need to be async + * todo condition because generic + * */ + // todo collectionName from properties + @TransactionalEventListener(fallbackExecution = true, condition = "#event.collectionName == 'petriNet'") + public void onAfterSave(AfterSaveEvent<PetriNet> event) { + PetriNet net = event.getSource(); + try { + service.indexNow(petriNetMappingService.transform(net)); + } catch (Exception e) { + log.error("Indexing failed [{}]", net.getStringId(), e); + } + } + + /** + * todo + * todo does not need to be async + * todo condition because generic + * */ + // todo collectionName from properties + @TransactionalEventListener(fallbackExecution = true, condition = "#event.collectionName == 'petriNet'") public void onAfterDelete(AfterDeleteEvent<PetriNet> event) { Document document = event.getDocument(); if (document == null) { diff --git a/src/main/java/com/netgrif/application/engine/petrinet/service/PetriNetService.java b/src/main/java/com/netgrif/application/engine/petrinet/service/PetriNetService.java index bb46f0af89a..0acd7b6494e 100644 --- a/src/main/java/com/netgrif/application/engine/petrinet/service/PetriNetService.java +++ b/src/main/java/com/netgrif/application/engine/petrinet/service/PetriNetService.java @@ -124,9 +124,6 @@ public class PetriNetService implements IPetriNetService { @Resource private IPetriNetService self; - @Autowired - private IElasticPetriNetMappingService petriNetMappingService; - @Autowired private IUriService uriService; @@ -268,12 +265,6 @@ public Optional<PetriNet> save(PetriNet petriNet) { this.evictCache(petriNet); petriNet = repository.save(petriNet); - try { - elasticPetriNetService.indexNow(this.petriNetMappingService.transform(petriNet)); - } catch (Exception e) { - log.error("Indexing failed [{}]", petriNet.getStringId(), e); - } - return Optional.of(petriNet); } diff --git a/src/main/java/com/netgrif/application/engine/transaction/NaeTransaction.java b/src/main/java/com/netgrif/application/engine/transaction/NaeTransaction.java index 82178e6934b..11b5b5f1852 100644 --- a/src/main/java/com/netgrif/application/engine/transaction/NaeTransaction.java +++ b/src/main/java/com/netgrif/application/engine/transaction/NaeTransaction.java @@ -32,9 +32,11 @@ public class NaeTransaction { private Closure<?> event; private Closure<?> onCommit; private Closure<?> onRollBack; + private Exception onCallBackException; private Propagation propagation; private Date deadline; + private boolean wasRolledBack; /** * todo @@ -68,6 +70,7 @@ public void afterCompletion(int status) { if (canCallOnCommit(status)) { runTransactionCallBack(onCommit); } else if (canCallOnRollBack(status)) { + wasRolledBack = true; runTransactionCallBack(onRollBack); } } diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/CaseEventHandler.java b/src/main/java/com/netgrif/application/engine/workflow/service/CaseEventHandler.java index b188442fa20..7f1bdaaa05c 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/CaseEventHandler.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/CaseEventHandler.java @@ -1,23 +1,47 @@ package com.netgrif.application.engine.workflow.service; +import com.netgrif.application.engine.elastic.service.interfaces.IElasticCaseMappingService; import com.netgrif.application.engine.elastic.service.interfaces.IElasticCaseService; import com.netgrif.application.engine.workflow.domain.Case; +import lombok.RequiredArgsConstructor; import lombok.extern.slf4j.Slf4j; import org.bson.Document; import org.bson.types.ObjectId; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.data.mongodb.core.mapping.event.AbstractMongoEventListener; import org.springframework.data.mongodb.core.mapping.event.AfterDeleteEvent; +import org.springframework.data.mongodb.core.mapping.event.AfterSaveEvent; import org.springframework.stereotype.Component; +import org.springframework.transaction.event.TransactionalEventListener; @Slf4j @Component -public class CaseEventHandler extends AbstractMongoEventListener<Case> { +@RequiredArgsConstructor +public class CaseEventHandler { - @Autowired - private IElasticCaseService service; + private final IElasticCaseService service; + private final IElasticCaseMappingService caseMappingService; - @Override + /** + * todo + * todo does not need to be async + * todo condition because generic + * */ + // todo collectionName from properties + @TransactionalEventListener(fallbackExecution = true, condition = "#event.collectionName == 'case'") + public void onAfterSave(AfterSaveEvent<Case> event) { + Case useCase = event.getSource(); + try { + useCase.resolveImmediateDataFields(); + service.indexNow(caseMappingService.transform(useCase)); + } catch (Exception e) { + log.error("Indexing failed [{}]", useCase.getStringId(), e); + } + } + + /** + * todo + * */ + // todo collectionName from properties + @TransactionalEventListener(fallbackExecution = true, condition = "#event.collectionName == 'case'") public void onAfterDelete(AfterDeleteEvent<Case> event) { Document document = event.getDocument(); if (document == null) { diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/TaskEventHandler.java b/src/main/java/com/netgrif/application/engine/workflow/service/TaskEventHandler.java index 2291db40ca4..c66ac4fbe41 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/TaskEventHandler.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/TaskEventHandler.java @@ -3,33 +3,40 @@ import com.netgrif.application.engine.elastic.service.interfaces.IElasticTaskMappingService; import com.netgrif.application.engine.elastic.service.interfaces.IElasticTaskService; import com.netgrif.application.engine.workflow.domain.Task; +import lombok.RequiredArgsConstructor; import lombok.extern.slf4j.Slf4j; import org.bson.Document; import org.bson.types.ObjectId; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.data.mongodb.core.mapping.event.AbstractMongoEventListener; import org.springframework.data.mongodb.core.mapping.event.AfterDeleteEvent; import org.springframework.data.mongodb.core.mapping.event.AfterSaveEvent; -import org.springframework.scheduling.annotation.Async; import org.springframework.stereotype.Component; +import org.springframework.transaction.event.TransactionalEventListener; @Slf4j @Component -public class TaskEventHandler extends AbstractMongoEventListener<Task> { - - @Autowired - private IElasticTaskService service; - - @Autowired - private IElasticTaskMappingService taskMappingService; - - @Async - @Override +@RequiredArgsConstructor +public class TaskEventHandler { + + private final IElasticTaskService service; + private final IElasticTaskMappingService taskMappingService; + + /** + * todo + * todo does not need to be async + * todo condition because generic + * */ + // todo collectionName from properties + @TransactionalEventListener(fallbackExecution = true, condition = "#event.collectionName == 'task'") public void onAfterSave(AfterSaveEvent<Task> event) { service.index(this.taskMappingService.transform(event.getSource())); } - @Override + /** + * todo + * todo condition because generic + * */ + // todo collectionName from properties + @TransactionalEventListener(fallbackExecution = true, condition = "#event.collectionName == 'task'") public void onAfterDelete(AfterDeleteEvent<Task> event) { Document document = event.getDocument(); if (document == null) { diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/TaskService.java b/src/main/java/com/netgrif/application/engine/workflow/service/TaskService.java index c09a7c6dc78..655ae192e89 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/TaskService.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/TaskService.java @@ -4,8 +4,6 @@ import com.netgrif.application.engine.auth.domain.IUser; import com.netgrif.application.engine.auth.domain.LoggedUser; import com.netgrif.application.engine.auth.service.interfaces.IUserService; -import com.netgrif.application.engine.elastic.service.interfaces.IElasticTaskMappingService; -import com.netgrif.application.engine.elastic.service.interfaces.IElasticTaskService; import com.netgrif.application.engine.history.domain.taskevents.AssignTaskEventLog; import com.netgrif.application.engine.history.domain.taskevents.CancelTaskEventLog; import com.netgrif.application.engine.history.domain.taskevents.DelegateTaskEventLog; @@ -101,25 +99,15 @@ public class TaskService implements ITaskService { @Autowired protected IProcessRoleService processRoleService; - @Autowired - protected IElasticTaskMappingService taskMappingService; - @Autowired protected IEventService eventService; - protected IElasticTaskService elasticTaskService; - @Autowired protected IHistoryService historyService; @Autowired protected IValidationService validation; - @Autowired - public void setElasticTaskService(IElasticTaskService elasticTaskService) { - this.elasticTaskService = elasticTaskService; - } - @Autowired private IRuleEngine ruleEngine; @@ -718,14 +706,12 @@ public List<Task> findAllByCase(String caseId) { @Override public Task save(Task task) { task = taskRepository.save(task); - elasticTaskService.index(this.taskMappingService.transform(task)); return task; } @Override public List<Task> save(List<Task> tasks) { tasks = taskRepository.saveAll(tasks); - tasks.forEach(task -> elasticTaskService.index(this.taskMappingService.transform(task))); return tasks; } @@ -851,7 +837,6 @@ public void delete(List<Task> tasks, Case useCase) { workflowService.removeTasksFromCase(tasks, useCase); log.info("[{}]: Tasks of case {} are being deleted", useCase.getStringId(), useCase.getTitle()); taskRepository.deleteAll(tasks); - tasks.forEach(t -> elasticTaskService.remove(t.getStringId())); } @Override @@ -859,7 +844,6 @@ public void delete(List<Task> tasks, String caseId) { workflowService.removeTasksFromCase(tasks, caseId); log.info("[{}]: Tasks of case are being deleted", caseId); taskRepository.deleteAll(tasks); - tasks.forEach(t -> elasticTaskService.remove(t.getStringId())); } @Override diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/WorkflowService.java b/src/main/java/com/netgrif/application/engine/workflow/service/WorkflowService.java index 808e6bc574a..14ed162355b 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/WorkflowService.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/WorkflowService.java @@ -3,7 +3,6 @@ import com.google.common.collect.Ordering; import com.netgrif.application.engine.auth.domain.LoggedUser; import com.netgrif.application.engine.auth.service.interfaces.IUserService; -import com.netgrif.application.engine.elastic.service.interfaces.IElasticCaseMappingService; import com.netgrif.application.engine.elastic.service.interfaces.IElasticCaseService; import com.netgrif.application.engine.elastic.web.requestbodies.CaseSearchRequest; import com.netgrif.application.engine.history.domain.caseevents.CreateCaseEventLog; @@ -97,9 +96,6 @@ public class WorkflowService implements IWorkflowService { @Autowired protected IInitValueExpressionEvaluator initValueExpressionEvaluator; - @Autowired - protected IElasticCaseMappingService caseMappingService; - @Lazy @Autowired private IEventService eventService; @@ -124,12 +120,7 @@ public Case save(Case useCase) { } encryptDataSet(useCase); useCase = repository.save(useCase); - try { - useCase.resolveImmediateDataFields(); - elasticCaseService.indexNow(this.caseMappingService.transform(useCase)); - } catch (Exception e) { - log.error("Indexing failed [{}]", useCase.getStringId(), e); - } + return useCase; } diff --git a/src/test/groovy/com/netgrif/application/engine/transaction/TransactionTest.groovy b/src/test/groovy/com/netgrif/application/engine/transaction/TransactionTest.groovy index 9081001ddc5..b282da62e7c 100644 --- a/src/test/groovy/com/netgrif/application/engine/transaction/TransactionTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/transaction/TransactionTest.groovy @@ -1,6 +1,11 @@ package com.netgrif.application.engine.transaction import com.netgrif.application.engine.TestHelper +import com.netgrif.application.engine.elastic.service.interfaces.IElasticCaseService +import com.netgrif.application.engine.elastic.service.interfaces.IElasticPetriNetService +import com.netgrif.application.engine.elastic.service.interfaces.IElasticTaskService +import com.netgrif.application.engine.elastic.web.requestbodies.CaseSearchRequest +import com.netgrif.application.engine.elastic.web.requestbodies.ElasticTaskSearchRequest 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 @@ -11,7 +16,10 @@ import com.netgrif.application.engine.startup.ImportHelper import com.netgrif.application.engine.startup.SuperCreator import com.netgrif.application.engine.workflow.domain.Case import com.netgrif.application.engine.workflow.domain.QCase +import com.netgrif.application.engine.workflow.domain.QTask +import com.netgrif.application.engine.workflow.domain.Task 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 import com.netgrif.application.engine.workflow.web.responsebodies.DataSet import org.junit.jupiter.api.BeforeEach @@ -43,6 +51,18 @@ class TransactionTest { @Autowired private IWorkflowService workflowService + @Autowired + private ITaskService taskService + + @Autowired + private IElasticPetriNetService elasticPetriNetService + + @Autowired + private IElasticCaseService elasticCaseService + + @Autowired + private IElasticTaskService elasticTaskService + @Autowired private SuperCreator superCreator @@ -55,24 +75,6 @@ class TransactionTest { VersionType.MAJOR, superCreator.getLoggedSuper()).getNet() } - private Case findByCaseTitle(String title) { - Page<Case> caseAsPage = workflowService.search(QCase.case$.title.eq(title), PageRequest.of(0, 1)) - if (caseAsPage.totalElements > 0) { - return caseAsPage.first() - } else { - return null - } - } - - private List<Case> findAllByIdentifier(String identifier) { - Page<Case> caseAsPage = workflowService.search(QCase.case$.processIdentifier.eq(identifier), PageRequest.of(0, Integer.MAX_VALUE)) - if (caseAsPage.totalElements > 0) { - return caseAsPage.getContent() - } else { - return List.of() - } - } - @Test void testBasicTransaction() { Case useCase = importHelper.createCase("test", testNet) @@ -80,87 +82,161 @@ class TransactionTest { as Map<String, Field<?>>), superCreator.getSuperUser()).case assert findAllByIdentifier("transaction_test").size() == 4 - assert findByCaseTitle("onButton") - assert findByCaseTitle("onCommit") - assert findByCaseTitle("onAlways") - assert !findByCaseTitle("onRollBack") + + assert findCaseByTitle("onButton") + assert findTaskByCaseTitle("onButton") + + assert findCaseByTitle("onCommit") + assert findTaskByCaseTitle("onCommit") + + assert findCaseByTitle("onAlways") + assert findTaskByCaseTitle("onAlways") + + assert !findCaseByTitle("onRollBack") + assert !findTaskByCaseTitle("onRollBack") + assert useCase.getDataSet().get("text_without_action").getValue().getValue() == "xxx" + assert useCase.getDataSet().get("was_transaction_rolled_back").getValue().getValue() == false } @Test void testBasicTransactionWithFailure() { - Case useCase = importHelper.createCase("test", testNet) - useCase = dataService.setData(useCase, new DataSet(["testBasicTransactionWithFailure": new ButtonField(rawValue: 1)] - as Map<String, Field<?>>), superCreator.getSuperUser()).case + Case useCase = createTestCaseAndSetButton("test", "testBasicTransactionWithFailure") + importHelper.createCase("toBeRemoved", testNet) + + assert findAllByIdentifier("transaction_test").size() == 4 + + assert !findCaseByTitle("onButton") + assert !findTaskByCaseTitle("onButton") + + assert !findCaseByTitle("onCommit") + assert !findTaskByCaseTitle("onCommit") + + assert findCaseByTitle("onAlways") + assert findTaskByCaseTitle("onAlways") + + assert findCaseByTitle("onRollBack") + assert findTaskByCaseTitle("onRollBack") + + assert findCaseByTitle("toBeRemoved") + assert findTaskByCaseTitle("toBeRemoved") - assert findAllByIdentifier("transaction_test").size() == 3 - assert !findByCaseTitle("onButton") - assert !findByCaseTitle("onCommit") - assert findByCaseTitle("onAlways") - assert findByCaseTitle("onRollBack") assert useCase.getDataSet().get("text_without_action").getValue().getValue() != "xxx" + assert useCase.getDataSet().get("was_transaction_rolled_back").getValue().getValue() == true } @Test void testFailureInCallBackThrowsError() { - Case useCase = importHelper.createCase("test", testNet) assertThrows(RuntimeException.class, { - dataService.setData(useCase, new DataSet(["testFailureInCallBackThrowsError": new ButtonField(rawValue: 1)] - as Map<String, Field<?>>), superCreator.getSuperUser()) + createTestCaseAndSetButton("test", "testFailureInCallBackThrowsError") }) assert findAllByIdentifier("transaction_test").size() == 1 - assert !findByCaseTitle("onAlways") + assert !findCaseByTitle("onAlways") + assert !findTaskByCaseTitle("onAlways") } @Test void testTimeout() { - Case useCase = importHelper.createCase("test", testNet) - dataService.setData(useCase, new DataSet(["testTimeout": new ButtonField(rawValue: 1)] - as Map<String, Field<?>>), superCreator.getSuperUser()) + Case useCase = createTestCaseAndSetButton("test", "testTimeout") assert findAllByIdentifier("transaction_test").size() == 3 - assert !findByCaseTitle("onButton") - assert !findByCaseTitle("onCommit") - assert findByCaseTitle("onAlways") - assert findByCaseTitle("onRollBack") + + assert !findCaseByTitle("onButton") + assert !findTaskByCaseTitle("onButton") + + assert !findCaseByTitle("onCommit") + assert !findTaskByCaseTitle("onCommit") + + assert findCaseByTitle("onAlways") + assert findTaskByCaseTitle("onAlways") + + assert findCaseByTitle("onRollBack") + assert findTaskByCaseTitle("onRollBack") + + assert useCase.getDataSet().get("was_transaction_rolled_back").getValue().getValue() == true } @Test void testElasticIndexingOnTransactionFailure() { - // assert if after failure exists case from transaction in elastic (it shouldnt) + Case useCase = createTestCaseAndSetButton("test", "testElasticIndexingOnTransactionFailure") + + Thread.sleep(2000) // wait for indexation + + assert findAllByIdentifier("transaction_test").size() == 3 + + assert !existPetriNetInElastic("transaction_test_secondary") + assert !existCaseInElastic("toBeRemoved") + assert !existCaseInElastic("toBeRemovedNestedOnFailure") + + assert !existCaseInElastic("onButton") + assert !existTaskInElastic("onButton") + + assert existCaseInElastic("onRollBack") + assert existTaskInElastic("onRollBack") + + assert existCaseInElastic("onAlways") + assert existTaskInElastic("onAlways") + + assert useCase.getDataSet().get("was_transaction_rolled_back").getValue().getValue() == true + } + + @Test + void testElasticIndexingOnTransactionSuccess() { + Case useCase = createTestCaseAndSetButton("test", "testElasticIndexingOnTransactionSuccess") + + Thread.sleep(2000) // wait for indexation + + assert findAllByIdentifier("transaction_test").size() == 5 + + assert existPetriNetInElastic("transaction_test_secondary") + assert !existCaseInElastic("toBeRemoved") + assert !existTaskInElastic("toBeRemoved") + assert existCaseInElastic("toBeRemovedNestedOnFailure") + assert existTaskInElastic("toBeRemovedNestedOnFailure") + + assert existCaseInElastic("onButton") + assert existTaskInElastic("onButton") + + assert existCaseInElastic("onCommit") + assert existTaskInElastic("onCommit") + + assert existCaseInElastic("onAlways") + assert existTaskInElastic("onAlways") + + assert useCase.getDataSet().get("was_transaction_rolled_back").getValue().getValue() == false } @Test - public void testTransactionRaceCondition() { + void testTransactionRaceCondition() { // assert failure in one of two concurrent transactions } @Test - public void testNestedJoinedTransactions() { + void testNestedJoinedTransactions() { // assert if all happy paths are executed // consider onAlways } @Test - public void testNestedDifferentTransactions() { + void testNestedDifferentTransactions() { // assert if all happy paths are executed // consider onAlways } @Test - public void testNestedJoinedTransactionsWithFailureInParentTransaction() { + void testNestedJoinedTransactionsWithFailureInParentTransaction() { // assert if runtime exception causes all onRollBacks // consider onAlways } @Test - public void testNestedJoinedTransactionsWithFailureInNestedTransaction() { + void testNestedJoinedTransactionsWithFailureInNestedTransaction() { // assert if runtime exception causes all onRollBacks // consider onAlways } @Test - public void testNestedDifferentTransactionsWithFailureInParentTransaction() { + void testNestedDifferentTransactionsWithFailureInParentTransaction() { // assert if runtime exception (in parent action) causes only relevant onRollBacks // consider onAlways @@ -169,9 +245,64 @@ class TransactionTest { } @Test - public void testNestedDifferentTransactionsWithFailureInNestedTransaction() { + void testNestedDifferentTransactionsWithFailureInNestedTransaction() { // assert if runtime exception causes only relevant onRollBacks // consider onAlways } + private Case createTestCaseAndSetButton(String title, String buttonFieldId) { + Case useCase = importHelper.createCase(title, testNet) + return dataService.setData(useCase, new DataSet([(buttonFieldId): new ButtonField(rawValue: 1)] + as Map<String, Field<?>>), superCreator.getSuperUser()).getCase() + } + + private Case findCaseByTitle(String title) { + Page<Case> caseAsPage = workflowService.search(QCase.case$.title.eq(title), PageRequest.of(0, 1)) + if (caseAsPage.totalElements > 0) { + return caseAsPage.first() + } else { + return null + } + } + + private Task findTaskByCaseTitle(String caseTitle) { + Page<Task> taskAsPage = taskService.search(QTask.task.caseTitle.eq(caseTitle), PageRequest.of(0, 1)) + if (taskAsPage.totalElements > 0) { + return taskAsPage.first() + } else { + return null + } + } + + private List<Case> findAllByIdentifier(String identifier) { + Page<Case> caseAsPage = workflowService.search(QCase.case$.processIdentifier.eq(identifier), PageRequest.of(0, Integer.MAX_VALUE)) + if (caseAsPage.totalElements > 0) { + return caseAsPage.getContent() + } else { + return List.of() + } + } + + private boolean existPetriNetInElastic(String identifier) { + return elasticPetriNetService.findAllByIdentifier(identifier).size() >= 1 + } + + private boolean existCaseInElastic(String title) { + return elasticCaseService.count( + List.of(CaseSearchRequest.builder().query("title:" + title).build()), + superCreator.getLoggedSuper(), + Locale.getDefault(), + false + ) >= 1 + } + + private boolean existTaskInElastic(String caseTitle) { + return elasticTaskService.count( + List.of(new ElasticTaskSearchRequest(Map.of("query", "caseTitle:" + caseTitle))), + superCreator.getLoggedSuper(), + Locale.getDefault(), + false + ) >= 1 + } + } diff --git a/src/test/resources/petriNets/transaction/transaction_test.xml b/src/test/resources/petriNets/transaction/transaction_test.xml index b098bed858b..d05b35ee738 100644 --- a/src/test/resources/petriNets/transaction/transaction_test.xml +++ b/src/test/resources/petriNets/transaction/transaction_test.xml @@ -17,6 +17,11 @@ <title/> </data> + <data type="boolean"> + <id>was_transaction_rolled_back</id> + <title/> + </data> + <data type="button"> <id>testBasicTransaction</id> <title/> @@ -24,11 +29,10 @@ <id>testBasicTransaction</id> <actions phase="post"> <action> + was_transaction_rolled_back: f.was_transaction_rolled_back, text_without_action: f.text_without_action; - transaction( - timeout: 1000, - forceCreation: false, + def myTransaction = transaction( event: { createCase("transaction_test", "onButton") change text_without_action value { "xxx" } @@ -37,6 +41,8 @@ onRollBack: { createCase("transaction_test", "onRollBack") } ) createCase("transaction_test", "onAlways") + + change was_transaction_rolled_back value { myTransaction.wasRolledBack } </action> </actions> </event> @@ -49,12 +55,12 @@ <id>testBasicTransactionWithFailure</id> <actions phase="post"> <action> + was_transaction_rolled_back: f.was_transaction_rolled_back, text_without_action: f.text_without_action; - transaction( - timeout: 1000, - forceCreation: false, + def myTransaction = transaction( event: { + workflowService.deleteCase(findCase({it.title.eq("toBeRemoved")})) createCase("transaction_test", "onButton") change text_without_action value { "xxx" } // not runtime exception on purpose @@ -64,6 +70,8 @@ onRollBack: { createCase("transaction_test", "onRollBack") } ) createCase("transaction_test", "onAlways") + + change was_transaction_rolled_back value { myTransaction.wasRolledBack } </action> </actions> </event> @@ -76,11 +84,10 @@ <id>testFailureInCallBackThrowsError</id> <actions phase="post"> <action> + was_transaction_rolled_back: f.was_transaction_rolled_back, text_without_action: f.text_without_action; - transaction( - timeout: 1000, - forceCreation: false, + def myTransaction = transaction( event: { createCase("transaction_test", "onButton") change text_without_action value { "xxx" } @@ -93,6 +100,8 @@ } ) createCase("transaction_test", "onAlways") + + change was_transaction_rolled_back value { myTransaction.wasRolledBack } </action> </actions> </event> @@ -105,30 +114,93 @@ <id>testTimeout</id> <actions phase="post"> <action> + was_transaction_rolled_back: f.was_transaction_rolled_back, text_without_action: f.text_without_action; - transaction( - timeout: 1, - forceCreation: false, + def myTransaction = transaction( + timeout: 1, // in millis event: { createCase("transaction_test", "onButton") - println "before sleep ${new Date().toString()}" - Thread.sleep(10000) - println "after sleep ${new Date().toString()}" + Thread.sleep(50) // make sure it will time-out }, onCommit: { createCase("transaction_test", "onCommit") }, onRollBack: { createCase("transaction_test", "onRollBack") } ) createCase("transaction_test", "onAlways") + + change was_transaction_rolled_back value { myTransaction.wasRolledBack } + </action> + </actions> + </event> + </data> + + <data type="button"> + <id>testElasticIndexingOnTransactionFailure</id> + <title/> + <event type="set"> + <id>testElasticIndexingOnTransactionFailure</id> + <actions phase="post"> + <action> + was_transaction_rolled_back: f.was_transaction_rolled_back, + text_without_action: f.text_without_action; + + def myTransaction = transaction( + event: { + petriNetService.importPetriNet(new java.io.FileInputStream("src/test/resources/petriNets/transaction/transaction_test_secondary.xml"), + com.netgrif.application.engine.petrinet.domain.VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser()) + def toBeRemovedCase = createCase("transaction_test_secondary", "toBeRemoved") + assignTask("t1", toBeRemovedCase) + workflowService.deleteCase(toBeRemovedCase.stringId) + + createCase("transaction_test", "onButton") + throw new RuntimeException("error") + }, + onCommit: { createCase("transaction_test", "onCommit") }, + onRollBack: { createCase("transaction_test", "onRollBack") } + ) + createCase("transaction_test", "onAlways") + + change was_transaction_rolled_back value { myTransaction.wasRolledBack } + </action> + </actions> + </event> + </data> + + <data type="button"> + <id>testElasticIndexingOnTransactionSuccess</id> + <title/> + <event type="set"> + <id>testElasticIndexingOnTransactionSuccess</id> + <actions phase="post"> + <action> + was_transaction_rolled_back: f.was_transaction_rolled_back, + text_without_action: f.text_without_action; + + def myTransaction = transaction( + event: { + petriNetService.importPetriNet(new java.io.FileInputStream("src/test/resources/petriNets/transaction/transaction_test_secondary.xml"), + com.netgrif.application.engine.petrinet.domain.VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser()) + def toBeRemovedCase = createCase("transaction_test_secondary", "toBeRemoved") + assignTask("t1", toBeRemovedCase) + workflowService.deleteCase(toBeRemovedCase.stringId) + + createCase("transaction_test", "onButton") + }, + onCommit: { createCase("transaction_test", "onCommit") }, + onRollBack: { createCase("transaction_test", "onRollBack") } + ) + createCase("transaction_test", "onAlways") + + change was_transaction_rolled_back value { myTransaction.wasRolledBack } </action> </actions> </event> </data> <transition> - <id>t2</id> + <id>t1</id> <x>496</x> <y>144</y> - <label>t2</label> + <label>t1</label> </transition> </document> \ No newline at end of file diff --git a/src/test/resources/petriNets/transaction/transaction_test_secondary.xml b/src/test/resources/petriNets/transaction/transaction_test_secondary.xml new file mode 100644 index 00000000000..690dbad2591 --- /dev/null +++ b/src/test/resources/petriNets/transaction/transaction_test_secondary.xml @@ -0,0 +1,34 @@ +<document xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="https://petriflow.com/petriflow.schema.xsd"> + <id>transaction_test_secondary</id> + <version>1.0.0</version> + <initials>TRS</initials> + <title>transaction_test_secondary + device_hub + true + true + false + + + text_without_action + + </data> + <data type="text"> + <id>text_2</id> + <title/> + </data> + + <transition> + <id>t1</id> + <x>496</x> + <y>144</y> + <label>t1</label> + <event type="assign"> + <id>1</id> + <actions phase="post"> + <action> + createCase("transaction_test", "toBeRemovedNestedOnFailure") + </action> + </actions> + </event> + </transition> +</document> \ No newline at end of file From 44bdd01c410983a8a592c57a95129f4149791108 Mon Sep 17 00:00:00 2001 From: chvostek <chvostek@netgrif.com> Date: Tue, 30 Jul 2024 08:43:23 +0200 Subject: [PATCH 06/48] [NAE-1998] Implement transactions for events - update transaction error logging in ActionDelegate - implement new tests in TransactionTest --- .../logic/action/ActionDelegate.groovy | 1 + .../engine/transaction/TransactionTest.groovy | 109 +++++- .../transaction/transaction_test.xml | 370 +++++++++++++++++- 3 files changed, 460 insertions(+), 20 deletions(-) diff --git a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy index d86c4bf9aaf..cd73c4fe59c 100644 --- a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy +++ b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy @@ -249,6 +249,7 @@ class ActionDelegate /*TODO: release/8.0.0: implements ActionAPI*/ { try { transaction.begin() } catch (Exception e) { + log.warn("Transaction failed in action: $action.definition") log.error("Transaction failed with error: {}", e.getMessage(), e) } } diff --git a/src/test/groovy/com/netgrif/application/engine/transaction/TransactionTest.groovy b/src/test/groovy/com/netgrif/application/engine/transaction/TransactionTest.groovy index b282da62e7c..d27795f5ff1 100644 --- a/src/test/groovy/com/netgrif/application/engine/transaction/TransactionTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/transaction/TransactionTest.groovy @@ -207,47 +207,124 @@ class TransactionTest { } @Test - void testTransactionRaceCondition() { - // assert failure in one of two concurrent transactions + void testTransactionWriteConflict() { + Case useCase = createTestCaseAndSetButton("test", "testTransactionWriteConflict") + + assert findAllByIdentifier("transaction_test").size() == 5 + + assert findCaseByTitle("onRollBackNested") + assert findTaskByCaseTitle("onRollBackNested") + + assert !findCaseByTitle("onCommitNested") + assert !findTaskByCaseTitle("onCommitNested") + + assert findCaseByTitle("onAlwaysNested") + assert findTaskByCaseTitle("onAlwaysNested") + + assert findCaseByTitle("onCommit") + assert findTaskByCaseTitle("onCommit") + + assert findCaseByTitle("onAlways") + assert findTaskByCaseTitle("onAlways") + + useCase = workflowService.findOne(useCase.stringId) + assert useCase.getDataSet().get("text_without_action").getValue().getValue() == "not nested" } @Test void testNestedJoinedTransactions() { - // assert if all happy paths are executed - // consider onAlways + Case useCase = createTestCaseAndSetButton("test", "testNestedJoinedTransactions") + + assert findAllByIdentifier("transaction_test").size() == 7 + assert findCaseByTitle("onButton") + assert findCaseByTitle("onCommit") + assert findCaseByTitle("onAlways") + assert findCaseByTitle("onButtonNested") + assert findCaseByTitle("onCommitNested") + assert findCaseByTitle("onAlwaysNested") + assert !findCaseByTitle("onRollBack") + assert !findCaseByTitle("onRollBackNested") + assert useCase.getDataSet().get("was_transaction_rolled_back").getValue().getValue() == false } @Test void testNestedDifferentTransactions() { - // assert if all happy paths are executed - // consider onAlways + Case useCase = createTestCaseAndSetButton("test", "testNestedDifferentTransactions") + + assert findAllByIdentifier("transaction_test").size() == 7 + assert findCaseByTitle("onButton") + assert findCaseByTitle("onCommit") + assert findCaseByTitle("onAlways") + assert findCaseByTitle("onButtonNested") + assert findCaseByTitle("onCommitNested") + assert findCaseByTitle("onAlwaysNested") + assert !findCaseByTitle("onRollBack") + assert !findCaseByTitle("onRollBackNested") + assert useCase.getDataSet().get("was_transaction_rolled_back").getValue().getValue() == false } @Test void testNestedJoinedTransactionsWithFailureInParentTransaction() { - // assert if runtime exception causes all onRollBacks - // consider onAlways + Case useCase = createTestCaseAndSetButton("test", "testNestedJoinedTransactionsWithFailureInParentTransaction") + + assert findAllByIdentifier("transaction_test").size() == 4 + assert !findCaseByTitle("onButton") + assert !findCaseByTitle("onCommit") + assert findCaseByTitle("onAlways") + assert !findCaseByTitle("onButtonNested") + assert !findCaseByTitle("onCommitNested") + assert !findCaseByTitle("onAlwaysNested") + assert findCaseByTitle("onRollBack") + assert findCaseByTitle("onRollBackNested") + assert useCase.getDataSet().get("was_transaction_rolled_back").getValue().getValue() == true } @Test void testNestedJoinedTransactionsWithFailureInNestedTransaction() { - // assert if runtime exception causes all onRollBacks - // consider onAlways + Case useCase = createTestCaseAndSetButton("test", "testNestedJoinedTransactionsWithFailureInNestedTransaction") + + assert findAllByIdentifier("transaction_test").size() == 4 + assert !findCaseByTitle("onButton") + assert !findCaseByTitle("onCommit") + assert findCaseByTitle("onAlways") + assert !findCaseByTitle("onButtonNested") + assert !findCaseByTitle("onCommitNested") + assert !findCaseByTitle("onAlwaysNested") + assert findCaseByTitle("onRollBack") + assert findCaseByTitle("onRollBackNested") + assert useCase.getDataSet().get("was_transaction_rolled_back").getValue().getValue() == true } @Test void testNestedDifferentTransactionsWithFailureInParentTransaction() { - // assert if runtime exception (in parent action) causes only relevant onRollBacks - // consider onAlways + Case useCase = createTestCaseAndSetButton("test", "testNestedDifferentTransactionsWithFailureInParentTransaction") - // assert if runtime exception (in action where definition of different transition is) causes only relevant onRollBacks - // consider onAlways + assert findAllByIdentifier("transaction_test").size() == 5 + assert !findCaseByTitle("onButton") + assert !findCaseByTitle("onCommit") + assert findCaseByTitle("onAlways") + assert findCaseByTitle("onButtonNested") + assert findCaseByTitle("onCommitNested") + assert !findCaseByTitle("onAlwaysNested") + assert findCaseByTitle("onRollBack") + assert !findCaseByTitle("onRollBackNested") + assert useCase.getDataSet().get("was_transaction_rolled_back").getValue().getValue() == true // is overridden from false to true } @Test void testNestedDifferentTransactionsWithFailureInNestedTransaction() { - // assert if runtime exception causes only relevant onRollBacks - // consider onAlways + Case useCase = createTestCaseAndSetButton("test", "testNestedDifferentTransactionsWithFailureInNestedTransaction") + + assert findAllByIdentifier("transaction_test").size() == 6 + assert findCaseByTitle("onButton") + assert findCaseByTitle("onCommit") + assert findCaseByTitle("onAlways") + assert !findCaseByTitle("onButtonNested") + assert !findCaseByTitle("onCommitNested") + assert findCaseByTitle("onAlwaysNested") + assert !findCaseByTitle("onRollBack") + assert findCaseByTitle("onRollBackNested") + assert useCase.getDataSet().get("was_transaction_rolled_back").getValue().getValue() == false // is overridden from true to false } private Case createTestCaseAndSetButton(String title, String buttonFieldId) { diff --git a/src/test/resources/petriNets/transaction/transaction_test.xml b/src/test/resources/petriNets/transaction/transaction_test.xml index d05b35ee738..231f300d366 100644 --- a/src/test/resources/petriNets/transaction/transaction_test.xml +++ b/src/test/resources/petriNets/transaction/transaction_test.xml @@ -12,10 +12,6 @@ <id>text_without_action</id> <title/> </data> - <data type="text"> - <id>text_2</id> - <title/> - </data> <data type="boolean"> <id>was_transaction_rolled_back</id> @@ -197,6 +193,372 @@ </event> </data> + <data type="button"> + <id>testTransactionWriteConflict</id> + <title/> + <event type="set"> + <id>testTransactionWriteConflict</id> + <actions phase="post"> + <action> + was_transaction_rolled_back: f.was_transaction_rolled_back, + testTransactionWriteConflictNested: f.testTransactionWriteConflictNested, + text_without_action: f.text_without_action; + + def myTransaction = transaction( + event: { + change testTransactionWriteConflictNested value { "some text value" } + change text_without_action value { "not nested" } // should be conflicted + }, + onCommit: { createCase("transaction_test", "onCommit") }, + onRollBack: { createCase("transaction_test", "onRollBack") } + ) + createCase("transaction_test", "onAlways") + + change was_transaction_rolled_back value { myTransaction.wasRolledBack } + </action> + </actions> + </event> + </data> + <data type="text"> + <id>testTransactionWriteConflictNested</id> + <title/> + <event type="set"> + <id>testTransactionWriteConflictNested</id> + <actions phase="post"> + <action> + was_transaction_rolled_back: f.was_transaction_rolled_back, + testTransactionWriteConflictNested: f.testTransactionWriteConflictNested, + text_without_action: f.text_without_action; + + def myTransaction = transaction( + forceCreation: true, + event: { + change text_without_action value { "nested" } + }, + onCommit: { createCase("transaction_test", "onCommitNested") }, + onRollBack: { createCase("transaction_test", "onRollBackNested") } + ) + createCase("transaction_test", "onAlwaysNested") + + change was_transaction_rolled_back value { myTransaction.wasRolledBack } + </action> + </actions> + </event> + </data> + + <data type="button"> + <id>testNestedJoinedTransactions</id> + <title/> + <event type="set"> + <id>testNestedJoinedTransactions</id> + <actions phase="post"> + <action> + was_transaction_rolled_back: f.was_transaction_rolled_back, + testNestedJoinedTransactionsNested: f.testNestedJoinedTransactionsNested, + text_without_action: f.text_without_action; + + def myTransaction = transaction( + event: { + change testNestedJoinedTransactionsNested value { "some text value" } + createCase("transaction_test", "onButton") + }, + onCommit: { createCase("transaction_test", "onCommit") }, + onRollBack: { createCase("transaction_test", "onRollBack") } + ) + createCase("transaction_test", "onAlways") + + change was_transaction_rolled_back value { myTransaction.wasRolledBack } + </action> + </actions> + </event> + </data> + <data type="text"> + <id>testNestedJoinedTransactionsNested</id> + <title/> + <event type="set"> + <id>testNestedJoinedTransactionsNested</id> + <actions phase="post"> + <action> + was_transaction_rolled_back: f.was_transaction_rolled_back, + text_without_action: f.text_without_action; + + def myTransaction = transaction( + event: { + createCase("transaction_test", "onButtonNested") + }, + onCommit: { createCase("transaction_test", "onCommitNested") }, + onRollBack: { createCase("transaction_test", "onRollBackNested") } + ) + createCase("transaction_test", "onAlwaysNested") + + change was_transaction_rolled_back value { myTransaction.wasRolledBack } + </action> + </actions> + </event> + </data> + + <data type="button"> + <id>testNestedDifferentTransactions</id> + <title/> + <event type="set"> + <id>testNestedDifferentTransactions</id> + <actions phase="post"> + <action> + was_transaction_rolled_back: f.was_transaction_rolled_back, + testNestedDifferentTransactionsNested: f.testNestedDifferentTransactionsNested, + text_without_action: f.text_without_action; + + def myTransaction = transaction( + event: { + change testNestedDifferentTransactionsNested value { "some text value" } + createCase("transaction_test", "onButton") + }, + onCommit: { createCase("transaction_test", "onCommit") }, + onRollBack: { createCase("transaction_test", "onRollBack") } + ) + createCase("transaction_test", "onAlways") + + change was_transaction_rolled_back value { myTransaction.wasRolledBack } + </action> + </actions> + </event> + </data> + <data type="text"> + <id>testNestedDifferentTransactionsNested</id> + <title/> + <event type="set"> + <id>testNestedDifferentTransactionsNested</id> + <actions phase="post"> + <action> + was_transaction_rolled_back: f.was_transaction_rolled_back, + text_without_action: f.text_without_action; + + def myTransaction = transaction( + forceCreation: true, + event: { + createCase("transaction_test", "onButtonNested") + }, + onCommit: { createCase("transaction_test", "onCommitNested") }, + onRollBack: { createCase("transaction_test", "onRollBackNested") } + ) + createCase("transaction_test", "onAlwaysNested") + + change was_transaction_rolled_back value { myTransaction.wasRolledBack } + </action> + </actions> + </event> + </data> + + <data type="button"> + <id>testNestedJoinedTransactionsWithFailureInParentTransaction</id> + <title/> + <event type="set"> + <id>testNestedJoinedTransactionsWithFailureInParentTransaction</id> + <actions phase="post"> + <action> + was_transaction_rolled_back: f.was_transaction_rolled_back, + testNestedJoinedTransactionsWithFailureInParentTransactionNested: f.testNestedJoinedTransactionsWithFailureInParentTransactionNested, + text_without_action: f.text_without_action; + + def myTransaction = transaction( + event: { + change testNestedJoinedTransactionsWithFailureInParentTransactionNested value { "some text value" } + createCase("transaction_test", "onButton") + throw new RuntimeException("error") // exception must be thrown after execution of nested action + }, + onCommit: { createCase("transaction_test", "onCommit") }, + onRollBack: { createCase("transaction_test", "onRollBack") } + ) + createCase("transaction_test", "onAlways") + + change was_transaction_rolled_back value { myTransaction.wasRolledBack } + </action> + </actions> + </event> + </data> + <data type="text"> + <id>testNestedJoinedTransactionsWithFailureInParentTransactionNested</id> + <title/> + <event type="set"> + <id>testNestedJoinedTransactionsWithFailureInParentTransactionNested</id> + <actions phase="post"> + <action> + was_transaction_rolled_back: f.was_transaction_rolled_back, + text_without_action: f.text_without_action; + + def myTransaction = transaction( + event: { + createCase("transaction_test", "onButtonNested") + }, + onCommit: { createCase("transaction_test", "onCommitNested") }, + onRollBack: { createCase("transaction_test", "onRollBackNested") } + ) + createCase("transaction_test", "onAlwaysNested") + + change was_transaction_rolled_back value { myTransaction.wasRolledBack } + </action> + </actions> + </event> + </data> + + <data type="button"> + <id>testNestedJoinedTransactionsWithFailureInNestedTransaction</id> + <title/> + <event type="set"> + <id>testNestedJoinedTransactionsWithFailureInNestedTransaction</id> + <actions phase="post"> + <action> + was_transaction_rolled_back: f.was_transaction_rolled_back, + testNestedJoinedTransactionsWithFailureInNestedTransactionNested: f.testNestedJoinedTransactionsWithFailureInNestedTransactionNested, + text_without_action: f.text_without_action; + + def myTransaction = transaction( + event: { + change testNestedJoinedTransactionsWithFailureInNestedTransactionNested value { "some text value" } + createCase("transaction_test", "onButton") + }, + onCommit: { createCase("transaction_test", "onCommit") }, + onRollBack: { createCase("transaction_test", "onRollBack") } + ) + createCase("transaction_test", "onAlways") + + change was_transaction_rolled_back value { myTransaction.wasRolledBack } + </action> + </actions> + </event> + </data> + <data type="text"> + <id>testNestedJoinedTransactionsWithFailureInNestedTransactionNested</id> + <title/> + <event type="set"> + <id>testNestedJoinedTransactionsWithFailureInNestedTransactionNested</id> + <actions phase="post"> + <action> + was_transaction_rolled_back: f.was_transaction_rolled_back, + text_without_action: f.text_without_action; + + def myTransaction = transaction( + event: { + createCase("transaction_test", "onButtonNested") + throw new RuntimeException("error") + }, + onCommit: { createCase("transaction_test", "onCommitNested") }, + onRollBack: { createCase("transaction_test", "onRollBackNested") } + ) + createCase("transaction_test", "onAlwaysNested") + + change was_transaction_rolled_back value { myTransaction.wasRolledBack } + </action> + </actions> + </event> + </data> + + <data type="button"> + <id>testNestedDifferentTransactionsWithFailureInParentTransaction</id> + <title/> + <event type="set"> + <id>testNestedDifferentTransactionsWithFailureInParentTransaction</id> + <actions phase="post"> + <action> + was_transaction_rolled_back: f.was_transaction_rolled_back, + testNestedDifferentTransactionsWithFailureInParentTransactionNested: f.testNestedDifferentTransactionsWithFailureInParentTransactionNested, + text_without_action: f.text_without_action; + + def myTransaction = transaction( + event: { + change testNestedDifferentTransactionsWithFailureInParentTransactionNested value { "some text value" } + createCase("transaction_test", "onButton") + throw new RuntimeException("error") + }, + onCommit: { createCase("transaction_test", "onCommit") }, + onRollBack: { createCase("transaction_test", "onRollBack") } + ) + createCase("transaction_test", "onAlways") + + change was_transaction_rolled_back value { myTransaction.wasRolledBack } + </action> + </actions> + </event> + </data> + <data type="text"> + <id>testNestedDifferentTransactionsWithFailureInParentTransactionNested</id> + <title/> + <event type="set"> + <id>testNestedDifferentTransactionsWithFailureInParentTransactionNested</id> + <actions phase="post"> + <action> + was_transaction_rolled_back: f.was_transaction_rolled_back, + text_without_action: f.text_without_action; + + def myTransaction = transaction( + forceCreation: true, + event: { + createCase("transaction_test", "onButtonNested") + }, + onCommit: { createCase("transaction_test", "onCommitNested") }, + onRollBack: { createCase("transaction_test", "onRollBackNested") } + ) + createCase("transaction_test", "onAlwaysNested") + + change was_transaction_rolled_back value { myTransaction.wasRolledBack } + </action> + </actions> + </event> + </data> + + <data type="button"> + <id>testNestedDifferentTransactionsWithFailureInNestedTransaction</id> + <title/> + <event type="set"> + <id>testNestedDifferentTransactionsWithFailureInNestedTransaction</id> + <actions phase="post"> + <action> + was_transaction_rolled_back: f.was_transaction_rolled_back, + testNestedDifferentTransactionsWithFailureInNestedTransactionNested: f.testNestedDifferentTransactionsWithFailureInNestedTransactionNested, + text_without_action: f.text_without_action; + + def myTransaction = transaction( + event: { + change testNestedDifferentTransactionsWithFailureInNestedTransactionNested value { "some text value" } + createCase("transaction_test", "onButton") + }, + onCommit: { createCase("transaction_test", "onCommit") }, + onRollBack: { createCase("transaction_test", "onRollBack") } + ) + createCase("transaction_test", "onAlways") + + change was_transaction_rolled_back value { myTransaction.wasRolledBack } + </action> + </actions> + </event> + </data> + <data type="text"> + <id>testNestedDifferentTransactionsWithFailureInNestedTransactionNested</id> + <title/> + <event type="set"> + <id>testNestedDifferentTransactionsWithFailureInNestedTransactionNested</id> + <actions phase="post"> + <action> + was_transaction_rolled_back: f.was_transaction_rolled_back, + text_without_action: f.text_without_action; + + def myTransaction = transaction( + forceCreation: true, + event: { + createCase("transaction_test", "onButtonNested") + throw new RuntimeException("error") + }, + onCommit: { createCase("transaction_test", "onCommitNested") }, + onRollBack: { createCase("transaction_test", "onRollBackNested") } + ) + createCase("transaction_test", "onAlwaysNested") + + change was_transaction_rolled_back value { myTransaction.wasRolledBack } + </action> + </actions> + </event> + </data> + <transition> <id>t1</id> <x>496</x> From 2dae3a54ef511c475c960fb68c6375781774a7e5 Mon Sep 17 00:00:00 2001 From: chvostek <chvostek@netgrif.com> Date: Tue, 30 Jul 2024 08:58:09 +0200 Subject: [PATCH 07/48] [NAE-1998] Implement transactions for events - implement error propagation into rollback closure in NaeTransaction - implement test for error propagation --- .../engine/transaction/NaeTransaction.java | 15 ++++++++-- .../engine/transaction/TransactionTest.groovy | 12 ++++++++ .../transaction/transaction_test.xml | 30 +++++++++++++++++++ 3 files changed, 54 insertions(+), 3 deletions(-) diff --git a/src/main/java/com/netgrif/application/engine/transaction/NaeTransaction.java b/src/main/java/com/netgrif/application/engine/transaction/NaeTransaction.java index 11b5b5f1852..c3c70fb0e34 100644 --- a/src/main/java/com/netgrif/application/engine/transaction/NaeTransaction.java +++ b/src/main/java/com/netgrif/application/engine/transaction/NaeTransaction.java @@ -34,6 +34,7 @@ public class NaeTransaction { private Closure<?> onRollBack; private Exception onCallBackException; + private Exception onEventException; private Propagation propagation; private Date deadline; private boolean wasRolledBack; @@ -53,9 +54,14 @@ public void begin() { transactionTemplate.execute(new TransactionCallbackWithoutResult() { protected void doInTransactionWithoutResult(TransactionStatus status) { - registerTransactionCallBacks(); - event.call(); - throwIfDeadlineReached(); // Transaction API does not check the timeout declared in transaction template + try { + registerTransactionCallBacks(); + event.call(); + throwIfDeadlineReached(); // Transaction API does not check the timeout declared in transaction template + } catch (Exception rethrow) { + onEventException = rethrow; + throw rethrow; + } } }); } @@ -71,6 +77,9 @@ public void afterCompletion(int status) { runTransactionCallBack(onCommit); } else if (canCallOnRollBack(status)) { wasRolledBack = true; + if (onEventException != null) { + onRollBack = onRollBack.curry(onEventException); + } runTransactionCallBack(onRollBack); } } diff --git a/src/test/groovy/com/netgrif/application/engine/transaction/TransactionTest.groovy b/src/test/groovy/com/netgrif/application/engine/transaction/TransactionTest.groovy index d27795f5ff1..9aa1edb03e6 100644 --- a/src/test/groovy/com/netgrif/application/engine/transaction/TransactionTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/transaction/TransactionTest.groovy @@ -327,6 +327,18 @@ class TransactionTest { assert useCase.getDataSet().get("was_transaction_rolled_back").getValue().getValue() == false // is overridden from true to false } + @Test + void testRollBackErrorCurrying() { + Case useCase = createTestCaseAndSetButton("test", "testRollBackErrorCurrying") + + assert findAllByIdentifier("transaction_test").size() == 3 + assert !findCaseByTitle("onButton") + assert !findCaseByTitle("onCommit") + assert findCaseByTitle("onAlways") + assert findCaseByTitle("argument is initialized") + assert useCase.getDataSet().get("was_transaction_rolled_back").getValue().getValue() == true + } + private Case createTestCaseAndSetButton(String title, String buttonFieldId) { Case useCase = importHelper.createCase(title, testNet) return dataService.setData(useCase, new DataSet([(buttonFieldId): new ButtonField(rawValue: 1)] diff --git a/src/test/resources/petriNets/transaction/transaction_test.xml b/src/test/resources/petriNets/transaction/transaction_test.xml index 231f300d366..8f0455c82ec 100644 --- a/src/test/resources/petriNets/transaction/transaction_test.xml +++ b/src/test/resources/petriNets/transaction/transaction_test.xml @@ -559,6 +559,36 @@ </event> </data> + <data type="button"> + <id>testRollBackErrorCurrying</id> + <title/> + <event type="set"> + <id>testRollBackErrorCurrying</id> + <actions phase="post"> + <action> + was_transaction_rolled_back: f.was_transaction_rolled_back, + text_without_action: f.text_without_action; + + def myTransaction = transaction( + event: { + createCase("transaction_test", "onButton") + throw new IllegalArgumentException("argument is initialized") + }, + onCommit: { createCase("transaction_test", "onCommit") }, + onRollBack: { e -> + if (e != null && e instanceof IllegalArgumentException) { + createCase("transaction_test", e.getMessage()) + } + } + ) + createCase("transaction_test", "onAlways") + + change was_transaction_rolled_back value { myTransaction.wasRolledBack } + </action> + </actions> + </event> + </data> + <transition> <id>t1</id> <x>496</x> From 8fbae16c05f2bbfb911269627d3084732958e876 Mon Sep 17 00:00:00 2001 From: chvostek <chvostek@netgrif.com> Date: Tue, 30 Jul 2024 15:24:15 +0200 Subject: [PATCH 08/48] [NAE-1998] Implement transactions for events - add javadoc - refactor ActionDelegate.throwIfCallBackFailed - optimize imports --- .../logic/action/ActionDelegate.groovy | 58 +++++++++++++++++-- .../configuration/mongo/MongoConfig.java | 1 - .../service/PetriNetEventHandler.java | 15 ----- .../engine/transaction/NaeTransaction.java | 49 +++++++++++----- .../workflow/service/CaseEventHandler.java | 10 ---- .../workflow/service/TaskEventHandler.java | 11 ---- .../engine/transaction/TransactionTest.groovy | 33 +++++++++++ .../transaction/transaction_test.xml | 31 ++++++++++ 8 files changed, 153 insertions(+), 55 deletions(-) diff --git a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy index cd73c4fe59c..14e565eb59e 100644 --- a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy +++ b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy @@ -215,7 +215,52 @@ class ActionDelegate /*TODO: release/8.0.0: implements ActionAPI*/ { } /** - * todo + * Method runs provided code in database transaction. If the provided code fails, the rollback callback is called + * and no exception is thrown. If the callback fails the subject exception is thrown. + * <br> + * Simple example: + * <pre> + * trans: t.t1, + * text: f.textId; + * + * transactional { + * change text value { "some text value" } + * make text, visible on trans when { true } + * } + * createCase("my_process", "My case") + * </pre> + * Complex example: + * <pre> + * trans: t.t1, + * result: f.resultId, + * text: f.textId; + * + * def myTransaction = transactional ( + * timeout: 1000, + * forceCreation: true, + * event: { + * createCase("my_process", "My case") + * change text value { "some text value" } + * }, + * onCommit: { + * make text, editable on trans when { true } + * }, + * onRollBack: { error -> + * handleError(error) + * } + * ) + * change result value { myTransaction.wasRolledBack } + * </pre> + * + * @param timeout timeout in milliseconds. If the time is reached, transaction fails. The default value is + * {@link TransactionDefinition#TIMEOUT_DEFAULT} + * @param forceCreation if set to true, new transaction is created under any situation. If set to false new + * transaction is created only if none transaction is active + * @param event code to be run in transaction + * @param onCommit callback, that is called after the successful commit + * @param onRollBack callback, that is called after event failure + * + * @returns {@link NaeTransaction} with state after the commit and callback execution * */ @NamedVariant NaeTransaction transaction(int timeout = TransactionDefinition.TIMEOUT_DEFAULT, boolean forceCreation = false, Closure event, @@ -236,13 +281,16 @@ class ActionDelegate /*TODO: release/8.0.0: implements ActionAPI*/ { } /** - * todo + * Logs and throws an exception if the transaction failed on callback execution. + * + * @param transaction object after the commit / rollback * */ protected void throwIfCallBackFailed(NaeTransaction transaction) { - if (transaction.onCallBackException != null) { - log.error("Transaction synchronization call back execution failed with message: {} ", transaction.onCallBackException.getMessage()) - throw transaction.onCallBackException + if (transaction.onCallBackException == null){ + return } + log.error("Transaction synchronization call back execution failed with message: {} ", transaction.onCallBackException.getMessage()) + throw transaction.onCallBackException } protected void executeTransaction(NaeTransaction transaction) { diff --git a/src/main/java/com/netgrif/application/engine/configuration/mongo/MongoConfig.java b/src/main/java/com/netgrif/application/engine/configuration/mongo/MongoConfig.java index e2125c52792..bf7bcb6edd9 100644 --- a/src/main/java/com/netgrif/application/engine/configuration/mongo/MongoConfig.java +++ b/src/main/java/com/netgrif/application/engine/configuration/mongo/MongoConfig.java @@ -1,7 +1,6 @@ package com.netgrif.application.engine.configuration.mongo; import lombok.RequiredArgsConstructor; -import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.autoconfigure.mongo.MongoProperties; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; diff --git a/src/main/java/com/netgrif/application/engine/petrinet/service/PetriNetEventHandler.java b/src/main/java/com/netgrif/application/engine/petrinet/service/PetriNetEventHandler.java index e0cc5c3a6ab..26c80fe6f4d 100644 --- a/src/main/java/com/netgrif/application/engine/petrinet/service/PetriNetEventHandler.java +++ b/src/main/java/com/netgrif/application/engine/petrinet/service/PetriNetEventHandler.java @@ -3,13 +3,10 @@ import com.netgrif.application.engine.elastic.service.interfaces.IElasticPetriNetMappingService; import com.netgrif.application.engine.elastic.service.interfaces.IElasticPetriNetService; import com.netgrif.application.engine.petrinet.domain.PetriNet; -import com.netgrif.application.engine.workflow.domain.Case; import lombok.RequiredArgsConstructor; import lombok.extern.slf4j.Slf4j; import org.bson.Document; import org.bson.types.ObjectId; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.data.mongodb.core.mapping.event.AbstractMongoEventListener; import org.springframework.data.mongodb.core.mapping.event.AfterDeleteEvent; import org.springframework.data.mongodb.core.mapping.event.AfterSaveEvent; import org.springframework.stereotype.Component; @@ -23,12 +20,6 @@ public class PetriNetEventHandler { private final IElasticPetriNetService service; private final IElasticPetriNetMappingService petriNetMappingService; - /** - * todo - * todo does not need to be async - * todo condition because generic - * */ - // todo collectionName from properties @TransactionalEventListener(fallbackExecution = true, condition = "#event.collectionName == 'petriNet'") public void onAfterSave(AfterSaveEvent<PetriNet> event) { PetriNet net = event.getSource(); @@ -39,12 +30,6 @@ public void onAfterSave(AfterSaveEvent<PetriNet> event) { } } - /** - * todo - * todo does not need to be async - * todo condition because generic - * */ - // todo collectionName from properties @TransactionalEventListener(fallbackExecution = true, condition = "#event.collectionName == 'petriNet'") public void onAfterDelete(AfterDeleteEvent<PetriNet> event) { Document document = event.getDocument(); diff --git a/src/main/java/com/netgrif/application/engine/transaction/NaeTransaction.java b/src/main/java/com/netgrif/application/engine/transaction/NaeTransaction.java index c3c70fb0e34..a853f1fffd9 100644 --- a/src/main/java/com/netgrif/application/engine/transaction/NaeTransaction.java +++ b/src/main/java/com/netgrif/application/engine/transaction/NaeTransaction.java @@ -10,27 +10,40 @@ import org.springframework.transaction.TransactionTimedOutException; import org.springframework.transaction.annotation.Propagation; import org.springframework.transaction.support.*; +import com.netgrif.application.engine.petrinet.domain.dataset.logic.action.ActionDelegate; import java.util.Date; import static org.springframework.transaction.support.TransactionSynchronization.STATUS_COMMITTED; import static org.springframework.transaction.support.TransactionSynchronization.STATUS_ROLLED_BACK; -/** - * todo - * */ + @Data @Slf4j @Builder public class NaeTransaction { /** - * todo + * Timeout for the transaction in milliseconds. When the timeout is reached, transaction fails on commit. * */ private int timeout; + /** + * If set to true, new transaction is created in any situation (uses {@link Propagation#REQUIRES_NEW}). If set to + * false, transaction is created only if none exists (uses {@link Propagation#REQUIRED}). + * */ private boolean forceCreation; + /** + * Transaction code to be executed under transaction. + * */ private Closure<?> event; + /** + * Callback, that is called when {@link NaeTransaction#event} is successful. + * */ private Closure<?> onCommit; + /** + * Callback, that is called when {@link NaeTransaction#event} fails. The closure can contain input attribute. If so, + * the input attribute is initialized by the subject exception ({@link NaeTransaction#onEventException}) + * */ private Closure<?> onRollBack; private Exception onCallBackException; @@ -40,12 +53,15 @@ public class NaeTransaction { private boolean wasRolledBack; /** - * todo + * Singleton bean of Mongo transaction manager provided from {@link ActionDelegate#getTransactionManager} * */ private final MongoTransactionManager transactionManager; /** - * todo + * Does additional setups for transaction by {@link TransactionTemplate} and executes provided {@link NaeTransaction#event}. + * <br> + * If the execution is successful callback {@link NaeTransaction#onCommit} is called. Otherwise {@link NaeTransaction#onRollBack} + * is called. If any of the callback fails, exception isn't thrown, but saved in {@link NaeTransaction#onCallBackException} * */ public void begin() { TransactionTemplate transactionTemplate = new TransactionTemplate(transactionManager); @@ -67,8 +83,9 @@ protected void doInTransactionWithoutResult(TransactionStatus status) { } /** - * todo - * does not log the error in the callback + * Registers callbacks for the active transaction. Must be called under active transaction. Callbacks are registered + * by {@link TransactionSynchronizationManager#registerSynchronization(TransactionSynchronization)}. If any of the + * callbacks fails the exception is not thrown. It's saved in {@link NaeTransaction#onCallBackException}. * */ private void registerTransactionCallBacks() { TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization(){ @@ -91,11 +108,14 @@ private boolean canCallOnCommit(int status) { } private boolean canCallOnRollBack(int status) { - return status == STATUS_ROLLED_BACK && onCommit != null; + return status == STATUS_ROLLED_BACK && onRollBack != null; } /** - * todo + * Runs the provided callback. If the callback fails, the exception is saved in {@link NaeTransaction#onCallBackException} + * and thrown. + * + * @param callBack callback to be executed * */ private void runTransactionCallBack(Closure<?> callBack) { try { @@ -108,7 +128,9 @@ private void runTransactionCallBack(Closure<?> callBack) { } /** - * todo + * Initializes the {@link NaeTransaction#deadline} field by the provided timeout in milliseconds. + * + * @param millis timeout in milliseconds. Can be {@link TransactionDefinition#TIMEOUT_DEFAULT} or positive number * */ private void setTimeoutInMillis(long millis) throws IllegalArgumentException { if (timeout == TransactionDefinition.TIMEOUT_DEFAULT) { @@ -122,7 +144,7 @@ private void setTimeoutInMillis(long millis) throws IllegalArgumentException { } /** - * todo + * Throws the {@link TransactionTimedOutException} if the {@link NaeTransaction#deadline} is reached */ private void throwIfDeadlineReached() throws TransactionTimedOutException { if (this.deadline == null) { @@ -135,7 +157,8 @@ private void throwIfDeadlineReached() throws TransactionTimedOutException { } /** - * todo + * Builder extension of the {@link Builder} implementation for {@link }. Containing additional logic over the native builder + * implementation * */ public static class NaeTransactionBuilder { public NaeTransactionBuilder forceCreation(boolean forceCreation) { diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/CaseEventHandler.java b/src/main/java/com/netgrif/application/engine/workflow/service/CaseEventHandler.java index 7f1bdaaa05c..03156a9fccf 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/CaseEventHandler.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/CaseEventHandler.java @@ -20,12 +20,6 @@ public class CaseEventHandler { private final IElasticCaseService service; private final IElasticCaseMappingService caseMappingService; - /** - * todo - * todo does not need to be async - * todo condition because generic - * */ - // todo collectionName from properties @TransactionalEventListener(fallbackExecution = true, condition = "#event.collectionName == 'case'") public void onAfterSave(AfterSaveEvent<Case> event) { Case useCase = event.getSource(); @@ -37,10 +31,6 @@ public void onAfterSave(AfterSaveEvent<Case> event) { } } - /** - * todo - * */ - // todo collectionName from properties @TransactionalEventListener(fallbackExecution = true, condition = "#event.collectionName == 'case'") public void onAfterDelete(AfterDeleteEvent<Case> event) { Document document = event.getDocument(); diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/TaskEventHandler.java b/src/main/java/com/netgrif/application/engine/workflow/service/TaskEventHandler.java index c66ac4fbe41..6820cb46d21 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/TaskEventHandler.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/TaskEventHandler.java @@ -20,22 +20,11 @@ public class TaskEventHandler { private final IElasticTaskService service; private final IElasticTaskMappingService taskMappingService; - /** - * todo - * todo does not need to be async - * todo condition because generic - * */ - // todo collectionName from properties @TransactionalEventListener(fallbackExecution = true, condition = "#event.collectionName == 'task'") public void onAfterSave(AfterSaveEvent<Task> event) { service.index(this.taskMappingService.transform(event.getSource())); } - /** - * todo - * todo condition because generic - * */ - // todo collectionName from properties @TransactionalEventListener(fallbackExecution = true, condition = "#event.collectionName == 'task'") public void onAfterDelete(AfterDeleteEvent<Task> event) { Document document = event.getDocument(); diff --git a/src/test/groovy/com/netgrif/application/engine/transaction/TransactionTest.groovy b/src/test/groovy/com/netgrif/application/engine/transaction/TransactionTest.groovy index 9aa1edb03e6..5c8d7e51c0c 100644 --- a/src/test/groovy/com/netgrif/application/engine/transaction/TransactionTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/transaction/TransactionTest.groovy @@ -22,7 +22,10 @@ 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 import com.netgrif.application.engine.workflow.web.responsebodies.DataSet +import groovy.time.TimeCategory +import groovy.time.TimeDuration import org.junit.jupiter.api.BeforeEach +import org.junit.jupiter.api.Disabled import org.junit.jupiter.api.Test import org.springframework.beans.factory.annotation.Autowired import org.springframework.boot.test.context.SpringBootTest @@ -339,6 +342,36 @@ class TransactionTest { assert useCase.getDataSet().get("was_transaction_rolled_back").getValue().getValue() == true } + @Test + @Disabled + void testPerformance() { + int iterations = 1000 + Case useCase = importHelper.createCase("performance test case", testNet) + + long totalTransactionalDuration = 0 + (0..iterations).each { + Date startTime = new Date() + dataService.setData(useCase, new DataSet(["testCreateCaseInTransactionPerformance": new ButtonField(rawValue: 1)] + as Map<String, Field<?>>), superCreator.getSuperUser()).getCase() + Date endTime = new Date() + TimeDuration elapsedTimeTransactional = TimeCategory.minus( endTime, startTime ) + totalTransactionalDuration += elapsedTimeTransactional.toMilliseconds() + } + + long totalNonTransactionalDuration = 0 + (0..iterations).each { + Date startTime = new Date() + dataService.setData(useCase, new DataSet(["testCreateCasePerformance": new ButtonField(rawValue: 1)] + as Map<String, Field<?>>), superCreator.getSuperUser()).getCase() + Date endTime = new Date() + TimeDuration elapsedTimeTransactional = TimeCategory.minus( endTime, startTime ) + totalNonTransactionalDuration += elapsedTimeTransactional.toMilliseconds() + } + + println("AVG transactional for 1 create case: " + totalTransactionalDuration / iterations + "ms") + println("AVG non-transactional for 1 create case: " + totalNonTransactionalDuration / iterations + "ms") + } + private Case createTestCaseAndSetButton(String title, String buttonFieldId) { Case useCase = importHelper.createCase(title, testNet) return dataService.setData(useCase, new DataSet([(buttonFieldId): new ButtonField(rawValue: 1)] diff --git a/src/test/resources/petriNets/transaction/transaction_test.xml b/src/test/resources/petriNets/transaction/transaction_test.xml index 8f0455c82ec..78f5bb69fee 100644 --- a/src/test/resources/petriNets/transaction/transaction_test.xml +++ b/src/test/resources/petriNets/transaction/transaction_test.xml @@ -589,6 +589,37 @@ </event> </data> + <data type="button"> + <id>testCreateCaseInTransactionPerformance</id> + <title/> + <event type="set"> + <id>testCreateCaseInTransactionPerformance</id> + <actions phase="post"> + <action> + transaction { + createCase("transaction_test", "transactional create case") + } + </action> + </actions> + </event> + </data> + <data type="button"> + <id>testCreateCasePerformance</id> + <title/> + <event type="set"> + <id>testCreateCasePerformance</id> + <actions phase="post"> + <action> + createCase("transaction_test", "non transactional create case") + </action> + </actions> + </event> + </data> + <data type="number"> + <id>iterations</id> + <title/> + </data> + <transition> <id>t1</id> <x>496</x> From ca38f56ec2805e687d8e6108238882aa3834181b Mon Sep 17 00:00:00 2001 From: chvostek <chvostek@netgrif.com> Date: Wed, 31 Jul 2024 07:50:45 +0200 Subject: [PATCH 09/48] [NAE-1998] Implement transactions for events - change mongo configuration to replica set --- docker-compose.yml | 7 +++++++ src/main/resources/application.properties | 2 +- 2 files changed, 8 insertions(+), 1 deletion(-) diff --git a/docker-compose.yml b/docker-compose.yml index e8f9e97c2c6..93cb61876f7 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -3,8 +3,15 @@ version: "3.3" services: docker-mongo: image: mongo:4.4 + command: ["--replSet", "rs0", "--bind_ip_all", "--port", "27017"] + hostname: 127.0.0.1 ports: - "27017:27017" + healthcheck: + test: echo "try { rs.status() } catch (err) { rs.initiate({_id:'rs0',members:[{_id:0,host:'host.docker.internal:27017'}]}) }" | mongosh --port 27017 --quiet + interval: 5s + timeout: 30s + retries: 10 deploy: resources: limits: diff --git a/src/main/resources/application.properties b/src/main/resources/application.properties index 65eacce38f7..29af990d9d6 100644 --- a/src/main/resources/application.properties +++ b/src/main/resources/application.properties @@ -21,7 +21,7 @@ spring.servlet.multipart.max-request-size=50MB nae.uri.index=${DATABASE_NAME:nae}_uri # MongoDB -spring.data.mongodb.uri=${MONGO_URI:mongodb://localhost:27017} +spring.data.mongodb.uri=${MONGO_URI:mongodb://localhost:27017/?replicaSet=rs0} #spring.data.mongodb.host=${MONGO_HOST:localhost} #spring.data.mongodb.port=${MONGO_PORT:27017} spring.data.mongodb.database=${DATABASE_NAME:nae} From d84b099ec8ec8496a2d0c6490f6687409abfa367 Mon Sep 17 00:00:00 2001 From: chvostek <chvostek@netgrif.com> Date: Wed, 31 Jul 2024 09:37:41 +0200 Subject: [PATCH 10/48] [NAE-1998] Implement transactions for events - fix mongo event handlers to work with empty documents --- .../engine/petrinet/service/PetriNetEventHandler.java | 4 ++-- .../application/engine/workflow/service/CaseEventHandler.java | 4 ++-- .../application/engine/workflow/service/TaskEventHandler.java | 4 ++-- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/src/main/java/com/netgrif/application/engine/petrinet/service/PetriNetEventHandler.java b/src/main/java/com/netgrif/application/engine/petrinet/service/PetriNetEventHandler.java index 26c80fe6f4d..4698e59020d 100644 --- a/src/main/java/com/netgrif/application/engine/petrinet/service/PetriNetEventHandler.java +++ b/src/main/java/com/netgrif/application/engine/petrinet/service/PetriNetEventHandler.java @@ -33,8 +33,8 @@ public void onAfterSave(AfterSaveEvent<PetriNet> event) { @TransactionalEventListener(fallbackExecution = true, condition = "#event.collectionName == 'petriNet'") public void onAfterDelete(AfterDeleteEvent<PetriNet> event) { Document document = event.getDocument(); - if (document == null) { - log.warn("Trying to delete null document!"); + if (document == null || document.isEmpty()) { + log.warn("Trying to delete null or empty document!"); return; } diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/CaseEventHandler.java b/src/main/java/com/netgrif/application/engine/workflow/service/CaseEventHandler.java index 03156a9fccf..88c21abdc66 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/CaseEventHandler.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/CaseEventHandler.java @@ -34,8 +34,8 @@ public void onAfterSave(AfterSaveEvent<Case> event) { @TransactionalEventListener(fallbackExecution = true, condition = "#event.collectionName == 'case'") public void onAfterDelete(AfterDeleteEvent<Case> event) { Document document = event.getDocument(); - if (document == null) { - log.warn("Trying to delete null document!"); + if (document == null || document.isEmpty()) { + log.warn("Trying to delete null or empty document!"); return; } diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/TaskEventHandler.java b/src/main/java/com/netgrif/application/engine/workflow/service/TaskEventHandler.java index 6820cb46d21..879387dfca3 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/TaskEventHandler.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/TaskEventHandler.java @@ -28,8 +28,8 @@ public void onAfterSave(AfterSaveEvent<Task> event) { @TransactionalEventListener(fallbackExecution = true, condition = "#event.collectionName == 'task'") public void onAfterDelete(AfterDeleteEvent<Task> event) { Document document = event.getDocument(); - if (document == null) { - log.warn("Trying to delete null document!"); + if (document == null || document.isEmpty()) { + log.warn("Trying to delete null or empty document!"); return; } From b065b1644acf824d3d7b339e3e4a85ee5bbe9c84 Mon Sep 17 00:00:00 2001 From: chvostek <chvostek@netgrif.com> Date: Wed, 31 Jul 2024 09:49:01 +0200 Subject: [PATCH 11/48] [NAE-1998] Implement transactions for events - fix access modifiers in ActionRunner and MongoConfig --- .../petrinet/domain/dataset/logic/action/ActionRunner.groovy | 3 ++- .../application/engine/configuration/mongo/MongoConfig.java | 2 +- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionRunner.groovy b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionRunner.groovy index d80b305c3bc..0449d3aaddc 100644 --- a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionRunner.groovy +++ b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionRunner.groovy @@ -26,7 +26,8 @@ abstract class ActionRunner { @Autowired private IFieldActionsCacheService actionsCacheService - @Autowired MongoTransactionManager transactionManager + @Autowired + private MongoTransactionManager transactionManager private Map<String, Object> actionsCache = new HashMap<>() diff --git a/src/main/java/com/netgrif/application/engine/configuration/mongo/MongoConfig.java b/src/main/java/com/netgrif/application/engine/configuration/mongo/MongoConfig.java index bf7bcb6edd9..6ee9d750588 100644 --- a/src/main/java/com/netgrif/application/engine/configuration/mongo/MongoConfig.java +++ b/src/main/java/com/netgrif/application/engine/configuration/mongo/MongoConfig.java @@ -15,7 +15,7 @@ public class MongoConfig extends AbstractMongoClientConfiguration { private final MongoProperties properties; @Bean - MongoTransactionManager transactionManager(MongoDatabaseFactory dbFactory) { + public MongoTransactionManager transactionManager(MongoDatabaseFactory dbFactory) { return new MongoTransactionManager(dbFactory); } From 7d84da07e3a71c837ae48f2df33fd59e734f128f Mon Sep 17 00:00:00 2001 From: Machac <machac@netgrif.com> Date: Wed, 31 Jul 2024 12:49:43 +0200 Subject: [PATCH 12/48] [NAE-1998] Implement transactions for events - edit github pipeline --- .github/workflows/pr-build.yml | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/.github/workflows/pr-build.yml b/.github/workflows/pr-build.yml index 57906d4a391..751daec62a6 100644 --- a/.github/workflows/pr-build.yml +++ b/.github/workflows/pr-build.yml @@ -38,6 +38,12 @@ jobs: image: mongo:4.4 ports: - 27017:27017 + options: --replSet rs0 --bind_ip_all + healthcheck: + test: echo "try { rs.status() } catch (err) { rs.initiate({_id:'rs0',members:[{_id:0,host:'localhost:27017'}]}) }" | mongo --quiet + interval: 5s + timeout: 30s + retries: 10 redis: image: redis From b708b64dd6f4b840e651518ca4fedb859f5993ec Mon Sep 17 00:00:00 2001 From: Machac <machac@netgrif.com> Date: Wed, 31 Jul 2024 12:51:36 +0200 Subject: [PATCH 13/48] [NAE-1998] Implement transactions for events - edit github pipeline --- .github/workflows/pr-build.yml | 5 ----- 1 file changed, 5 deletions(-) diff --git a/.github/workflows/pr-build.yml b/.github/workflows/pr-build.yml index 751daec62a6..b3c6ca73e88 100644 --- a/.github/workflows/pr-build.yml +++ b/.github/workflows/pr-build.yml @@ -39,11 +39,6 @@ jobs: ports: - 27017:27017 options: --replSet rs0 --bind_ip_all - healthcheck: - test: echo "try { rs.status() } catch (err) { rs.initiate({_id:'rs0',members:[{_id:0,host:'localhost:27017'}]}) }" | mongo --quiet - interval: 5s - timeout: 30s - retries: 10 redis: image: redis From c25fd5e1ceca9a8032345a428b2f64833db6061e Mon Sep 17 00:00:00 2001 From: Machac <machac@netgrif.com> Date: Wed, 31 Jul 2024 12:56:22 +0200 Subject: [PATCH 14/48] [NAE-1998] Implement transactions for events - edit github pipeline --- .github/workflows/pr-build.yml | 18 ++++++++++++++++-- 1 file changed, 16 insertions(+), 2 deletions(-) diff --git a/.github/workflows/pr-build.yml b/.github/workflows/pr-build.yml index b3c6ca73e88..b3043585475 100644 --- a/.github/workflows/pr-build.yml +++ b/.github/workflows/pr-build.yml @@ -38,7 +38,7 @@ jobs: image: mongo:4.4 ports: - 27017:27017 - options: --replSet rs0 --bind_ip_all + command: ["mongod", "--replSet", "rs0", "--bind_ip_all"] redis: image: redis @@ -84,10 +84,24 @@ jobs: key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.xml') }} restore-keys: ${{ runner.os }}-m2 + - name: Wait for MongoDB to be ready + run: | + for i in {1..30}; do + if mongo --eval "print(\"waited for connection\")" &>/dev/null; then + echo "MongoDB is up" + break + fi + echo "Waiting for MongoDB..." + sleep 2 + done + + - name: Initialize MongoDB Replica Set + run: | + echo 'rs.initiate({_id: "rs0", members: [{_id: 0, host: "localhost:27017"}]})' | mongo + - name: Generate certificates run: cd src/main/resources/certificates && openssl genrsa -out keypair.pem 4096 && openssl rsa -in keypair.pem -pubout -out public.crt && openssl pkcs8 -topk8 -inform PEM -outform DER -nocrypt -in keypair.pem -out private.der && cd ../../../.. - - name: Build run: mvn clean package install -DskipTests=true From df95e08b6533b99a2ca42ac2ebd36d1dbc39e788 Mon Sep 17 00:00:00 2001 From: Machac <machac@netgrif.com> Date: Wed, 31 Jul 2024 12:57:40 +0200 Subject: [PATCH 15/48] [NAE-1998] Implement transactions for events - edit github pipeline --- .github/workflows/pr-build.yml | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/.github/workflows/pr-build.yml b/.github/workflows/pr-build.yml index b3043585475..d8f4ac71417 100644 --- a/.github/workflows/pr-build.yml +++ b/.github/workflows/pr-build.yml @@ -38,7 +38,10 @@ jobs: image: mongo:4.4 ports: - 27017:27017 - command: ["mongod", "--replSet", "rs0", "--bind_ip_all"] + options: >- + --entrypoint "/usr/bin/mongod" + --replSet rs0 + --bind_ip_all redis: image: redis From ca90d161e238e68fe4f1a1b139086ed0997877c5 Mon Sep 17 00:00:00 2001 From: Machac <machac@netgrif.com> Date: Wed, 31 Jul 2024 13:11:20 +0200 Subject: [PATCH 16/48] [NAE-1998] Implement transactions for events - edit github pipeline --- .github/workflows/pr-build.yml | 20 +------------------- 1 file changed, 1 insertion(+), 19 deletions(-) diff --git a/.github/workflows/pr-build.yml b/.github/workflows/pr-build.yml index d8f4ac71417..5a1b54d1fd4 100644 --- a/.github/workflows/pr-build.yml +++ b/.github/workflows/pr-build.yml @@ -38,10 +38,7 @@ jobs: image: mongo:4.4 ports: - 27017:27017 - options: >- - --entrypoint "/usr/bin/mongod" - --replSet rs0 - --bind_ip_all + options: --entrypoint "/usr/bin/mongod" --replSet "rs0" --bind_ip_all redis: image: redis @@ -87,21 +84,6 @@ jobs: key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.xml') }} restore-keys: ${{ runner.os }}-m2 - - name: Wait for MongoDB to be ready - run: | - for i in {1..30}; do - if mongo --eval "print(\"waited for connection\")" &>/dev/null; then - echo "MongoDB is up" - break - fi - echo "Waiting for MongoDB..." - sleep 2 - done - - - name: Initialize MongoDB Replica Set - run: | - echo 'rs.initiate({_id: "rs0", members: [{_id: 0, host: "localhost:27017"}]})' | mongo - - name: Generate certificates run: cd src/main/resources/certificates && openssl genrsa -out keypair.pem 4096 && openssl rsa -in keypair.pem -pubout -out public.crt && openssl pkcs8 -topk8 -inform PEM -outform DER -nocrypt -in keypair.pem -out private.der && cd ../../../.. From a64e46955af35b89ecfb0f7fc0c0f50e5c1df6e7 Mon Sep 17 00:00:00 2001 From: Machac <machac@netgrif.com> Date: Wed, 31 Jul 2024 13:16:50 +0200 Subject: [PATCH 17/48] [NAE-1998] Implement transactions for events - edit github pipeline --- .github/workflows/pr-build.yml | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/.github/workflows/pr-build.yml b/.github/workflows/pr-build.yml index 5a1b54d1fd4..de467d5026e 100644 --- a/.github/workflows/pr-build.yml +++ b/.github/workflows/pr-build.yml @@ -34,11 +34,6 @@ jobs: runs-on: ubuntu-latest timeout-minutes: 200 services: - mongo: - image: mongo:4.4 - ports: - - 27017:27017 - options: --entrypoint "/usr/bin/mongod" --replSet "rs0" --bind_ip_all redis: image: redis @@ -53,6 +48,12 @@ jobs: options: -e="discovery.type=single-node" -e="xpack.security.enabled=false" --health-cmd="curl http://localhost:9200/_cluster/health" --health-interval=10s --health-timeout=5s --health-retries=10 steps: + - name: Start MongoDB + uses: MongoCamp/mongodb-github-action@1.0.0 + with: + mongodb-version: 4.4 + mongodb-replica-set: rs0 + - name: Test Database env: ELASTIC_SEARCH_URL: http://localhost:${{ job.services.elasticsearch.ports[9200] }} From ad33f60bf9cfc12c2c69d211a085ee1128c08089 Mon Sep 17 00:00:00 2001 From: Machac <machac@netgrif.com> Date: Wed, 31 Jul 2024 13:27:13 +0200 Subject: [PATCH 18/48] [NAE-1998] Implement transactions for events - edit github pipeline --- .github/workflows/pr-build.yml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/.github/workflows/pr-build.yml b/.github/workflows/pr-build.yml index de467d5026e..c94b2627d4b 100644 --- a/.github/workflows/pr-build.yml +++ b/.github/workflows/pr-build.yml @@ -49,11 +49,13 @@ jobs: steps: - name: Start MongoDB - uses: MongoCamp/mongodb-github-action@1.0.0 + uses: MongoCamp/mongodb-github-action@1.2.0 with: mongodb-version: 4.4 mongodb-replica-set: rs0 + - run: curl http://localhost:27017 + - name: Test Database env: ELASTIC_SEARCH_URL: http://localhost:${{ job.services.elasticsearch.ports[9200] }} From e366c59aa5ad719f010fb6bc5e9df21fd7ed6ba0 Mon Sep 17 00:00:00 2001 From: Machac <machac@netgrif.com> Date: Wed, 31 Jul 2024 13:33:41 +0200 Subject: [PATCH 19/48] [NAE-1998] Implement transactions for events - edit github pipeline --- .github/workflows/pr-build.yml | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/.github/workflows/pr-build.yml b/.github/workflows/pr-build.yml index c94b2627d4b..a2aba666724 100644 --- a/.github/workflows/pr-build.yml +++ b/.github/workflows/pr-build.yml @@ -54,14 +54,15 @@ jobs: mongodb-version: 4.4 mongodb-replica-set: rs0 - - run: curl http://localhost:27017 - - name: Test Database env: ELASTIC_SEARCH_URL: http://localhost:${{ job.services.elasticsearch.ports[9200] }} + MONGO_URL: http://localhost:27017 run: | echo $ELASTIC_SEARCH_URL + echo $MONGO_URL curl -fsSL "$ELASTIC_SEARCH_URL/_cat/health?h=status" + curl -fsSL "$MONGO_URL" - uses: actions/checkout@v3 with: From a3405dda02c55129dd7f1b3ddc39037467e27903 Mon Sep 17 00:00:00 2001 From: Machac <machac@netgrif.com> Date: Wed, 31 Jul 2024 13:41:13 +0200 Subject: [PATCH 20/48] [NAE-1998] Implement transactions for events - edit github pipeline --- .github/workflows/pr-build.yml | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/.github/workflows/pr-build.yml b/.github/workflows/pr-build.yml index a2aba666724..9979db57996 100644 --- a/.github/workflows/pr-build.yml +++ b/.github/workflows/pr-build.yml @@ -54,6 +54,30 @@ jobs: mongodb-version: 4.4 mongodb-replica-set: rs0 + - name: Wait for Elasticsearch to be ready + run: | + echo "Waiting for Elasticsearch to be ready..." + for i in {1..30}; do + if curl -fsSL http://localhost:9200/_cluster/health | grep '"status":"green"' &>/dev/null; then + echo "Elasticsearch is up" + break + fi + echo "Waiting for Elasticsearch..." + sleep 2 + done + + - name: Wait for MongoDB to be ready + run: | + echo "Waiting for MongoDB to be ready..." + for i in {1..30}; do + if mongo --eval "print(\"MongoDB is up\")" &>/dev/null; then + echo "MongoDB is up" + break + fi + echo "Waiting for MongoDB..." + sleep 2 + done + - name: Test Database env: ELASTIC_SEARCH_URL: http://localhost:${{ job.services.elasticsearch.ports[9200] }} From 91cf4f7182d02ba9bdedf0efdccae835ca6e788a Mon Sep 17 00:00:00 2001 From: Machac <machac@netgrif.com> Date: Wed, 31 Jul 2024 13:51:17 +0200 Subject: [PATCH 21/48] [NAE-1998] Implement transactions for events - edit github pipeline --- .github/workflows/pr-build.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/pr-build.yml b/.github/workflows/pr-build.yml index 9979db57996..0ba8ed18add 100644 --- a/.github/workflows/pr-build.yml +++ b/.github/workflows/pr-build.yml @@ -70,7 +70,7 @@ jobs: run: | echo "Waiting for MongoDB to be ready..." for i in {1..30}; do - if mongo --eval "print(\"MongoDB is up\")" &>/dev/null; then + if mongo --eval "printjson(db.serverStatus())" &>/dev/null; then echo "MongoDB is up" break fi From 28c887a97f449200ee9903e3fcdf396ffc77e4a7 Mon Sep 17 00:00:00 2001 From: chvostek <chvostek@netgrif.com> Date: Mon, 5 Aug 2024 14:35:15 +0200 Subject: [PATCH 22/48] [NAE-1998] Implement transactions for events - optimize WorkflowService.createCase --- .../logic/action/ActionDelegate.groovy | 19 +- .../startup/DefaultFiltersRunner.groovy | 9 +- .../engine/startup/FilterRunner.groovy | 1 - .../engine/startup/ImportHelper.groovy | 11 +- .../orgstructure/groups/NextGroupService.java | 11 +- .../petrinet/service/PetriNetService.java | 3 +- .../engine/rules/config/RuleProperties.java | 15 ++ .../engine/rules/service/RuleEngine.java | 16 +- .../engine/workflow/domain/Case.java | 7 + .../dataoutcomes/GetDataEventOutcome.java | 1 - .../domain/outcome/CreateTasksOutcome.java | 14 + .../domain/params/CreateCaseParams.java | 63 +++++ .../service/FilterImportExportService.java | 17 +- .../service/MenuImportExportService.java | 14 +- .../engine/workflow/service/TaskService.java | 245 ++++++++++-------- .../workflow/service/WorkflowService.java | 171 ++++++------ .../service/interfaces/IDataService.java | 4 - .../service/interfaces/ITaskService.java | 8 +- .../service/interfaces/IWorkflowService.java | 20 +- .../web/PublicWorkflowController.java | 10 +- .../workflow/web/WorkflowController.java | 10 +- .../engine/action/AssignRemoveTest.groovy | 9 +- .../auth/TaskAuthorizationServiceTest.groovy | 83 +++++- .../WorkflowAuthorizationServiceTest.groovy | 33 ++- .../engine/elastic/ReindexTest.groovy | 11 +- .../engine/history/HistoryServiceTest.groovy | 26 +- .../PredefinedRolesPermissionsTest.groovy | 9 +- .../engine/importer/UserListTest.groovy | 1 - .../engine/insurance/EncryptionTest.groovy | 9 +- .../ElasticSearchViewPermissionTest.groovy | 57 +++- .../petrinet/domain/FunctionsTest.groovy | 65 ++++- .../petrinet/domain/ImporterTest.groovy | 17 +- .../domain/dataset/DynamicCaseNameTest.groovy | 19 +- .../dataset/DynamicValidationTest.groovy | 7 - .../domain/dataset/FileFieldTest.groovy | 17 +- .../ChangedFieldsAllowedNetsTest.groovy | 2 - .../engine/workflow/NewInitTest.groovy | 9 +- .../engine/workflow/TaskStateTest.groovy | 17 +- .../workflow/WorkflowServiceTest.groovy | 84 +++++- .../engine/importer/ImporterTest.java | 10 +- .../engine/rules/service/RuleEngineTest.java | 18 +- .../RuleEvaluationScheduleServiceTest.java | 9 +- .../workflow/service/TaskServiceTest.java | 17 +- .../engine/workflow/web/VariableArcsTest.java | 10 +- .../change_caseref_value_action_test.xml | 20 +- 45 files changed, 891 insertions(+), 337 deletions(-) create mode 100644 src/main/java/com/netgrif/application/engine/rules/config/RuleProperties.java create mode 100644 src/main/java/com/netgrif/application/engine/workflow/domain/outcome/CreateTasksOutcome.java create mode 100644 src/main/java/com/netgrif/application/engine/workflow/domain/params/CreateCaseParams.java diff --git a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy index 14e565eb59e..3ae314fb488 100644 --- a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy +++ b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy @@ -45,6 +45,7 @@ import com.netgrif.application.engine.workflow.domain.eventoutcomes.taskoutcomes import com.netgrif.application.engine.workflow.domain.eventoutcomes.taskoutcomes.TaskEventOutcome 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.service.FileFieldInputStream import com.netgrif.application.engine.workflow.service.TaskService import com.netgrif.application.engine.workflow.service.interfaces.* @@ -801,11 +802,25 @@ class ActionDelegate /*TODO: release/8.0.0: implements ActionAPI*/ { } Case createCase(String identifier, String title = null, String color = "", IUser author = userService.loggedOrSystem, Locale locale = LocaleContextHolder.getLocale(), Map<String, String> params = [:]) { - return workflowService.createCaseByIdentifier(identifier, title, color, author.transformToLoggedUser(), locale, params).getCase() + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNetIdentifier(identifier) + .title(title) + .color(color) + .loggedUser(author.transformToLoggedUser()) + .params(params) + .build() + return workflowService.createCase(createCaseParams).getCase() } Case createCase(PetriNet net, String title = net.defaultCaseName.getTranslation(locale), String color = "", IUser author = userService.loggedOrSystem, Locale locale = LocaleContextHolder.getLocale(), Map<String, String> params = [:]) { - CreateCaseEventOutcome outcome = workflowService.createCase(net.stringId, title, color, author.transformToLoggedUser(), params) + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(net) + .title(title) + .color(color) + .loggedUser(author.transformToLoggedUser()) + .params(params) + .build() + CreateCaseEventOutcome outcome = workflowService.createCase(createCaseParams) this.outcomes.add(outcome) return outcome.getCase() } diff --git a/src/main/groovy/com/netgrif/application/engine/startup/DefaultFiltersRunner.groovy b/src/main/groovy/com/netgrif/application/engine/startup/DefaultFiltersRunner.groovy index da3594dd345..795e38acea1 100644 --- a/src/main/groovy/com/netgrif/application/engine/startup/DefaultFiltersRunner.groovy +++ b/src/main/groovy/com/netgrif/application/engine/startup/DefaultFiltersRunner.groovy @@ -13,6 +13,7 @@ import com.netgrif.application.engine.workflow.domain.Case import com.netgrif.application.engine.workflow.domain.QCase import com.netgrif.application.engine.workflow.domain.QTask import com.netgrif.application.engine.workflow.domain.Task +import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams 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 @@ -271,7 +272,13 @@ class DefaultFiltersRunner extends AbstractOrderedCommandLineRunner { } } - Case filterCase = this.workflowService.createCase(filterNet.getStringId(), title, null, loggedUser.transformToLoggedUser()).getCase() + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(filterNet) + .title(title) + .color(null) + .loggedUser(loggedUser.transformToLoggedUser()) + .build() + Case filterCase = this.workflowService.createCase(createCaseParams).getCase() filterCase.setIcon(icon) filterCase = this.workflowService.save(filterCase) Task newFilterTask = this.taskService.searchOne(QTask.task.transitionId.eq(AUTO_CREATE_TRANSITION).and(QTask.task.caseId.eq(filterCase.getStringId()))) diff --git a/src/main/groovy/com/netgrif/application/engine/startup/FilterRunner.groovy b/src/main/groovy/com/netgrif/application/engine/startup/FilterRunner.groovy index bf68e37691e..9bc56d24b0f 100644 --- a/src/main/groovy/com/netgrif/application/engine/startup/FilterRunner.groovy +++ b/src/main/groovy/com/netgrif/application/engine/startup/FilterRunner.groovy @@ -3,7 +3,6 @@ package com.netgrif.application.engine.startup import com.netgrif.application.engine.petrinet.domain.PetriNet import com.netgrif.application.engine.petrinet.domain.VersionType import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService -import com.netgrif.application.engine.workflow.domain.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome import groovy.transform.CompileStatic import groovy.util.logging.Slf4j import org.springframework.beans.factory.annotation.Autowired diff --git a/src/main/groovy/com/netgrif/application/engine/startup/ImportHelper.groovy b/src/main/groovy/com/netgrif/application/engine/startup/ImportHelper.groovy index b03c6f26aa9..f7718ad232b 100644 --- a/src/main/groovy/com/netgrif/application/engine/startup/ImportHelper.groovy +++ b/src/main/groovy/com/netgrif/application/engine/startup/ImportHelper.groovy @@ -17,6 +17,7 @@ import com.netgrif.application.engine.workflow.domain.eventoutcomes.dataoutcomes import com.netgrif.application.engine.workflow.domain.eventoutcomes.taskoutcomes.AssignTaskEventOutcome import com.netgrif.application.engine.workflow.domain.eventoutcomes.taskoutcomes.CancelTaskEventOutcome import com.netgrif.application.engine.workflow.domain.eventoutcomes.taskoutcomes.FinishTaskEventOutcome +import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams import com.netgrif.application.engine.workflow.domain.repositories.CaseRepository import com.netgrif.application.engine.workflow.service.interfaces.IDataService import com.netgrif.application.engine.workflow.service.interfaces.ITaskService @@ -24,8 +25,6 @@ import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowServi import com.netgrif.application.engine.workflow.web.responsebodies.DataSet import com.netgrif.application.engine.workflow.web.responsebodies.TaskReference import groovy.util.logging.Slf4j -import org.slf4j.Logger -import org.slf4j.LoggerFactory import org.springframework.beans.factory.annotation.Autowired import org.springframework.core.io.ClassPathResource import org.springframework.core.io.ResourceLoader @@ -141,7 +140,13 @@ class ImportHelper { } Case createCase(String title, PetriNet net, LoggedUser user) { - return workflowService.createCase(net.getStringId(), title, "", user).getCase() + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(net) + .title(title) + .color("") + .loggedUser(user) + .build() + return workflowService.createCase(createCaseParams).getCase() } Case createCase(String title, PetriNet net) { diff --git a/src/main/java/com/netgrif/application/engine/orgstructure/groups/NextGroupService.java b/src/main/java/com/netgrif/application/engine/orgstructure/groups/NextGroupService.java index 37d333dc805..ba86d7689c1 100644 --- a/src/main/java/com/netgrif/application/engine/orgstructure/groups/NextGroupService.java +++ b/src/main/java/com/netgrif/application/engine/orgstructure/groups/NextGroupService.java @@ -21,11 +21,11 @@ import com.netgrif.application.engine.workflow.domain.QCase; import com.netgrif.application.engine.workflow.domain.Task; import com.netgrif.application.engine.workflow.domain.eventoutcomes.caseoutcomes.CreateCaseEventOutcome; +import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams; 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; import com.netgrif.application.engine.workflow.web.responsebodies.DataSet; -import com.netgrif.application.engine.workflow.web.responsebodies.TaskDataSets; import com.netgrif.application.engine.workflow.web.responsebodies.TaskReference; import com.querydsl.core.BooleanBuilder; import com.querydsl.core.types.Predicate; @@ -106,8 +106,13 @@ public CreateCaseEventOutcome createGroup(String title, IUser author) { if (userDefaultGroup != null && userDefaultGroup.getTitle().equals(title)) { return null; } - PetriNet orgGroupNet = petriNetService.getNewestVersionByIdentifier(GROUP_NET_IDENTIFIER); - CreateCaseEventOutcome outcome = workflowService.createCase(orgGroupNet.getStringId(), title, "", author.transformToLoggedUser()); + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(petriNetService.getNewestVersionByIdentifier(GROUP_NET_IDENTIFIER)) + .title(title) + .color("") + .loggedUser(author.transformToLoggedUser()) + .build(); + CreateCaseEventOutcome outcome = workflowService.createCase(createCaseParams); DataSet taskData = getInitialGroupData(author, title, outcome.getCase()); Task initTask = getGroupInitTask(outcome.getCase()); diff --git a/src/main/java/com/netgrif/application/engine/petrinet/service/PetriNetService.java b/src/main/java/com/netgrif/application/engine/petrinet/service/PetriNetService.java index 0acd7b6494e..3a064ebeb78 100644 --- a/src/main/java/com/netgrif/application/engine/petrinet/service/PetriNetService.java +++ b/src/main/java/com/netgrif/application/engine/petrinet/service/PetriNetService.java @@ -5,7 +5,6 @@ import com.netgrif.application.engine.auth.domain.LoggedUser; import com.netgrif.application.engine.auth.service.interfaces.IUserService; import com.netgrif.application.engine.configuration.properties.CacheProperties; -import com.netgrif.application.engine.elastic.service.interfaces.IElasticPetriNetMappingService; import com.netgrif.application.engine.elastic.service.interfaces.IElasticPetriNetService; import com.netgrif.application.engine.history.domain.petrinetevents.DeletePetriNetEventLog; import com.netgrif.application.engine.history.domain.petrinetevents.ImportPetriNetEventLog; @@ -273,7 +272,7 @@ public Optional<PetriNet> save(PetriNet petriNet) { public PetriNet getPetriNet(String id) { Optional<PetriNet> net = repository.findById(id); if (net.isEmpty()) { - throw new IllegalArgumentException("No Petri net with id: " + id + " was found."); + throw new IllegalArgumentException("Petri net with id [" + id + "] was found."); } net.get().initializeArcs(); return net.get(); diff --git a/src/main/java/com/netgrif/application/engine/rules/config/RuleProperties.java b/src/main/java/com/netgrif/application/engine/rules/config/RuleProperties.java new file mode 100644 index 00000000000..fce6ce08387 --- /dev/null +++ b/src/main/java/com/netgrif/application/engine/rules/config/RuleProperties.java @@ -0,0 +1,15 @@ +package com.netgrif.application.engine.rules.config; + +import lombok.Data; +import org.springframework.boot.context.properties.ConfigurationProperties; +import org.springframework.context.annotation.Configuration; + +@Data +@Configuration +@ConfigurationProperties(prefix = "rule-engine") +public class RuleProperties { + + private boolean enabled = false; + private boolean rethrowExceptions = false; + +} diff --git a/src/main/java/com/netgrif/application/engine/rules/service/RuleEngine.java b/src/main/java/com/netgrif/application/engine/rules/service/RuleEngine.java index b0fb56e444f..ad5d0d32d74 100644 --- a/src/main/java/com/netgrif/application/engine/rules/service/RuleEngine.java +++ b/src/main/java/com/netgrif/application/engine/rules/service/RuleEngine.java @@ -1,6 +1,7 @@ package com.netgrif.application.engine.rules.service; import com.netgrif.application.engine.petrinet.domain.PetriNet; +import com.netgrif.application.engine.rules.config.RuleProperties; import com.netgrif.application.engine.rules.domain.RuleRepository; import com.netgrif.application.engine.rules.domain.facts.CaseCreatedFact; import com.netgrif.application.engine.rules.domain.facts.NetImportedFact; @@ -9,11 +10,10 @@ import com.netgrif.application.engine.rules.service.interfaces.IRuleEngine; import com.netgrif.application.engine.workflow.domain.Case; import com.netgrif.application.engine.workflow.domain.Task; +import lombok.RequiredArgsConstructor; import lombok.extern.slf4j.Slf4j; import org.kie.api.runtime.KieSession; -import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Lookup; -import org.springframework.beans.factory.annotation.Value; import org.springframework.stereotype.Service; import java.util.Arrays; @@ -21,14 +21,12 @@ @Slf4j @Service +@RequiredArgsConstructor public abstract class RuleEngine implements IRuleEngine { - // TODO: release/8.0.0 properties - @Value("${rule-engine.rethrow-exceptions:#{false}}") - protected boolean rethrowExceptions; + private final RuleRepository ruleRepository; - @Autowired - private RuleRepository ruleRepository; + private final RuleProperties properties; @Lookup protected abstract KieSession ruleEngine(); @@ -59,7 +57,7 @@ public int evaluateRules(PetriNet petriNet, ScheduledRuleFact scheduledRuleFact) } private int evaluateWithFacts(List<Object> facts) { - if (ruleRepository.count() == 0) { + if (!properties.isEnabled() || ruleRepository.count() == 0) { return 0; } KieSession session = null; @@ -70,7 +68,7 @@ private int evaluateWithFacts(List<Object> facts) { numberOfRulesExecuted = session.fireAllRules(); } catch (Exception e) { log.error("Rule engine failure", e); - if (rethrowExceptions) { + if (properties.isRethrowExceptions()) { throw e; } } finally { diff --git a/src/main/java/com/netgrif/application/engine/workflow/domain/Case.java b/src/main/java/com/netgrif/application/engine/workflow/domain/Case.java index 48cb9e903f5..941d32daa47 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/domain/Case.java +++ b/src/main/java/com/netgrif/application/engine/workflow/domain/Case.java @@ -179,6 +179,13 @@ public void addTask(Task task) { this.tasks.put(task.getTransitionId(), new TaskPair(task)); } + public void addTasks(Collection<Task> tasks) { + if (tasks == null) { + return; + } + tasks.forEach(this::addTask); + } + public void removeTasks(List<Task> tasks) { tasks.forEach(task -> this.tasks.remove(task.getTransitionId()) diff --git a/src/main/java/com/netgrif/application/engine/workflow/domain/eventoutcomes/dataoutcomes/GetDataEventOutcome.java b/src/main/java/com/netgrif/application/engine/workflow/domain/eventoutcomes/dataoutcomes/GetDataEventOutcome.java index 9eba59cc505..08d47545f7c 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/domain/eventoutcomes/dataoutcomes/GetDataEventOutcome.java +++ b/src/main/java/com/netgrif/application/engine/workflow/domain/eventoutcomes/dataoutcomes/GetDataEventOutcome.java @@ -2,7 +2,6 @@ import com.netgrif.application.engine.petrinet.domain.DataRef; import com.netgrif.application.engine.petrinet.domain.I18nString; -import com.netgrif.application.engine.petrinet.domain.dataset.Field; import com.netgrif.application.engine.workflow.domain.Case; import com.netgrif.application.engine.workflow.domain.Task; import com.netgrif.application.engine.workflow.domain.eventoutcomes.EventOutcome; diff --git a/src/main/java/com/netgrif/application/engine/workflow/domain/outcome/CreateTasksOutcome.java b/src/main/java/com/netgrif/application/engine/workflow/domain/outcome/CreateTasksOutcome.java new file mode 100644 index 00000000000..4f47d408f61 --- /dev/null +++ b/src/main/java/com/netgrif/application/engine/workflow/domain/outcome/CreateTasksOutcome.java @@ -0,0 +1,14 @@ +package com.netgrif.application.engine.workflow.domain.outcome; + +import com.netgrif.application.engine.workflow.domain.Task; +import lombok.AllArgsConstructor; +import lombok.Data; + +import java.util.List; + +@Data +@AllArgsConstructor +public class CreateTasksOutcome { + private List<Task> tasks; + private Task autoTriggerTask; +} diff --git a/src/main/java/com/netgrif/application/engine/workflow/domain/params/CreateCaseParams.java b/src/main/java/com/netgrif/application/engine/workflow/domain/params/CreateCaseParams.java new file mode 100644 index 00000000000..cbd3c5c7c67 --- /dev/null +++ b/src/main/java/com/netgrif/application/engine/workflow/domain/params/CreateCaseParams.java @@ -0,0 +1,63 @@ +package com.netgrif.application.engine.workflow.domain.params; + +import com.netgrif.application.engine.auth.domain.LoggedUser; +import com.netgrif.application.engine.petrinet.domain.PetriNet; +import com.netgrif.application.engine.workflow.domain.Case; +import lombok.Builder; +import lombok.Data; +import org.springframework.context.i18n.LocaleContextHolder; + +import java.util.HashMap; +import java.util.Locale; +import java.util.Map; +import java.util.function.Function; + +/** + * todo javadoc + * */ +@Data +@Builder +public class CreateCaseParams { + + private String petriNetId; + private String petriNetIdentifier; + private PetriNet petriNet; + private String title; + private Function<Case, String> makeTitle; + private String color; + private LoggedUser loggedUser; + @Builder.Default + private Locale locale = LocaleContextHolder.getLocale(); + @Builder.Default + private Map<String, String> params = new HashMap<>(); + + /** + * todo javadoc + * Builder extension of the {@link Builder} implementation for {@link }. Containing additional logic over the native builder + * implementation + * */ + public static class CreateCaseParamsBuilder { + /** + * todo javadoc + * */ + public CreateCaseParams.CreateCaseParamsBuilder title(String title) { + this.title = title; + if (title != null) { + this.makeTitle = (u) -> title; + } else { + this.makeTitle = null; + } + return this; + } + + /** + * todo javadoc + * */ + public CreateCaseParams.CreateCaseParamsBuilder petriNet(PetriNet petriNet) { + this.petriNet = petriNet.clone(); + this.petriNetIdentifier = petriNet.getIdentifier(); + this.petriNetId = petriNet.getStringId(); + return this; + } + } +} diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/FilterImportExportService.java b/src/main/java/com/netgrif/application/engine/workflow/service/FilterImportExportService.java index c57344f216f..ed8a0ab9b5a 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/FilterImportExportService.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/FilterImportExportService.java @@ -18,6 +18,7 @@ import com.netgrif.application.engine.workflow.domain.*; import com.netgrif.application.engine.workflow.domain.filter.FilterImportExport; import com.netgrif.application.engine.workflow.domain.filter.FilterImportExportList; +import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams; import com.netgrif.application.engine.workflow.service.interfaces.IDataService; import com.netgrif.application.engine.workflow.service.interfaces.IFilterImportExportService; import com.netgrif.application.engine.workflow.service.interfaces.ITaskService; @@ -86,12 +87,24 @@ public class FilterImportExportService implements IFilterImportExportService { @Override public void createFilterImport(IUser author) { - workflowService.createCaseByIdentifier(IMPORT_NET_IDENTIFIER, "Import filters " + author.getFullName(), "", author.transformToLoggedUser()); + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNetIdentifier(IMPORT_NET_IDENTIFIER) + .title("Import filters " + author.getFullName()) + .color("") + .loggedUser(author.transformToLoggedUser()) + .build(); + workflowService.createCase(createCaseParams); } @Override public void createFilterExport(IUser author) { - workflowService.createCaseByIdentifier(EXPORT_NET_IDENTIFIER, "Export filters " + author.getFullName(), "", author.transformToLoggedUser()); + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNetIdentifier(EXPORT_NET_IDENTIFIER) + .title("Export filters " + author.getFullName()) + .color("") + .loggedUser(author.transformToLoggedUser()) + .build(); + workflowService.createCase(createCaseParams); } /** diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/MenuImportExportService.java b/src/main/java/com/netgrif/application/engine/workflow/service/MenuImportExportService.java index f40c05a0397..9a236c18996 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/MenuImportExportService.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/MenuImportExportService.java @@ -19,6 +19,7 @@ import com.netgrif.application.engine.workflow.domain.menu.MenuAndFilters; import com.netgrif.application.engine.workflow.domain.menu.MenuEntry; import com.netgrif.application.engine.workflow.domain.menu.MenuEntryRole; +import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams; import com.netgrif.application.engine.workflow.service.interfaces.*; import com.netgrif.application.engine.workflow.web.responsebodies.DataSet; import lombok.extern.slf4j.Slf4j; @@ -246,12 +247,13 @@ public String createMenuItemCase(StringBuilder resultMessage, MenuEntry item, St }); } //Creating new Case of preference_filter_item net and setting its data... - Case menuItemCase = workflowService.createCase( - petriNetService.getNewestVersionByIdentifier("preference_filter_item").getStringId(), - item.getEntryName() + "_" + menuIdentifier, - "", - userService.getSystem().transformToLoggedUser() - ).getCase(); + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(petriNetService.getNewestVersionByIdentifier("preference_filter_item")) + .title(item.getEntryName() + "_" + menuIdentifier) + .color("") + .loggedUser(userService.getSystem().transformToLoggedUser()) + .build(); + Case menuItemCase = workflowService.createCase(createCaseParams).getCase(); QTask qTask = new QTask("task"); Task task = taskService.searchOne(qTask.transitionId.eq("init").and(qTask.caseId.eq(menuItemCase.getStringId()))); diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/TaskService.java b/src/main/java/com/netgrif/application/engine/workflow/service/TaskService.java index 655ae192e89..97ac8606552 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/TaskService.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/TaskService.java @@ -30,13 +30,11 @@ import com.netgrif.application.engine.utils.DateUtils; import com.netgrif.application.engine.utils.FullPageRequest; import com.netgrif.application.engine.validation.service.interfaces.IValidationService; -import com.netgrif.application.engine.workflow.domain.Case; -import com.netgrif.application.engine.workflow.domain.State; -import com.netgrif.application.engine.workflow.domain.Task; -import com.netgrif.application.engine.workflow.domain.TaskNotFoundException; +import com.netgrif.application.engine.workflow.domain.*; import com.netgrif.application.engine.workflow.domain.eventoutcomes.EventOutcome; import com.netgrif.application.engine.workflow.domain.eventoutcomes.dataoutcomes.SetDataEventOutcome; import com.netgrif.application.engine.workflow.domain.eventoutcomes.taskoutcomes.*; +import com.netgrif.application.engine.workflow.domain.outcome.CreateTasksOutcome; import com.netgrif.application.engine.workflow.domain.repositories.TaskRepository; import com.netgrif.application.engine.workflow.domain.triggers.AutoTrigger; import com.netgrif.application.engine.workflow.domain.triggers.TimeTrigger; @@ -111,6 +109,26 @@ public class TaskService implements ITaskService { @Autowired private IRuleEngine ruleEngine; + /** + * todo javadoc + * */ + @Override + public List<EventOutcome> executeTask(Task task, Case useCase) { + log.info("[{}]: executeTask [{}] in case [{}]", useCase.getStringId(), task.getTransitionId(), useCase.getTitle()); + List<EventOutcome> outcomes = new ArrayList<>(); + try { + log.info("assignTask [{}] in case [{}]", task.getTitle(), useCase.getTitle()); + outcomes.add(assignTask(task.getStringId())); + log.info("getData [{}] in case [{}]", task.getTitle(), useCase.getTitle()); + outcomes.add(dataService.getData(task.getStringId(), userService.getSystem())); + log.info("finishTask [{}] in case [{}]", task.getTitle(), useCase.getTitle()); + outcomes.add(finishTask(task.getStringId())); + } catch (TransitionNotExecutableException e) { + log.error("execution of task [{}] in case [{}] failed: ", task.getTitle(), useCase.getTitle(), e); + } + return outcomes; + } + @Override public List<AssignTaskEventOutcome> assignTasks(List<Task> tasks, IUser user) throws TransitionNotExecutableException { return assignTasks(tasks, user, new HashMap<>()); @@ -431,6 +449,7 @@ protected Case evaluateRules(String caseId, Task task, EventType eventType, Even } /** + * todo javadoc * Reloads all unassigned tasks of given case: * <table border="1"> * <tr> @@ -444,40 +463,125 @@ protected Case evaluateRules(String caseId, Task task, EventType eventType, Even * </tr> * </table> */ - @SuppressWarnings("StatementWithEmptyBody") @Override public void reloadTasks(Case useCase) { log.info("[{}]: Reloading tasks in [{}]", useCase.getStringId(), useCase.getTitle()); - PetriNet net = useCase.getPetriNet(); - List<Task> tasks; - // create tasks on first reload (create case) - if (useCase.getTasks().isEmpty()) { - tasks = net.getTransitions().values().stream() - .map(transition -> createFromTransition(transition, useCase)) - .collect(Collectors.toList()); - } else { - tasks = taskRepository.findAllByCaseId(useCase.getStringId()); - } - // update tasks state + List<String> taskIds = useCase.getTasks().values().stream() + .map(taskPair -> taskPair.getTaskId().toString()) + .collect(Collectors.toList()); + + Optional<Task> autoTriggerTaskOpt = reloadAndSaveTasks((List<Task>) taskRepository.findAllById(taskIds), useCase); + + autoTriggerTaskOpt.ifPresent(task -> executeTask(task, workflowService.findOne(useCase.getStringId()))); + } + + /** + * todo javadoc + * */ + private Optional<Task> reloadAndSaveTasks(List<Task> tasks, Case useCase) { Task autoTriggered = null; + PetriNet net = useCase.getPetriNet(); for (Task task : tasks) { Transition transition = net.getTransition(task.getTransitionId()); - if (isExecutable(transition, net)) { - task.setState(State.ENABLED); - if (task.isAutoTriggered()) { - autoTriggered = task; - } - } else { - task.setState(State.DISABLED); + if (updateStateOfTask(task, transition, net)) { + autoTriggered = task; + } + } + save(tasks); + + return autoTriggered == null ? Optional.empty() : Optional.of(autoTriggered); + } + + /** + * todo javadoc + * */ + @Override + public CreateTasksOutcome createAndSetTasksInCase(Case useCase) { + List<Task> tasks = useCase.getPetriNet().getTransitions().values().stream() + .map(transition -> createTaskFromTransition(transition, useCase)) + .collect(Collectors.toList()); + + useCase.addTasks(tasks); + + Optional<Task> autoTriggerTaskOpt = reloadAndSaveTasks(tasks, useCase); + + return new CreateTasksOutcome(tasks, autoTriggerTaskOpt.orElse(null)); + } + + /** + * todo javadoc + * */ + private Task createTaskFromTransition(Transition transition, Case useCase) { + final Task task = Task.with() + .title(transition.getTitle()) + .processId(useCase.getPetriNetId()) + .caseId(useCase.getId().toString()) + .transitionId(transition.getImportId()) + .layout(transition.getLayout()) + .tags(transition.getTags()) + .caseColor(useCase.getColor()) + .caseTitle(useCase.getTitle()) + .priority(transition.getPriority()) + .icon(transition.getIcon() == null ? useCase.getIcon() : transition.getIcon()) + .immediateDataFields(transition.getImmediateData()) + .assignPolicy(transition.getAssignPolicy()) + .dataFocusPolicy(transition.getDataFocusPolicy()) + .finishPolicy(transition.getFinishPolicy()) + .build(); + transition.getEvents().forEach((type, event) -> task.addEventTitle(type, event.getTitle())); + task.addAssignedUserPolicy(transition.getAssignedUserPolicy()); + for (Trigger trigger : transition.getTriggers()) { + Trigger taskTrigger = trigger.clone(); + task.addTrigger(taskTrigger); + + if (taskTrigger instanceof TimeTrigger) { + TimeTrigger timeTrigger = (TimeTrigger) taskTrigger; + scheduleTaskExecution(task, timeTrigger.getStartDate(), useCase); + } else if (taskTrigger instanceof AutoTrigger) { + task.setUserId(userService.getSystem().getStringId()); } - save(task); } - if (autoTriggered != null) { - executeTransition(autoTriggered, workflowService.findOne(useCase.getStringId())); + ProcessRole defaultRole = processRoleService.defaultRole(); + ProcessRole anonymousRole = processRoleService.anonymousRole(); + for (Map.Entry<String, Map<RolePermission, Boolean>> entry : transition.getRoles().entrySet()) { + if (useCase.getEnabledRoles().contains(entry.getKey()) + || defaultRole.getStringId().equals(entry.getKey()) + || anonymousRole.getStringId().equals(entry.getKey())) { + task.addRole(entry.getKey(), entry.getValue()); + } + } + transition.getNegativeViewRoles().forEach(task::addNegativeViewRole); + + for (Map.Entry<String, Map<RolePermission, Boolean>> entry : transition.getUserRefs().entrySet()) { + task.addUserRef(entry.getKey(), entry.getValue()); } + task.resolveViewRoles(); + task.resolveViewUserRefs(); + + Transaction transaction = useCase.getPetriNet().getTransactionByTransition(transition); + if (transaction != null) { + task.setTransactionId(transaction.getStringId()); + } + + return task; } - boolean isExecutable(Transition transition, PetriNet net) { + + /** + * todo javadoc + * returns true if it is autotrigger + * */ + private boolean updateStateOfTask(Task task, Transition transition, PetriNet net) { + if (isExecutable(transition, net)) { + task.setState(State.ENABLED); + return task.isAutoTriggered(); + } else { + task.setState(State.DISABLED); + return false; + } + } + + private boolean isExecutable(Transition transition, PetriNet net) { Collection<Arc> arcsOfTransition = net.getArcsOfTransition(transition); if (arcsOfTransition == null) { @@ -489,7 +593,7 @@ boolean isExecutable(Transition transition, PetriNet net) { .allMatch(Arc::isExecutable); } - void finishExecution(Transition transition, String useCaseId) throws TransitionNotExecutableException { + private void finishExecution(Transition transition, String useCaseId) throws TransitionNotExecutableException { Case useCase = workflowService.findOne(useCaseId); log.info("[{}]: Finish execution of task [{}] in case [{}]", useCaseId, transition.getTitle(), useCase.getTitle()); execute(transition, useCase, arc -> arc.getSource().equals(transition)); @@ -498,7 +602,7 @@ void finishExecution(Transition transition, String useCaseId) throws TransitionN workflowService.save(useCase); } - public void startExecution(Transition transition, Case useCase) throws TransitionNotExecutableException { + private void startExecution(Transition transition, Case useCase) throws TransitionNotExecutableException { log.info("[{}]: Start execution of {} in case {}", useCase.getStringId(), transition.getTitle(), useCase.getTitle()); execute(transition, useCase, arc -> arc.getDestination().equals(transition)); } @@ -523,23 +627,7 @@ protected void execute(Transition transition, Case useCase, Predicate<Arc> predi workflowService.updateMarking(useCase); } - protected List<EventOutcome> executeTransition(Task task, Case useCase) { - log.info("[{}]: executeTransition [{}] in case [{}]", useCase.getStringId(), task.getTransitionId(), useCase.getTitle()); - List<EventOutcome> outcomes = new ArrayList<>(); - try { - log.info("assignTask [{}] in case [{}]", task.getTitle(), useCase.getTitle()); - outcomes.add(assignTask(task.getStringId())); - log.info("getData [{}] in case [{}]", task.getTitle(), useCase.getTitle()); - outcomes.add(dataService.getData(task.getStringId(), userService.getSystem())); - log.info("finishTask [{}] in case [{}]", task.getTitle(), useCase.getTitle()); - outcomes.add(finishTask(task.getStringId())); - } catch (TransitionNotExecutableException e) { - log.error("execution of task [{}] in case [{}] failed: ", task.getTitle(), useCase.getTitle(), e); - } - return outcomes; - } - - void validateData(Transition transition, Case useCase) { + private void validateData(Transition transition, Case useCase) { // TODO: release/8.0.0 fix validation // for (Map.Entry<String, DataFieldLogic> entry : transition.getDataSet().entrySet()) { // if (useCase.getPetriNet().getDataSet().get(entry.getKey()) != null @@ -563,11 +651,11 @@ void validateData(Transition transition, Case useCase) { // } } - protected void scheduleTaskExecution(Task task, LocalDateTime time, Case useCase) { + private void scheduleTaskExecution(Task task, LocalDateTime time, Case useCase) { log.info("[{}]: Task {} scheduled to run at {}", useCase.getStringId(), task.getTitle(), time.toString()); scheduler.schedule(() -> { try { - executeTransition(task, useCase); + executeTask(task, useCase); } catch (Exception e) { log.info("[{}]: Scheduled task [{}] of case [{}] could not be executed: {}", useCase.getStringId(), task.getTitle(), useCase.getTitle(), e.toString()); } @@ -755,67 +843,6 @@ private List<String> getExistingUsers(UserListFieldValue userListValue) { .collect(Collectors.toList()); } - private Task createFromTransition(Transition transition, Case useCase) { - final Task task = Task.with() - .title(transition.getTitle()) - .processId(useCase.getPetriNetId()) - .caseId(useCase.getId().toString()) - .transitionId(transition.getImportId()) - .layout(transition.getLayout()) - .tags(transition.getTags()) - .caseColor(useCase.getColor()) - .caseTitle(useCase.getTitle()) - .priority(transition.getPriority()) - .icon(transition.getIcon() == null ? useCase.getIcon() : transition.getIcon()) - .immediateDataFields(transition.getImmediateData()) - .assignPolicy(transition.getAssignPolicy()) - .dataFocusPolicy(transition.getDataFocusPolicy()) - .finishPolicy(transition.getFinishPolicy()) - .build(); - transition.getEvents().forEach((type, event) -> task.addEventTitle(type, event.getTitle())); - task.addAssignedUserPolicy(transition.getAssignedUserPolicy()); - for (Trigger trigger : transition.getTriggers()) { - Trigger taskTrigger = trigger.clone(); - task.addTrigger(taskTrigger); - - if (taskTrigger instanceof TimeTrigger) { - TimeTrigger timeTrigger = (TimeTrigger) taskTrigger; - scheduleTaskExecution(task, timeTrigger.getStartDate(), useCase); - } else if (taskTrigger instanceof AutoTrigger) { - task.setUserId(userService.getSystem().getStringId()); - } - } - ProcessRole defaultRole = processRoleService.defaultRole(); - ProcessRole anonymousRole = processRoleService.anonymousRole(); - for (Map.Entry<String, Map<RolePermission, Boolean>> entry : transition.getRoles().entrySet()) { - if (useCase.getEnabledRoles().contains(entry.getKey()) - || defaultRole.getStringId().equals(entry.getKey()) - || anonymousRole.getStringId().equals(entry.getKey())) { - task.addRole(entry.getKey(), entry.getValue()); - } - } - transition.getNegativeViewRoles().forEach(task::addNegativeViewRole); - - for (Map.Entry<String, Map<RolePermission, Boolean>> entry : transition.getUserRefs().entrySet()) { - task.addUserRef(entry.getKey(), entry.getValue()); - } - task.resolveViewRoles(); - task.resolveViewUserRefs(); - - Transaction transaction = useCase.getPetriNet().getTransactionByTransition(transition); - if (transaction != null) { - task.setTransactionId(transaction.getStringId()); - } - - Task savedTask = save(task); - - useCase.addTask(savedTask); - // TODO: release/8.0.0 remove? - workflowService.resolveUserRef(useCase); - - return savedTask; - } - private Page<Task> loadUsers(Page<Task> tasks) { Map<String, IUser> users = new HashMap<>(); tasks.forEach(task -> { diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/WorkflowService.java b/src/main/java/com/netgrif/application/engine/workflow/service/WorkflowService.java index 14ed162355b..2f1a8b437fd 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/WorkflowService.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/WorkflowService.java @@ -28,19 +28,20 @@ import com.netgrif.application.engine.workflow.domain.eventoutcomes.EventOutcome; import com.netgrif.application.engine.workflow.domain.eventoutcomes.caseoutcomes.CreateCaseEventOutcome; import com.netgrif.application.engine.workflow.domain.eventoutcomes.caseoutcomes.DeleteCaseEventOutcome; +import com.netgrif.application.engine.workflow.domain.outcome.CreateTasksOutcome; import com.netgrif.application.engine.workflow.domain.repositories.CaseRepository; import com.netgrif.application.engine.workflow.service.initializer.DataSetInitializer; import com.netgrif.application.engine.workflow.service.interfaces.IEventService; import com.netgrif.application.engine.workflow.service.interfaces.IInitValueExpressionEvaluator; import com.netgrif.application.engine.workflow.service.interfaces.ITaskService; import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowService; +import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams; import com.querydsl.core.types.Predicate; import lombok.extern.slf4j.Slf4j; import org.bson.types.ObjectId; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.ApplicationEventPublisher; import org.springframework.context.annotation.Lazy; -import org.springframework.context.i18n.LocaleContextHolder; import org.springframework.data.domain.Page; import org.springframework.data.domain.PageImpl; import org.springframework.data.domain.PageRequest; @@ -49,6 +50,7 @@ import org.springframework.data.mongodb.core.query.BasicQuery; import org.springframework.data.util.Pair; import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; import java.time.LocalDateTime; import java.util.*; @@ -134,11 +136,7 @@ public Case findOne(String caseId) { @Override public Case findOneNoNet(String caseId) { Optional<Case> caseOptional = repository.findById(caseId); - if (caseOptional.isEmpty()) { - throw new IllegalArgumentException("Could not find Case with id [" + caseId + "]"); - } - // TODO: release/8.0.0 get or throw? - return caseOptional.get(); + return caseOptional.orElseThrow(() -> new IllegalArgumentException("Could not find Case with id [" + caseId + "]")); } protected void initialize(Case useCase) { @@ -215,117 +213,108 @@ private List<String> getExistingUsers(UserListFieldValue userListValue) { .collect(Collectors.toList()); } + /** + * todo javadoc + * */ @Override - public CreateCaseEventOutcome createCase(String netId, String title, String color, LoggedUser user, Locale locale, Map<String, String> params) { - if (locale == null) { - locale = LocaleContextHolder.getLocale(); - } - if (title == null) { - return this.createCase(netId, resolveDefaultCaseTitle(netId, locale, params), color, user, params); - } - return this.createCase(netId, title, color, user, params); - } + @Transactional + public CreateCaseEventOutcome createCase(CreateCaseParams createCaseParams) { + fillMissingAttributes(createCaseParams); - @Override - public CreateCaseEventOutcome createCase(String netId, String title, String color, LoggedUser user, Locale locale) { - return this.createCase(netId, title, color, user, locale, new HashMap<>()); - } + Case useCase = createCaseObject(createCaseParams); + CreateTasksOutcome createTasksOutcome = taskService.createAndSetTasksInCase(useCase); + save(useCase); // must be after tasks creation for effectivity reasons - @Override - public CreateCaseEventOutcome createCase(String netId, String title, String color, LoggedUser user, Map<String, String> params) { - return createCase(netId, (u) -> title, color, user, params); - } + PetriNet petriNet = createCaseParams.getPetriNet(); + CreateCaseEventOutcome outcome = new CreateCaseEventOutcome(); - @Override - public CreateCaseEventOutcome createCase(String netId, String title, String color, LoggedUser user) { - return this.createCase(netId, (u) -> title, color, user); - } + outcome.addOutcomes(eventService.runActions(petriNet.getPreCreateActions(), null, Optional.empty(), + createCaseParams.getParams())); - @Override - public CreateCaseEventOutcome createCaseByIdentifier(String identifier, String title, String color, LoggedUser user, Locale locale, Map<String, String> params) { - PetriNet net = petriNetService.getNewestVersionByIdentifier(identifier); - if (net == null) { - throw new IllegalArgumentException("Petri net with identifier [" + identifier + "] does not exist."); + int rulesExecuted = ruleEngine.evaluateRules(useCase, new CaseCreatedFact(useCase.getStringId(), EventPhase.PRE)); + if (rulesExecuted > 0) { + useCase = save(useCase); } - return this.createCase(net.getStringId(), title != null && !title.equals("") ? title : net.getDefaultCaseName().getTranslation(locale), color, user, params); - } - @Override - public CreateCaseEventOutcome createCaseByIdentifier(String identifier, String title, String color, LoggedUser user, Locale locale) { - return this.createCaseByIdentifier(identifier, title, color, user, locale, new HashMap<>()); - } - - @Override - public CreateCaseEventOutcome createCaseByIdentifier(String identifier, String title, String color, LoggedUser user, Map<String, String> params) { - PetriNet net = petriNetService.getNewestVersionByIdentifier(identifier); - if (net == null) { - throw new IllegalArgumentException("Petri net with identifier [" + identifier + "] does not exist."); - } - return this.createCase(net.getStringId(), title, color, user, params); - } + historyService.save(new CreateCaseEventLog(useCase, EventPhase.PRE)); - @Override - public CreateCaseEventOutcome createCaseByIdentifier(String identifier, String title, String color, LoggedUser user) { - PetriNet net = petriNetService.getNewestVersionByIdentifier(identifier); - if (net == null) { - throw new IllegalArgumentException("Petri net with identifier [" + identifier + "] does not exist."); + if (createTasksOutcome.getAutoTriggerTask() != null) { + taskService.executeTask(createTasksOutcome.getAutoTriggerTask(), useCase); + useCase = findOne(useCase.getStringId()); } - return this.createCase(net.getStringId(), title, color, user); - } - public CreateCaseEventOutcome createCase(String netId, Function<Case, String> makeTitle, String color, LoggedUser user) { - return this.createCase(netId, makeTitle, color, user, new HashMap<>()); - } + // TODO release/8.0.0 resolving init of taskRefs is going to be done differently + // resolveTaskRefs(useCase); - public CreateCaseEventOutcome createCase(String netId, Function<Case, String> makeTitle, String color, LoggedUser user, Map<String, String> params) { - LoggedUser loggedOrImpersonated = user.getSelfOrImpersonated(); - PetriNet petriNet = petriNetService.clone(new ObjectId(netId)); - int rulesExecuted; - Case useCase = new Case(petriNet); - dataSetInitializer.populateDataSet(useCase, params); - useCase.setColor(color); - useCase.setAuthor(loggedOrImpersonated.transformToAuthor()); - useCase.setCreationDate(LocalDateTime.now()); - useCase.setTitle(makeTitle.apply(useCase)); - // TODO: release/7.0.0 6.2.5 - // TODO: release/8.0.0 useCase.setUriNodeId(petriNet.getUriNodeId()); -// UriNode uriNode = uriService.getOrCreate(petriNet, UriContentType.CASE); -// useCase.setUriNodeId(uriNode.getId()); - - CreateCaseEventOutcome outcome = new CreateCaseEventOutcome(); - outcome.addOutcomes(eventService.runActions(petriNet.getPreCreateActions(), null, Optional.empty(), params)); - rulesExecuted = ruleEngine.evaluateRules(useCase, new CaseCreatedFact(useCase.getStringId(), EventPhase.PRE)); - if (rulesExecuted > 0) { - useCase = save(useCase); + List<EventOutcome> eventPostOutcomes = eventService.runActions(petriNet.getPostCreateActions(), useCase, Optional.empty(), + createCaseParams.getParams()); + if (!eventPostOutcomes.isEmpty()) { + outcome.addOutcomes(eventPostOutcomes); + useCase = findOne(useCase.getStringId()); } - historyService.save(new CreateCaseEventLog(useCase, EventPhase.PRE)); - log.info("[{}]: Case {} created", useCase.getStringId(), useCase.getTitle()); - - useCase.getPetriNet().initializeArcs(useCase.getDataSet()); - taskService.reloadTasks(useCase); - useCase = findOne(useCase.getStringId()); - resolveTaskRefs(useCase); - - useCase = findOne(useCase.getStringId()); - outcome.addOutcomes(eventService.runActions(petriNet.getPostCreateActions(), useCase, Optional.empty(), params)); - useCase = findOne(useCase.getStringId()); rulesExecuted = ruleEngine.evaluateRules(useCase, new CaseCreatedFact(useCase.getStringId(), EventPhase.POST)); if (rulesExecuted > 0) { useCase = save(useCase); } historyService.save(new CreateCaseEventLog(useCase, EventPhase.POST)); + + log.info("[{}]: Case {} created", useCase.getStringId(), useCase.getTitle()); + outcome.setCase(useCase); addMessageToOutcome(petriNet, CaseEventType.CREATE, outcome); return outcome; } - protected Function<Case, String> resolveDefaultCaseTitle(String netId, Locale locale, Map<String, String> params) { - PetriNet petriNet = petriNetService.clone(new ObjectId(netId)); + /** + * todo javadoc + * */ + private Case createCaseObject(CreateCaseParams createCaseParams) { + LoggedUser loggedOrImpersonated = createCaseParams.getLoggedUser().getSelfOrImpersonated(); + + Case useCase = new Case(createCaseParams.getPetriNet()); + dataSetInitializer.populateDataSet(useCase, createCaseParams.getParams()); + useCase.setColor(createCaseParams.getColor()); + useCase.setAuthor(loggedOrImpersonated.transformToAuthor()); + useCase.setCreationDate(LocalDateTime.now()); + useCase.setTitle(createCaseParams.getMakeTitle().apply(useCase)); + useCase.setUriNodeId(createCaseParams.getPetriNet().getUriNodeId()); + + useCase.getPetriNet().initializeArcs(useCase.getDataSet()); + + return useCase; + } + + /** + * todo javadoc + * makeTitle, petriNet + * */ + private void fillMissingAttributes(CreateCaseParams createCaseParams) throws IllegalArgumentException { + if (createCaseParams.getLoggedUser() == null) { + throw new IllegalArgumentException("Logged user cannot be null on Case creation."); + } + if (createCaseParams.getMakeTitle() == null && createCaseParams.getPetriNetId() != null) { + createCaseParams.setMakeTitle(resolveDefaultCaseTitle(createCaseParams)); + } + if (createCaseParams.getPetriNet() == null) { + PetriNet petriNet = null; + if (createCaseParams.getPetriNetId() != null) { + petriNet = petriNetService.get(new ObjectId(createCaseParams.getPetriNetId())).clone(); + } else if (createCaseParams.getPetriNetIdentifier() != null) { + petriNet = petriNetService.getNewestVersionByIdentifier(createCaseParams.getPetriNetIdentifier()).clone(); + } + createCaseParams.setPetriNet(petriNet); + } + } + + private Function<Case, String> resolveDefaultCaseTitle(CreateCaseParams createCaseParams) { + Locale locale = createCaseParams.getLocale(); + PetriNet petriNet = petriNetService.clone(new ObjectId(createCaseParams.getPetriNetId())); Function<Case, String> makeTitle; if (petriNet.hasDynamicCaseName()) { - makeTitle = (u) -> initValueExpressionEvaluator.evaluateCaseName(u, petriNet.getDefaultCaseNameExpression(), params).getTranslation(locale); + makeTitle = (u) -> initValueExpressionEvaluator.evaluateCaseName(u, petriNet.getDefaultCaseNameExpression(), + createCaseParams.getParams()).getTranslation(locale); } else { makeTitle = (u) -> petriNet.getDefaultCaseName().getTranslation(locale); } diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/interfaces/IDataService.java b/src/main/java/com/netgrif/application/engine/workflow/service/interfaces/IDataService.java index 30ff05446da..cee726046fb 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/interfaces/IDataService.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/interfaces/IDataService.java @@ -2,21 +2,17 @@ import com.netgrif.application.engine.auth.domain.IUser; import com.netgrif.application.engine.auth.domain.LoggedUser; -import com.fasterxml.jackson.databind.node.ObjectNode; -import com.netgrif.application.engine.petrinet.domain.Component; import com.netgrif.application.engine.petrinet.domain.dataset.Field; import com.netgrif.application.engine.petrinet.domain.dataset.FileField; import com.netgrif.application.engine.petrinet.domain.dataset.FileListField; import com.netgrif.application.engine.petrinet.domain.dataset.UserFieldValue; import com.netgrif.application.engine.workflow.domain.Case; -import com.netgrif.application.engine.workflow.domain.QTask; import com.netgrif.application.engine.workflow.domain.Task; import com.netgrif.application.engine.workflow.domain.eventoutcomes.dataoutcomes.GetDataEventOutcome; import com.netgrif.application.engine.workflow.domain.eventoutcomes.dataoutcomes.GetDataGroupsEventOutcome; import com.netgrif.application.engine.workflow.domain.eventoutcomes.dataoutcomes.SetDataEventOutcome; import com.netgrif.application.engine.workflow.service.FileFieldInputStream; import com.netgrif.application.engine.workflow.web.responsebodies.DataSet; -import com.querydsl.core.types.Predicate; import org.springframework.data.domain.Page; import org.springframework.web.multipart.MultipartFile; diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/interfaces/ITaskService.java b/src/main/java/com/netgrif/application/engine/workflow/service/interfaces/ITaskService.java index 31fd7c66c95..135c3a6c3e3 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/interfaces/ITaskService.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/interfaces/ITaskService.java @@ -6,27 +6,29 @@ import com.netgrif.application.engine.workflow.domain.Case; import com.netgrif.application.engine.workflow.domain.Task; import com.netgrif.application.engine.workflow.domain.TaskNotFoundException; +import com.netgrif.application.engine.workflow.domain.eventoutcomes.EventOutcome; import com.netgrif.application.engine.workflow.domain.eventoutcomes.dataoutcomes.SetDataEventOutcome; import com.netgrif.application.engine.workflow.domain.eventoutcomes.taskoutcomes.AssignTaskEventOutcome; import com.netgrif.application.engine.workflow.domain.eventoutcomes.taskoutcomes.CancelTaskEventOutcome; import com.netgrif.application.engine.workflow.domain.eventoutcomes.taskoutcomes.DelegateTaskEventOutcome; import com.netgrif.application.engine.workflow.domain.eventoutcomes.taskoutcomes.FinishTaskEventOutcome; +import com.netgrif.application.engine.workflow.domain.outcome.CreateTasksOutcome; import com.netgrif.application.engine.workflow.web.requestbodies.TaskSearchRequest; import com.netgrif.application.engine.workflow.web.responsebodies.TaskReference; import org.springframework.data.domain.Page; import org.springframework.data.domain.Pageable; -import org.springframework.transaction.annotation.Transactional; import java.util.List; import java.util.Locale; import java.util.Map; -import java.util.Set; // TODO: release/8.0.0 remove LoggedUser, create TaskEventContext class to merge all params public interface ITaskService { void reloadTasks(Case useCase); + CreateTasksOutcome createAndSetTasksInCase(Case useCase); + Task findOne(String taskId); Page<Task> getAll(LoggedUser loggedUser, Pageable pageable, Locale locale); @@ -51,6 +53,8 @@ public interface ITaskService { Task searchOne(com.querydsl.core.types.Predicate predicate); + List<EventOutcome> executeTask(Task task, Case useCase); + List<FinishTaskEventOutcome> finishTasks(List<Task> tasks, IUser user) throws TransitionNotExecutableException; List<FinishTaskEventOutcome> finishTasks(List<Task> tasks, IUser user, Map<String, String> params) throws TransitionNotExecutableException; diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/interfaces/IWorkflowService.java b/src/main/java/com/netgrif/application/engine/workflow/service/interfaces/IWorkflowService.java index 875fe09f89f..44de825f231 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/interfaces/IWorkflowService.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/interfaces/IWorkflowService.java @@ -1,19 +1,17 @@ package com.netgrif.application.engine.workflow.service.interfaces; -import com.netgrif.application.engine.auth.domain.LoggedUser; import com.netgrif.application.engine.petrinet.domain.I18nString; import com.netgrif.application.engine.petrinet.domain.PetriNet; -import com.netgrif.application.engine.petrinet.domain.dataset.Field; import com.netgrif.application.engine.workflow.domain.Case; import com.netgrif.application.engine.workflow.domain.Task; import com.netgrif.application.engine.workflow.domain.eventoutcomes.caseoutcomes.CreateCaseEventOutcome; import com.netgrif.application.engine.workflow.domain.eventoutcomes.caseoutcomes.DeleteCaseEventOutcome; +import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams; import com.querydsl.core.types.Predicate; import org.springframework.data.domain.Page; import org.springframework.data.domain.Pageable; import java.util.List; -import java.util.Locale; import java.util.Map; public interface IWorkflowService { @@ -30,21 +28,7 @@ public interface IWorkflowService { Case resolveUserRef(Case useCase); - CreateCaseEventOutcome createCase(String netId, String title, String color, LoggedUser user, Locale locale, Map<String, String> params); - - CreateCaseEventOutcome createCase(String netId, String title, String color, LoggedUser user, Locale locale); - - CreateCaseEventOutcome createCase(String netId, String title, String color, LoggedUser user, Map<String, String> params); - - CreateCaseEventOutcome createCase(String netId, String title, String color, LoggedUser user); - - CreateCaseEventOutcome createCaseByIdentifier(String identifier, String title, String color, LoggedUser user, Map<String, String> params); - - CreateCaseEventOutcome createCaseByIdentifier(String identifier, String title, String color, LoggedUser user); - - CreateCaseEventOutcome createCaseByIdentifier(String identifier, String title, String color, LoggedUser user, Locale locale, Map<String, String> params); - - CreateCaseEventOutcome createCaseByIdentifier(String identifier, String title, String color, LoggedUser user, Locale locale); + CreateCaseEventOutcome createCase(CreateCaseParams createCaseParams); Page<Case> findAllByAuthor(String authorId, String petriNet, Pageable pageable); diff --git a/src/main/java/com/netgrif/application/engine/workflow/web/PublicWorkflowController.java b/src/main/java/com/netgrif/application/engine/workflow/web/PublicWorkflowController.java index 801ca6f5cd7..bc60019e7a2 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/web/PublicWorkflowController.java +++ b/src/main/java/com/netgrif/application/engine/workflow/web/PublicWorkflowController.java @@ -5,6 +5,7 @@ import com.netgrif.application.engine.workflow.domain.eventoutcomes.caseoutcomes.CreateCaseEventOutcome; import com.netgrif.application.engine.workflow.domain.eventoutcomes.response.EventOutcomeWithMessage; import com.netgrif.application.engine.workflow.domain.eventoutcomes.response.EventOutcomeWithMessageResource; +import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams; import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowService; import com.netgrif.application.engine.workflow.web.requestbodies.CreateCaseBody; import io.swagger.v3.oas.annotations.Operation; @@ -47,7 +48,14 @@ public PublicWorkflowController(IWorkflowService workflowService, IUserService u public EntityModel<EventOutcomeWithMessage> createCase(@RequestBody CreateCaseBody body, Locale locale) { LoggedUser loggedUser = userService.getAnonymousLogged(); try { - CreateCaseEventOutcome outcome = this.workflowService.createCase(body.netId, body.title, body.color, loggedUser, locale); + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNetId(body.netId) + .title(body.title) + .color(body.color) + .loggedUser(loggedUser) + .locale(locale) + .build(); + CreateCaseEventOutcome outcome = this.workflowService.createCase(createCaseParams); return EventOutcomeWithMessageResource.successMessage("Case created successfully", outcome); } catch (Exception e) { log.error("Creating case failed:" + e.getMessage(), e); diff --git a/src/main/java/com/netgrif/application/engine/workflow/web/WorkflowController.java b/src/main/java/com/netgrif/application/engine/workflow/web/WorkflowController.java index 628fa7e3fa9..687fab75369 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/web/WorkflowController.java +++ b/src/main/java/com/netgrif/application/engine/workflow/web/WorkflowController.java @@ -10,6 +10,7 @@ import com.netgrif.application.engine.workflow.domain.eventoutcomes.caseoutcomes.DeleteCaseEventOutcome; import com.netgrif.application.engine.workflow.domain.eventoutcomes.response.EventOutcomeWithMessage; import com.netgrif.application.engine.workflow.domain.eventoutcomes.response.EventOutcomeWithMessageResource; +import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams; import com.netgrif.application.engine.workflow.service.FileFieldInputStream; import com.netgrif.application.engine.workflow.service.interfaces.IDataService; import com.netgrif.application.engine.workflow.service.interfaces.ITaskService; @@ -76,7 +77,14 @@ public WorkflowController(IWorkflowService workflowService, ITaskService taskSer public EntityModel<EventOutcomeWithMessage> createCase(@RequestBody CreateCaseBody body, Authentication auth, Locale locale) { LoggedUser loggedUser = (LoggedUser) auth.getPrincipal(); try { - CreateCaseEventOutcome outcome = workflowService.createCase(body.netId, body.title, body.color, loggedUser, locale); + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNetId(body.netId) + .title(body.title) + .color(body.color) + .loggedUser(loggedUser) + .locale(locale) + .build(); + CreateCaseEventOutcome outcome = workflowService.createCase(createCaseParams); return EventOutcomeWithMessageResource.successMessage("Case with id " + outcome.getCase().getStringId() + " was created succesfully", outcome); } catch (Exception e) { // TODO: 5. 2. 2017 change to custom exception log.error("Creating case failed:", e); diff --git a/src/test/groovy/com/netgrif/application/engine/action/AssignRemoveTest.groovy b/src/test/groovy/com/netgrif/application/engine/action/AssignRemoveTest.groovy index b5ed186ce48..800ec81addf 100644 --- a/src/test/groovy/com/netgrif/application/engine/action/AssignRemoveTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/action/AssignRemoveTest.groovy @@ -9,6 +9,7 @@ import com.netgrif.application.engine.startup.ImportHelper import com.netgrif.application.engine.startup.SuperCreator import com.netgrif.application.engine.workflow.domain.Case import com.netgrif.application.engine.workflow.domain.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome +import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams import com.netgrif.application.engine.workflow.domain.repositories.CaseRepository import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowService import groovy.transform.CompileStatic @@ -72,7 +73,13 @@ class AssignRemoveTest { def roleCount = userService.system.processRoles.size() // create - Case caze = workflowService.createCase(net.stringId, 'TEST', '', userService.getLoggedOrSystem().transformToLoggedUser()).getCase() + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(net) + .title("TEST") + .color("") + .loggedUser(userService.getLoggedOrSystem().transformToLoggedUser()) + .build() + Case caze = workflowService.createCase(createCaseParams).getCase() assert userService.system.processRoles.size() == roleCount + 4 // delete diff --git a/src/test/groovy/com/netgrif/application/engine/auth/TaskAuthorizationServiceTest.groovy b/src/test/groovy/com/netgrif/application/engine/auth/TaskAuthorizationServiceTest.groovy index 3c3c96aeb12..b8a4a7d85c8 100644 --- a/src/test/groovy/com/netgrif/application/engine/auth/TaskAuthorizationServiceTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/auth/TaskAuthorizationServiceTest.groovy @@ -6,7 +6,6 @@ import com.netgrif.application.engine.auth.domain.IUser import com.netgrif.application.engine.auth.domain.User import com.netgrif.application.engine.auth.domain.UserState import com.netgrif.application.engine.auth.service.interfaces.IUserService -import com.netgrif.application.engine.importer.service.AllDataConfiguration import com.netgrif.application.engine.importer.service.Importer import com.netgrif.application.engine.petrinet.domain.PetriNet import com.netgrif.application.engine.petrinet.domain.VersionType @@ -18,8 +17,8 @@ import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetServi import com.netgrif.application.engine.startup.ImportHelper import com.netgrif.application.engine.startup.SuperCreator import com.netgrif.application.engine.workflow.domain.Case -import com.netgrif.application.engine.workflow.domain.TaskPair import com.netgrif.application.engine.workflow.domain.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome +import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams import com.netgrif.application.engine.workflow.service.interfaces.IDataService import com.netgrif.application.engine.workflow.service.interfaces.ITaskAuthorizationService import com.netgrif.application.engine.workflow.service.interfaces.ITaskService @@ -276,7 +275,13 @@ class TaskAuthorizationServiceTest { void testCanAssign() { ProcessRole positiveRole = this.net.getRoles().values().find(v -> v.getImportId() == "assign_pos_role") userService.addRole(testUser, positiveRole.getStringId()) - Case case_ = workflowService.createCase(net.getStringId(), "Test assign", "", testUser.transformToLoggedUser()).getCase() + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(net) + .title("Test assign") + .color("") + .loggedUser(testUser.transformToLoggedUser()) + .build() + Case case_ = workflowService.createCase(createCaseParams).getCase() assert taskAuthorizationService.canCallAssign(testUser.transformToLoggedUser(), case_.getTaskStringId("1")) userService.removeRole(testUser, positiveRole.getStringId()) workflowService.deleteCase(case_.stringId) @@ -286,7 +291,13 @@ class TaskAuthorizationServiceTest { void testCanNotAssign() { ProcessRole negativeRole = this.net.getRoles().values().find(v -> v.getImportId() == "assign_neg_role") userService.addRole(testUser, negativeRole.getStringId()) - Case case_ = workflowService.createCase(net.getStringId(), "Test assign", "", testUser.transformToLoggedUser()).getCase() + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(net) + .title("Test assign") + .color("") + .loggedUser(testUser.transformToLoggedUser()) + .build() + Case case_ = workflowService.createCase(createCaseParams).getCase() assert !taskAuthorizationService.canCallAssign(testUser.transformToLoggedUser(), case_.getTaskStringId("1")) userService.removeRole(testUser, negativeRole.getStringId()) workflowService.deleteCase(case_.stringId) @@ -294,7 +305,13 @@ class TaskAuthorizationServiceTest { @Test void testCanAssignWithUsersRef() { - Case case_ = workflowService.createCase(netWithUserRefs.getStringId(), "Test assign", "", testUser.transformToLoggedUser()).getCase() + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(netWithUserRefs) + .title("Test assign") + .color("") + .loggedUser(testUser.transformToLoggedUser()) + .build() + Case case_ = workflowService.createCase(createCaseParams).getCase() String taskId = case_.getTaskStringId("1") case_ = dataService.setData(taskId, new DataSet([ "assign_pos_ul":new UserListField(rawValue: new UserListFieldValue([dataService.makeUserFieldValue(testUser.stringId)])) @@ -308,7 +325,13 @@ class TaskAuthorizationServiceTest { @Test void testCannotAssignWithUsersRef() { - Case case_ = workflowService.createCase(netWithUserRefs.getStringId(), "Test assign", "", testUser.transformToLoggedUser()).getCase() + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(netWithUserRefs) + .title("Test assign") + .color("") + .loggedUser(testUser.transformToLoggedUser()) + .build() + Case case_ = workflowService.createCase(createCaseParams).getCase() String taskId = case_.getTaskStringId("1") case_ = dataService.setData(taskId, new DataSet([ "assign_neg_ul": new UserListField(rawValue: new UserListFieldValue([dataService.makeUserFieldValue(testUser.stringId)])) @@ -323,7 +346,13 @@ class TaskAuthorizationServiceTest { void testCanAssignWithNegRoleAndPosUsersRef() { ProcessRole positiveRole = this.netWithUserRefs.getRoles().values().find(v -> v.getImportId() == "assign_pos_role") userService.addRole(testUser, positiveRole.getStringId()) - Case case_ = workflowService.createCase(netWithUserRefs.getStringId(), "Test assign", "", testUser.transformToLoggedUser()).getCase() + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(netWithUserRefs) + .title("Test assign") + .color("") + .loggedUser(testUser.transformToLoggedUser()) + .build() + Case case_ = workflowService.createCase(createCaseParams).getCase() String taskId = case_.getTaskStringId("1") case_ = dataService.setData(taskId, new DataSet([ "assign_pos_ul": new UserListField(rawValue: new UserListFieldValue([dataService.makeUserFieldValue(testUser.stringId)])) @@ -339,7 +368,13 @@ class TaskAuthorizationServiceTest { void testCanFinish() { ProcessRole positiveRole = this.netWithUserRefs.getRoles().values().find(v -> v.getImportId() == "finish_pos_role") userService.addRole(testUser, positiveRole.getStringId()) - Case case_ = workflowService.createCase(netWithUserRefs.getStringId(), "Test Finish", "", testUser.transformToLoggedUser()).getCase() + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(netWithUserRefs) + .title("Test Finish") + .color("") + .loggedUser(testUser.transformToLoggedUser()) + .build() + Case case_ = workflowService.createCase(createCaseParams).getCase() String taskId = case_.getTaskStringId("1") taskService.assignTask(testUser.transformToLoggedUser(), taskId) @@ -352,7 +387,13 @@ class TaskAuthorizationServiceTest { void testCanNotFinish() { ProcessRole negativeRole = this.netWithUserRefs.getRoles().values().find(v -> v.getImportId() == "finish_neg_role") userService.addRole(testUser, negativeRole.getStringId()) - Case case_ = workflowService.createCase(netWithUserRefs.getStringId(), "Test Finish", "", testUser.transformToLoggedUser()).getCase() + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(netWithUserRefs) + .title("Test Finish") + .color("") + .loggedUser(testUser.transformToLoggedUser()) + .build() + Case case_ = workflowService.createCase(createCaseParams).getCase() String taskId = case_.getTaskStringId("1") taskService.assignTask(testUser.transformToLoggedUser(), taskId) @@ -363,7 +404,13 @@ class TaskAuthorizationServiceTest { @Test void testCanFinishWithUsersRef() { - Case case_ = workflowService.createCase(netWithUserRefs.getStringId(), "Test Finish", "", testUser.transformToLoggedUser()).getCase() + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(netWithUserRefs) + .title("Test Finish") + .color("") + .loggedUser(testUser.transformToLoggedUser()) + .build() + Case case_ = workflowService.createCase(createCaseParams).getCase() String taskId = case_.getTaskStringId("1") case_ = dataService.setData(taskId, new DataSet([ "finish_pos_ul": new UserListField(rawValue: new UserListFieldValue([dataService.makeUserFieldValue(testUser.stringId)])) @@ -377,7 +424,13 @@ class TaskAuthorizationServiceTest { @Test void testCannotFinishWithUsersRef() { - Case case_ = workflowService.createCase(netWithUserRefs.getStringId(), "Test Finish", "", testUser.transformToLoggedUser()).getCase() + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(netWithUserRefs) + .title("Test Finish") + .color("") + .loggedUser(testUser.transformToLoggedUser()) + .build() + Case case_ = workflowService.createCase(createCaseParams).getCase() String taskId = case_.getTaskStringId("1") case_ = dataService.setData(taskId, new DataSet([ "finish_neg_ul": new UserListField(rawValue: new UserListFieldValue([dataService.makeUserFieldValue(testUser.stringId)])) @@ -393,7 +446,13 @@ class TaskAuthorizationServiceTest { void testCanFinishWithNegRoleAndPosUsersRef() { ProcessRole positiveRole = this.netWithUserRefs.getRoles().values().find(v -> v.getImportId() == "finish_pos_role") userService.addRole(testUser, positiveRole.getStringId()) - Case case_ = workflowService.createCase(netWithUserRefs.getStringId(), "Test Finish", "", testUser.transformToLoggedUser()).getCase() + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(netWithUserRefs) + .title("Test Finish") + .color("") + .loggedUser(testUser.transformToLoggedUser()) + .build() + Case case_ = workflowService.createCase(createCaseParams).getCase() String taskId = case_.getTaskStringId("1") case_ = dataService.setData(taskId, new DataSet([ "finish_pos_ul": new UserListField(rawValue: new UserListFieldValue([dataService.makeUserFieldValue(testUser.stringId)])) diff --git a/src/test/groovy/com/netgrif/application/engine/auth/WorkflowAuthorizationServiceTest.groovy b/src/test/groovy/com/netgrif/application/engine/auth/WorkflowAuthorizationServiceTest.groovy index 9984bd70a72..a5a1f515511 100644 --- a/src/test/groovy/com/netgrif/application/engine/auth/WorkflowAuthorizationServiceTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/auth/WorkflowAuthorizationServiceTest.groovy @@ -17,6 +17,7 @@ import com.netgrif.application.engine.startup.ImportHelper import com.netgrif.application.engine.startup.SuperCreator import com.netgrif.application.engine.workflow.domain.Case import com.netgrif.application.engine.workflow.domain.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome +import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams import com.netgrif.application.engine.workflow.service.interfaces.IDataService import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowAuthorizationService import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowService @@ -168,7 +169,13 @@ class WorkflowAuthorizationServiceTest { void testCanCallDelete() { ProcessRole positiveDeleteRole = this.net.getRoles().values().find(v -> v.getImportId() == "delete_pos_role") userService.addRole(testUser, positiveDeleteRole.getStringId()) - Case case_ = workflowService.createCase(net.getStringId(), "Test delete", "", testUser.transformToLoggedUser()).getCase() + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(net) + .title("Test delete") + .color("") + .loggedUser(testUser.transformToLoggedUser()) + .build() + Case case_ = workflowService.createCase(createCaseParams).getCase() assert workflowAuthorizationService.canCallDelete(testUser.transformToLoggedUser(), case_.getStringId()) userService.removeRole(testUser, positiveDeleteRole.getStringId()) } @@ -185,7 +192,13 @@ class WorkflowAuthorizationServiceTest { void testCanCallDeleteFalse() { ProcessRole deleteRole = this.net.getRoles().values().find(v -> v.getImportId() == "delete_neg_role") userService.addRole(testUser, deleteRole.getStringId()) - Case case_ = workflowService.createCase(net.getStringId(), "Test delete", "", testUser.transformToLoggedUser()).getCase() + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(net) + .title("Test delete") + .color("") + .loggedUser(testUser.transformToLoggedUser()) + .build() + Case case_ = workflowService.createCase(createCaseParams).getCase() assert !workflowAuthorizationService.canCallDelete(testUser.transformToLoggedUser(), case_.getStringId()) userService.removeRole(testUser, deleteRole.getStringId()) } @@ -199,7 +212,13 @@ class WorkflowAuthorizationServiceTest { userService.addRole(testUser, posDeleteRole.getStringId()) userService.addRole(testUser, negDeleteRole.getStringId()) - Case case_ = workflowService.createCase(netWithUserRefs.getStringId(), "Test delete", "", testUser.transformToLoggedUser()).getCase() + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(net) + .title("Test delete") + .color("") + .loggedUser(testUser.transformToLoggedUser()) + .build() + Case case_ = workflowService.createCase(createCaseParams).getCase() String taskId = case_.getTaskStringId("1") case_ = dataService.setData(taskId, new DataSet([ "pos_user_list": new UserListField(rawValue: new UserListFieldValue(userValues: [dataService.makeUserFieldValue(testUser.stringId)])), @@ -220,7 +239,13 @@ class WorkflowAuthorizationServiceTest { userService.addRole(testUser, posDeleteRole.getStringId()) userService.addRole(testUser, negDeleteRole.getStringId()) - Case case_ = workflowService.createCase(netWithUserRefs.getStringId(), "Test delete", "", testUser.transformToLoggedUser()).getCase() + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(netWithUserRefs) + .title("Test delete") + .color("") + .loggedUser(testUser.transformToLoggedUser()) + .build() + Case case_ = workflowService.createCase(createCaseParams).getCase() String taskId = case_.getTaskStringId("1") case_ = dataService.setData(taskId, new DataSet([ "pos_user_list": new UserListField(rawValue: new UserListFieldValue(userValues: [dataService.makeUserFieldValue(testUser.stringId)])), diff --git a/src/test/groovy/com/netgrif/application/engine/elastic/ReindexTest.groovy b/src/test/groovy/com/netgrif/application/engine/elastic/ReindexTest.groovy index db93093eb26..c9b3e57200f 100644 --- a/src/test/groovy/com/netgrif/application/engine/elastic/ReindexTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/elastic/ReindexTest.groovy @@ -9,6 +9,7 @@ import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetServi import com.netgrif.application.engine.startup.SuperCreator import com.netgrif.application.engine.workflow.domain.Case import com.netgrif.application.engine.workflow.domain.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome +import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowService import org.junit.jupiter.api.BeforeEach import org.junit.jupiter.api.Test @@ -55,9 +56,15 @@ class ReindexTest { int countTread = Thread.activeCount() List<Thread> threads = [] List<Case> savedCase = [] + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(net.getNet()) + .title("Test") + .color("color") + .loggedUser(superCreator.getLoggedSuper()) + .build() for (int i in 1..2000) { threads << Thread.start { - def useCase = workflowService.createCase(net.getNet().stringId, "Test", "color", superCreator.getLoggedSuper()).getCase() + def useCase = workflowService.createCase(createCaseParams).getCase() savedCase.add(useCase) } } @@ -69,7 +76,7 @@ class ReindexTest { threads = [] for (int i in 1..4000) { threads << Thread.start { - def useCase = workflowService.createCase(net.getNet().stringId, "Test", "color", superCreator.getLoggedSuper()).getCase() + def useCase = workflowService.createCase(createCaseParams).getCase() savedCase.add(useCase) } } diff --git a/src/test/groovy/com/netgrif/application/engine/history/HistoryServiceTest.groovy b/src/test/groovy/com/netgrif/application/engine/history/HistoryServiceTest.groovy index 16943c2c091..e836758e19e 100644 --- a/src/test/groovy/com/netgrif/application/engine/history/HistoryServiceTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/history/HistoryServiceTest.groovy @@ -7,10 +7,10 @@ import com.netgrif.application.engine.petrinet.domain.PetriNet import com.netgrif.application.engine.petrinet.domain.VersionType import com.netgrif.application.engine.petrinet.domain.dataset.NumberField 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.Case import com.netgrif.application.engine.workflow.domain.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome +import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams 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 @@ -65,7 +65,13 @@ class HistoryServiceTest { @Test void findAllAssignTaskEventLogsByCaseIdTest() { - Case caze = workflowService.createCase(net.getStringId(), "Test assign", "", superCreator.getLoggedSuper()).getCase() + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(net) + .title("Test assign") + .color("") + .loggedUser(superCreator.getLoggedSuper()) + .build() + Case caze = workflowService.createCase(createCaseParams).getCase() int count = historyService.findAllAssignTaskEventLogsByCaseId(caze.getStringId()).size() assert count == 0 String task = caze.tasks.values().find { it.transitionId == "1" }.taskStringId @@ -76,7 +82,13 @@ class HistoryServiceTest { @Test void findAllFinishTaskEventLogsByCaseId() { - Case caze = workflowService.createCase(net.getStringId(), "Test finish", "", superCreator.getLoggedSuper()).getCase() + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(net) + .title("Test finish") + .color("") + .loggedUser(superCreator.getLoggedSuper()) + .build() + Case caze = workflowService.createCase(createCaseParams).getCase() int count = historyService.findAllFinishTaskEventLogsByCaseId(caze.getStringId()).size() assert count == 0 String task = caze.tasks.values().find { it.transitionId == "1" }.taskStringId @@ -89,7 +101,13 @@ class HistoryServiceTest { @Test void findAllSetDataEventLogsByCaseId() { - Case caze = workflowService.createCase(net.getStringId(), "Test set data", "", superCreator.getLoggedSuper()).getCase() + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(net) + .title("Test set data") + .color("") + .loggedUser(superCreator.getLoggedSuper()) + .build() + Case caze = workflowService.createCase(createCaseParams).getCase() int count = historyService.findAllSetDataEventLogsByCaseId(caze.getStringId()).size() assert count == 0 String task = caze.tasks.values().find { it.transitionId == "1" }.taskStringId diff --git a/src/test/groovy/com/netgrif/application/engine/importer/PredefinedRolesPermissionsTest.groovy b/src/test/groovy/com/netgrif/application/engine/importer/PredefinedRolesPermissionsTest.groovy index 86ef94f0e88..cabe9c15a5a 100644 --- a/src/test/groovy/com/netgrif/application/engine/importer/PredefinedRolesPermissionsTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/importer/PredefinedRolesPermissionsTest.groovy @@ -15,6 +15,7 @@ import com.netgrif.application.engine.workflow.domain.Task import com.netgrif.application.engine.workflow.domain.TaskPair import com.netgrif.application.engine.workflow.domain.eventoutcomes.caseoutcomes.CreateCaseEventOutcome import com.netgrif.application.engine.workflow.domain.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome +import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams import com.netgrif.application.engine.workflow.service.interfaces.ITaskService import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowService import groovy.transform.CompileStatic @@ -456,7 +457,13 @@ class PredefinedRolesPermissionsTest { PetriNet net = importOutcome.getNet() - CreateCaseEventOutcome createCaseOutcome = workflowService.createCase(net.stringId, '', '', superCreator.loggedSuper) + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(net) + .title("") + .color("") + .loggedUser(superCreator.loggedSuper) + .build() + CreateCaseEventOutcome createCaseOutcome = workflowService.createCase(createCaseParams) assert createCaseOutcome.getCase() != null Case aCase = createCaseOutcome.getCase() diff --git a/src/test/groovy/com/netgrif/application/engine/importer/UserListTest.groovy b/src/test/groovy/com/netgrif/application/engine/importer/UserListTest.groovy index 8c05133e2e0..cd77dd3626c 100644 --- a/src/test/groovy/com/netgrif/application/engine/importer/UserListTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/importer/UserListTest.groovy @@ -8,7 +8,6 @@ import com.netgrif.application.engine.petrinet.domain.dataset.UserListField import com.netgrif.application.engine.petrinet.domain.dataset.UserListFieldValue import com.netgrif.application.engine.petrinet.domain.throwable.MissingPetriNetMetaDataException 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.utils.FullPageRequest import com.netgrif.application.engine.workflow.domain.Case diff --git a/src/test/groovy/com/netgrif/application/engine/insurance/EncryptionTest.groovy b/src/test/groovy/com/netgrif/application/engine/insurance/EncryptionTest.groovy index e31d83ac9b4..d0e0ac01ddb 100644 --- a/src/test/groovy/com/netgrif/application/engine/insurance/EncryptionTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/insurance/EncryptionTest.groovy @@ -10,6 +10,7 @@ import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetServi import com.netgrif.application.engine.startup.SuperCreator import com.netgrif.application.engine.workflow.domain.Case import com.netgrif.application.engine.workflow.domain.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome +import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams import com.netgrif.application.engine.workflow.domain.repositories.CaseRepository import com.netgrif.application.engine.workflow.service.TaskService import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowService @@ -84,7 +85,13 @@ class EncryptionTest { private String createCase() { ImportPetriNetEventOutcome net = petriNetService.importPetriNet(new FileInputStream("src/test/resources/mapping_test.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()) assert net.getNet() != null - def useCase = workflowService.createCase(net.getNet().stringId, "Encryption test", "color", mockLoggedUser()).getCase() + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(net.getNet()) + .title("Encryption test") + .color("color") + .loggedUser(mockLoggedUser()) + .build() + def useCase = workflowService.createCase(createCaseParams).getCase() def nameField = useCase.petriNet.dataSet.values().find { v -> v.name.defaultValue == FIELD_NAME } // TODO: release/8.0.0 // useCase.dataSet.put(nameField.stringId, new DataField(FIELD_VALUE)) diff --git a/src/test/groovy/com/netgrif/application/engine/permissions/ElasticSearchViewPermissionTest.groovy b/src/test/groovy/com/netgrif/application/engine/permissions/ElasticSearchViewPermissionTest.groovy index 0704ddb4991..6d72fbfac92 100644 --- a/src/test/groovy/com/netgrif/application/engine/permissions/ElasticSearchViewPermissionTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/permissions/ElasticSearchViewPermissionTest.groovy @@ -21,6 +21,7 @@ import com.netgrif.application.engine.startup.ImportHelper import com.netgrif.application.engine.startup.SuperCreator import com.netgrif.application.engine.workflow.domain.Case import com.netgrif.application.engine.workflow.domain.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome +import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams 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 @@ -100,7 +101,13 @@ class ElasticSearchViewPermissionTest { @Test void testSearchElasticViewWithUserWithoutRole() { - Case case_ = workflowService.createCase(net.getStringId(), "Permission test", "", testUser.transformToLoggedUser()).getCase() + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(net) + .title("Permission test") + .color("") + .loggedUser(testUser.transformToLoggedUser()) + .build() + Case case_ = workflowService.createCase(createCaseParams).getCase() CaseSearchRequest caseSearchRequest = new CaseSearchRequest() caseSearchRequest.process = [new CaseSearchRequest.PetriNet("vpt")] as List @@ -112,7 +119,13 @@ class ElasticSearchViewPermissionTest { @Test void testSearchElasticViewWithUserWithPosRole() { - Case case_ = workflowService.createCase(net.getStringId(), "Permission test", "", testUser.transformToLoggedUser()).getCase() + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(net) + .title("Permission test") + .color("") + .loggedUser(testUser.transformToLoggedUser()) + .build() + Case case_ = workflowService.createCase(createCaseParams).getCase() ProcessRole posViewRole = this.net.getRoles().values().find(v -> v.getImportId() == "view_pos_role") userService.addRole(testUser, posViewRole.getStringId()) @@ -130,7 +143,13 @@ class ElasticSearchViewPermissionTest { @Test void testSearchElasticViewWithUserWithNegRole() { - Case case_ = workflowService.createCase(net.getStringId(), "Permission test", "", testUser.transformToLoggedUser()).getCase() + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(net) + .title("Permission test") + .color("") + .loggedUser(testUser.transformToLoggedUser()) + .build() + Case case_ = workflowService.createCase(createCaseParams).getCase() ProcessRole negViewRole = this.net.getRoles().values().find(v -> v.getImportId() == "view_neg_role") userService.addRole(testUser, negViewRole.getStringId()) @@ -145,7 +164,13 @@ class ElasticSearchViewPermissionTest { @Test void testSearchElasticViewWithUserWithoutUserRef() { - Case case_ = workflowService.createCase(netWithUserRefs.getStringId(), "Permission test", "", testUser.transformToLoggedUser()).getCase() + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(netWithUserRefs) + .title("Permission test") + .color("") + .loggedUser(testUser.transformToLoggedUser()) + .build() + Case case_ = workflowService.createCase(createCaseParams).getCase() CaseSearchRequest caseSearchRequest = new CaseSearchRequest() caseSearchRequest.process = [new CaseSearchRequest.PetriNet(netWithUserRefs.getIdentifier())] as List @@ -157,7 +182,13 @@ class ElasticSearchViewPermissionTest { @Test void testSearchElasticViewWithUserWithPosUserRef() { - Case case_ = workflowService.createCase(netWithUserRefs.getStringId(), "Permission test", "", testUser.transformToLoggedUser()).getCase() + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(netWithUserRefs) + .title("Permission test") + .color("") + .loggedUser(testUser.transformToLoggedUser()) + .build() + Case case_ = workflowService.createCase(createCaseParams).getCase() String taskId = case_.getTaskStringId("1") dataService.setData(taskId, new DataSet([ "view_ul_pos": new UserListField(rawValue: new UserListFieldValue([dataService.makeUserFieldValue(testUser.stringId)])) @@ -175,7 +206,13 @@ class ElasticSearchViewPermissionTest { @Test void testSearchElasticViewWithUserWithNegUserRef() { - Case case_ = workflowService.createCase(netWithUserRefs.getStringId(), "Permission test", "", testUser.transformToLoggedUser()).getCase() + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(netWithUserRefs) + .title("Permission test") + .color("") + .loggedUser(testUser.transformToLoggedUser()) + .build() + Case case_ = workflowService.createCase(createCaseParams).getCase() String taskId = case_.getTaskStringId("1") dataService.setData(taskId, new DataSet([ "view_ul_neg": new UserListField(rawValue: new UserListFieldValue([dataService.makeUserFieldValue(testUser.stringId)])) @@ -193,7 +230,13 @@ class ElasticSearchViewPermissionTest { @Test void testSearchElasticViewWithUserWithNegativeRoleAndPosUserRef() { - Case case_ = workflowService.createCase(netWithUserRefs.getStringId(), "Permission test", "", testUser.transformToLoggedUser()).getCase() + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(netWithUserRefs) + .title("Permission test") + .color("") + .loggedUser(testUser.transformToLoggedUser()) + .build() + Case case_ = workflowService.createCase(createCaseParams).getCase() ProcessRole negViewRole = this.net.getRoles().values().find(v -> v.getImportId() == "view_neg_role") userService.addRole(testUser, negViewRole.getStringId()) String taskId = case_.getTaskStringId("1") diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/FunctionsTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/FunctionsTest.groovy index f1f86cbbd9a..52d4463af3f 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/FunctionsTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/FunctionsTest.groovy @@ -7,6 +7,7 @@ import com.netgrif.application.engine.petrinet.domain.dataset.* import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService import com.netgrif.application.engine.startup.SuperCreator import com.netgrif.application.engine.workflow.domain.Case +import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams 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 @@ -95,7 +96,13 @@ class FunctionsTest { assert functionResNet assert functionTestNet - Case aCase = workflowService.createCase(functionTestNet.stringId, "Test", "", userService.getLoggedOrSystem().transformToLoggedUser()).getCase() + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(functionTestNet) + .title("Test") + .color("") + .loggedUser(userService.getLoggedOrSystem().transformToLoggedUser()) + .build() + Case aCase = workflowService.createCase(createCaseParams).getCase() dataService.setData(aCase.getTaskStringId("1"), new DataSet(["createUser": new BooleanField(rawValue: true)] as Map<String, Field<?>>), superCreator.getLoggedSuper()) IUser user = userService.findByEmail("test@test.com", true) @@ -113,7 +120,13 @@ class FunctionsTest { assert functionResNet assert functionTestNet - Case aCase = workflowService.createCase(functionTestNet.stringId, "Test", "", userService.getLoggedOrSystem().transformToLoggedUser()).getCase() + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(functionTestNet) + .title("Test") + .color("") + .loggedUser(userService.getLoggedOrSystem().transformToLoggedUser()) + .build() + Case aCase = workflowService.createCase(createCaseParams).getCase() dataService.setData(aCase.getTaskStringId("1"), new DataSet((["enum": new EnumerationField(rawValue: new I18nString("ano"))] as Map<String, Field<?>>)), superCreator.getLoggedSuper()) aCase = workflowService.findOne(aCase.getStringId()) @@ -141,7 +154,13 @@ class FunctionsTest { def functionTestNet = petriNetService.importPetriNet(functionTestNetResource.inputStream, VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser()).getNet() assert functionTestNet - Case aCase = workflowService.createCase(functionTestNet.stringId, "Test", "", userService.getLoggedOrSystem().transformToLoggedUser()).getCase() + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(functionTestNet) + .title("Test") + .color("") + .loggedUser(userService.getLoggedOrSystem().transformToLoggedUser()) + .build() + Case aCase = workflowService.createCase(createCaseParams).getCase() dataService.setData(aCase.getTaskStringId("1"), new DataSet((["number": new NumberField(rawValue: 20d)] as Map<String, Field<?>>)), superCreator.getLoggedSuper()) }) } @@ -159,7 +178,13 @@ class FunctionsTest { def functionTestNet = petriNetService.importPetriNet(functionTestNetResource.inputStream, VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser()).getNet() assert functionTestNet - Case aCase = workflowService.createCase(functionTestNet.stringId, "Test", "", userService.getLoggedOrSystem().transformToLoggedUser()).getCase() + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(functionTestNet) + .title("Test") + .color("") + .loggedUser(userService.getLoggedOrSystem().transformToLoggedUser()) + .build() + Case aCase = workflowService.createCase(createCaseParams).getCase() dataService.setData(aCase.getTaskStringId("1"), new DataSet((["text": new TextField(rawValue: "20")] as Map<String, Field<?>>)), superCreator.getLoggedSuper()) functionTestNet = petriNetService.importPetriNet(functionTestNetResourceV2.inputStream, VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser()).getNet() @@ -175,7 +200,13 @@ class FunctionsTest { def functionTestNet = petriNetService.importPetriNet(functionTestNetResource.inputStream, VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser()).getNet() assert functionTestNet - Case aCase = workflowService.createCase(functionTestNet.stringId, "Test", "", userService.getLoggedOrSystem().transformToLoggedUser()).getCase() + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(functionTestNet) + .title("Test") + .color("") + .loggedUser(userService.getLoggedOrSystem().transformToLoggedUser()) + .build() + Case aCase = workflowService.createCase(createCaseParams).getCase() dataService.setData(aCase.getTaskStringId("1"), new DataSet((["number3": new NumberField(rawValue: 20d)] as Map<String, Field<?>>)), superCreator.getLoggedSuper()) }) } @@ -188,7 +219,13 @@ class FunctionsTest { assert functionResNet assert functionTestNet - Case aCase = workflowService.createCase(functionTestNet.stringId, "Test", "", userService.getLoggedOrSystem().transformToLoggedUser()).getCase() + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(functionTestNet) + .title("Test") + .color("") + .loggedUser(userService.getLoggedOrSystem().transformToLoggedUser()) + .build() + Case aCase = workflowService.createCase(createCaseParams).getCase() dataService.setData(aCase.getTaskStringId("1"), new DataSet((["number": new NumberField(rawValue: 20d)] as Map<String, Field<?>>)), superCreator.getLoggedSuper()) aCase = workflowService.findOne(aCase.getStringId()) @@ -215,7 +252,13 @@ class FunctionsTest { def functionResV2Net = petriNetService.importPetriNet(functionResNetResourceV2.inputStream, VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser()).getNet() def functionTestV2Net = petriNetService.importPetriNet(functionTestNetResourceV2.inputStream, VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser()).getNet() - Case aCase = workflowService.createCase(functionTestV2Net.stringId, "Test", "", userService.getLoggedOrSystem().transformToLoggedUser()).getCase() + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(functionTestV2Net) + .title("Test") + .color("") + .loggedUser(userService.getLoggedOrSystem().transformToLoggedUser()) + .build() + Case aCase = workflowService.createCase(createCaseParams).getCase() dataService.setData(aCase.getTaskStringId("0"), new DataSet((["updateOtherField": new BooleanField(rawValue: true)] as Map<String, Field<?>>)), superCreator.getLoggedSuper()) aCase = workflowService.findOne(aCase.stringId) @@ -244,7 +287,13 @@ class FunctionsTest { def petriNet = petriNetService.importPetriNet(resource.inputStream, VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser()).getNet() assert petriNet - Case aCase = workflowService.createCase(petriNet.stringId, "Test", "", userService.getLoggedOrSystem().transformToLoggedUser()).getCase() + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(petriNet) + .title("Test") + .color("") + .loggedUser(userService.getLoggedOrSystem().transformToLoggedUser()) + .build() + Case aCase = workflowService.createCase(createCaseParams).getCase() dataService.setData(aCase.getTaskStringId("1"), new DataSet((["number": new NumberField(rawValue: 20d)] as Map<String, Field<?>>)), superCreator.getLoggedSuper()) aCase = workflowService.findOne(aCase.getStringId()) NumberField numberField2 = aCase.dataSet.get("number2") as NumberField diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/ImporterTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/ImporterTest.groovy index ea9e4facb1b..3b5058dd074 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/ImporterTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/ImporterTest.groovy @@ -12,6 +12,7 @@ import com.netgrif.application.engine.startup.ImportHelper import com.netgrif.application.engine.startup.SuperCreator import com.netgrif.application.engine.workflow.domain.Case import com.netgrif.application.engine.workflow.domain.DataFieldBehavior +import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams import com.netgrif.application.engine.workflow.service.interfaces.ITaskService import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowService import groovy.transform.CompileStatic @@ -292,7 +293,13 @@ class ImporterTest { PetriNet net = petriNetService.importPetriNet(new ClassPathResource("/this_kw_test.xml").getInputStream(), VersionType.MAJOR, superCreator.getLoggedSuper()).getNet() assert net != null - Case testCase = workflowService.createCase(net.stringId, "Test case", "", superCreator.loggedSuper).getCase() + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(net) + .title("Test case") + .color("") + .loggedUser(superCreator.loggedSuper) + .build() + Case testCase = workflowService.createCase(createCaseParams).getCase() taskService.assignTask(testCase.getTaskStringId("t1")) testCase = workflowService.findOne(testCase.getStringId()) assert testCase.getDataSet().get("text_field").getRawValue() == "Hello world!" @@ -304,7 +311,13 @@ class ImporterTest { PetriNet net = petriNetService.importPetriNet(new ClassPathResource("/initial_behavior.xml").getInputStream(), VersionType.MAJOR, superCreator.getLoggedSuper()).getNet() assert net - Case testCase = workflowService.createCase(net.stringId, "Test case", "", superCreator.loggedSuper).getCase() + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(net) + .title("Test case") + .color("") + .loggedUser(superCreator.loggedSuper) + .build() + Case testCase = workflowService.createCase(createCaseParams).getCase() assertBehaviors(testCase.dataSet.get(NUMBER_FIELD).behaviors.get("1"), FORBIDDEN) assertBehaviors(testCase.dataSet.get(TEXT_FIELD).behaviors.get("1"), HIDDEN) diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicCaseNameTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicCaseNameTest.groovy index 01b714e2862..e47e59608d7 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicCaseNameTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicCaseNameTest.groovy @@ -6,6 +6,7 @@ import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetServi import com.netgrif.application.engine.startup.SuperCreator import com.netgrif.application.engine.workflow.domain.Case import com.netgrif.application.engine.workflow.domain.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome +import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowService import org.junit.jupiter.api.BeforeEach import org.junit.jupiter.api.Test @@ -40,10 +41,24 @@ class DynamicCaseNameTest { @Test void testInitValues() { ImportPetriNetEventOutcome optNet = petriNetService.importPetriNet(new FileInputStream("src/test/resources/petriNets/dynamic_case_name_test.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()) - Case useCase = workflowService.createCase(optNet.getNet().stringId, null, "", superCreator.loggedSuper, Locale.forLanguageTag("sk-SK")).getCase() + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(optNet.getNet()) + .title(null) + .color("") + .loggedUser(superCreator.loggedSuper) + .locale(Locale.forLanguageTag("sk-SK")) + .build() + Case useCase = workflowService.createCase(createCaseParams).getCase() assert useCase.title == "SK text value 6" - Case useCase2 = workflowService.createCase(optNet.getNet().stringId, null, "", superCreator.loggedSuper, Locale.ENGLISH).getCase() + CreateCaseParams createCaseParams2 = CreateCaseParams.builder() + .petriNet(optNet.getNet()) + .title(null) + .color("") + .loggedUser(superCreator.loggedSuper) + .locale(Locale.ENGLISH) + .build() + Case useCase2 = workflowService.createCase(createCaseParams2).getCase() assert useCase2.title == "EN text value 6" } } diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicValidationTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicValidationTest.groovy index 3f2a1f5479c..570b1afa2aa 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicValidationTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicValidationTest.groovy @@ -1,20 +1,13 @@ package com.netgrif.application.engine.petrinet.domain.dataset import com.netgrif.application.engine.TestHelper -import com.netgrif.application.engine.petrinet.domain.VersionType 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.Case -import com.netgrif.application.engine.workflow.domain.Task -import com.netgrif.application.engine.workflow.domain.eventoutcomes.dataoutcomes.SetDataEventOutcome -import com.netgrif.application.engine.workflow.domain.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome 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 import org.junit.jupiter.api.BeforeEach -import org.junit.jupiter.api.Disabled -import org.junit.jupiter.api.Test import org.junit.jupiter.api.extension.ExtendWith import org.springframework.beans.factory.annotation.Autowired import org.springframework.boot.test.context.SpringBootTest diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/FileFieldTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/FileFieldTest.groovy index 633d1f9db26..8da382142f0 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/FileFieldTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/FileFieldTest.groovy @@ -12,6 +12,7 @@ import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetServi import com.netgrif.application.engine.startup.ImportHelper import com.netgrif.application.engine.startup.SuperCreator import com.netgrif.application.engine.workflow.domain.Case +import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowService import org.junit.jupiter.api.BeforeEach import org.junit.jupiter.api.Test @@ -104,7 +105,13 @@ class FileFieldTest { IUser user = userService.findByEmail(configuration.email, true) assert user != null - Case useCase = workflowService.createCase(net.getStringId(), "Test file download", "black", user.transformToLoggedUser()).getCase() + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(net) + .title("Test file download") + .color("black") + .loggedUser(user.transformToLoggedUser()) + .build() + Case useCase = workflowService.createCase(createCaseParams).getCase() importHelper.assignTask(TASK_TITLE, useCase.getStringId(), user.transformToLoggedUser()) mockMvc.perform(get("/api/workflow/case/" + useCase.getStringId() + "/file") @@ -124,7 +131,13 @@ class FileFieldTest { IUser user = userService.findByEmail(configuration.email, true) assert user != null - Case useCase = workflowService.createCase(net.getStringId(), "Test file download", "black", user.transformToLoggedUser()).getCase() + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(net) + .title("Test file download") + .color("black") + .loggedUser(user.transformToLoggedUser()) + .build() + Case useCase = workflowService.createCase(createCaseParams).getCase() importHelper.assignTask(TASK_TITLE, useCase.getStringId(), user.transformToLoggedUser()) mockMvc.perform(get("/api/task/" + importHelper.getTaskId(TASK_TITLE, useCase.getStringId()) + "/file") diff --git a/src/test/groovy/com/netgrif/application/engine/workflow/ChangedFieldsAllowedNetsTest.groovy b/src/test/groovy/com/netgrif/application/engine/workflow/ChangedFieldsAllowedNetsTest.groovy index 2cb5c434987..357ac75a1de 100644 --- a/src/test/groovy/com/netgrif/application/engine/workflow/ChangedFieldsAllowedNetsTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/workflow/ChangedFieldsAllowedNetsTest.groovy @@ -3,8 +3,6 @@ package com.netgrif.application.engine.workflow import com.netgrif.application.engine.TestHelper import com.netgrif.application.engine.petrinet.domain.PetriNet import com.netgrif.application.engine.startup.ImportHelper -import com.netgrif.application.engine.workflow.domain.eventoutcomes.EventOutcome -import com.netgrif.application.engine.workflow.domain.eventoutcomes.dataoutcomes.SetDataEventOutcome import com.netgrif.application.engine.workflow.service.interfaces.IDataService import groovy.transform.CompileStatic import org.junit.jupiter.api.BeforeEach diff --git a/src/test/groovy/com/netgrif/application/engine/workflow/NewInitTest.groovy b/src/test/groovy/com/netgrif/application/engine/workflow/NewInitTest.groovy index 9ab1c690868..b8373f69627 100644 --- a/src/test/groovy/com/netgrif/application/engine/workflow/NewInitTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/workflow/NewInitTest.groovy @@ -10,6 +10,7 @@ import com.netgrif.application.engine.petrinet.domain.throwable.MissingPetriNetM import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService import com.netgrif.application.engine.startup.SuperCreator import com.netgrif.application.engine.workflow.domain.Case +import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowService import groovy.transform.CompileStatic import org.junit.jupiter.api.BeforeEach @@ -46,7 +47,13 @@ class NewInitTest { @Test void newInitTest() throws IOException, MissingIconKeyException, MissingPetriNetMetaDataException { petriNetService.importPetriNet(new FileInputStream("src/test/resources/petriNets/nae_1276_Init_value_as_choice.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()) - Case initTestCase = workflowService.createCase(petriNetService.getNewestVersionByIdentifier("new_init_test").stringId, "New init test", "", superCreator.getLoggedSuper()).getCase() + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(petriNetService.getNewestVersionByIdentifier("new_init_test")) + .title("New init test") + .color("") + .loggedUser(superCreator.getLoggedSuper()) + .build() + Case initTestCase = workflowService.createCase(createCaseParams).getCase() // TODO: release/8.0.0 // assert (initTestCase.dataSet["new_init_multichoice"].value as List<I18nString>).stream().any { ((I18nString) it).defaultValue == "Bob" } // assert (initTestCase.dataSet["new_init_multichoice"].value as List<I18nString>).stream().any { ((I18nString) it).defaultValue == "Alice" } diff --git a/src/test/groovy/com/netgrif/application/engine/workflow/TaskStateTest.groovy b/src/test/groovy/com/netgrif/application/engine/workflow/TaskStateTest.groovy index fb997411a3b..76af0d5c340 100644 --- a/src/test/groovy/com/netgrif/application/engine/workflow/TaskStateTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/workflow/TaskStateTest.groovy @@ -7,6 +7,7 @@ import com.netgrif.application.engine.startup.ImportHelper 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.params.CreateCaseParams import com.netgrif.application.engine.workflow.service.interfaces.ITaskService import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowService import groovy.transform.CompileStatic @@ -51,7 +52,13 @@ class TaskStateTest { assert netOptional.isPresent() PetriNet net = netOptional.get() - Case useCase = workflowService.createCase(net.stringId, "Test Case", "", superCreator.superUser.transformToLoggedUser())?.case + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(net) + .title("Test Case") + .color("") + .loggedUser(superCreator.superUser.transformToLoggedUser()) + .build() + Case useCase = workflowService.createCase(createCaseParams)?.case assert useCase List<Task> tasks = taskService.findAllByCase(useCase.stringId) @@ -66,7 +73,13 @@ class TaskStateTest { assert netOptional.isPresent() PetriNet net = netOptional.get() - Case useCase = workflowService.createCase(net.stringId, "Test Case", "", superCreator.superUser.transformToLoggedUser())?.case + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(net) + .title("Test Case") + .color("") + .loggedUser(superCreator.superUser.transformToLoggedUser()) + .build() + Case useCase = workflowService.createCase(createCaseParams)?.case assert useCase 4.times { index -> diff --git a/src/test/groovy/com/netgrif/application/engine/workflow/WorkflowServiceTest.groovy b/src/test/groovy/com/netgrif/application/engine/workflow/WorkflowServiceTest.groovy index 03eee44a48c..f85a06ace65 100644 --- a/src/test/groovy/com/netgrif/application/engine/workflow/WorkflowServiceTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/workflow/WorkflowServiceTest.groovy @@ -6,11 +6,14 @@ import com.netgrif.application.engine.petrinet.domain.VersionType 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.utils.InputStreamToString import com.netgrif.application.engine.workflow.domain.Case +import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowService +import groovy.time.TimeCategory +import groovy.time.TimeDuration import groovy.transform.CompileStatic import org.junit.jupiter.api.BeforeEach +import org.junit.jupiter.api.Disabled import org.junit.jupiter.api.Test import org.junit.jupiter.api.extension.ExtendWith import org.springframework.beans.factory.annotation.Autowired @@ -18,6 +21,8 @@ import org.springframework.boot.test.context.SpringBootTest import org.springframework.test.context.ActiveProfiles import org.springframework.test.context.junit.jupiter.SpringExtension +import static com.netgrif.application.engine.workflow.domain.params.CreateCaseParams.* + @ExtendWith(SpringExtension.class) @ActiveProfiles(["test"]) @SpringBootTest @@ -53,6 +58,44 @@ class WorkflowServiceTest { testHelper.truncateDbs() } + @Test + @Disabled + void testblabla() { + def testNetWithTriggers = petriNetService.importPetriNet(stream("petriNets/test_with_triggers.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()).getNet() + def testNet = petriNetService.importPetriNet(stream("petriNets/mortgage.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()).getNet() + + int iterations = 2 + def paramsWithoutTrigger = CreateCaseParams.builder() + .petriNet(testNet) + .loggedUser(superCreator.getLoggedSuper()) + .build() + def paramsWithTrigger = CreateCaseParams.builder() + .petriNet(testNetWithTriggers) + .loggedUser(superCreator.getLoggedSuper()) + .build() + + long totalWithoutTriggers = 0 + (0..iterations).each { + Date startTime = new Date() + workflowService.createCase(paramsWithoutTrigger) + Date endTime = new Date() + TimeDuration elapsedTimeTransactional = TimeCategory.minus( endTime, startTime ) + totalWithoutTriggers += elapsedTimeTransactional.toMilliseconds() + } + + long totalWithTriggers = 0 +// (0..iterations).each { +// Date startTime = new Date() +// workflowService.createCase(paramsWithTrigger) +// Date endTime = new Date() +// TimeDuration elapsedTimeTransactional = TimeCategory.minus( endTime, startTime ) +// totalWithTriggers += elapsedTimeTransactional.toMilliseconds() +// } + + println("AVG without triggers for 1 create case: " + totalWithoutTriggers / iterations + "ms") + println("AVG with triggers for 1 create case: " + totalWithTriggers / iterations + "ms") + } + @Test void testFindOneImmediateData() { def testNet = petriNetService.importPetriNet(stream(NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper()) @@ -73,7 +116,13 @@ class WorkflowServiceTest { assert testNet def net = testNet - Case aCase = workflowService.createCase(net.stringId, "autoErr", "red", superCreator.getLoggedSuper()).getCase() + CreateCaseParams createCaseParams = builder() + .petriNet(net) + .title("autoErr") + .color("red") + .loggedUser(superCreator.getLoggedSuper()) + .build() + Case aCase = workflowService.createCase(createCaseParams).getCase() importHelper.assignTask("Manual", aCase.getStringId(), superCreator.getLoggedSuper()) importHelper.finishTask("Manual", aCase.getStringId(), superCreator.getLoggedSuper()) @@ -85,7 +134,13 @@ class WorkflowServiceTest { void testSecondTransitionAuto() { def net = petriNetService.importPetriNet(stream(SECOND_AUTO_NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper()).getNet() - Case aCase = workflowService.createCase(net.stringId, "autoErr", "red", superCreator.getLoggedSuper()).getCase() + CreateCaseParams createCaseParams = builder() + .petriNet(net) + .title("autoErr") + .color("red") + .loggedUser(superCreator.getLoggedSuper()) + .build() + Case aCase = workflowService.createCase(createCaseParams).getCase() importHelper.assignTask("Manual", aCase.getStringId(), superCreator.getLoggedSuper()) importHelper.finishTask("Manual", aCase.getStringId(), superCreator.getLoggedSuper()) @@ -102,13 +157,26 @@ class WorkflowServiceTest { assert testNet.getNet() != null def net = testNet.getNet() - Case aCase = workflowService.createCase(net.stringId, null, null, superCreator.getLoggedSuper(), new Locale('sk')).getCase() + CreateCaseParams createCaseParams = builder() + .petriNet(net) + .title(null) + .color(null) + .loggedUser(superCreator.getLoggedSuper()) + .locale(new Locale('sk')) + .build() + Case aCase = workflowService.createCase(createCaseParams).getCase() assert aCase.title == "Slovenský preklad" - // TODO: release/8.0.0 fix uri nodes -// assert workflowService.findOne(aCase.stringId).uriNodeId == net.uriNodeId - - Case enCase = workflowService.createCase(net.stringId, null, null, superCreator.getLoggedSuper(), new Locale('en')).getCase() + assert workflowService.findOne(aCase.stringId).uriNodeId == net.uriNodeId + + createCaseParams = builder() + .petriNet(net) + .title(null) + .color(null) + .loggedUser(superCreator.getLoggedSuper()) + .locale(new Locale('en')) + .build() + Case enCase = workflowService.createCase(createCaseParams).getCase() assert enCase.title == "English translation" } diff --git a/src/test/java/com/netgrif/application/engine/importer/ImporterTest.java b/src/test/java/com/netgrif/application/engine/importer/ImporterTest.java index 8a360a5225e..0cda1f2c4e2 100644 --- a/src/test/java/com/netgrif/application/engine/importer/ImporterTest.java +++ b/src/test/java/com/netgrif/application/engine/importer/ImporterTest.java @@ -13,6 +13,7 @@ import com.netgrif.application.engine.utils.FullPageRequest; import com.netgrif.application.engine.workflow.domain.eventoutcomes.caseoutcomes.CreateCaseEventOutcome; import com.netgrif.application.engine.workflow.domain.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome; +import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams; import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowService; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -28,7 +29,6 @@ import java.io.IOException; import java.util.Arrays; import java.util.List; -import java.util.stream.Collectors; import static org.assertj.core.api.Assertions.assertThatThrownBy; @@ -74,7 +74,13 @@ public void priorityTest() throws MissingPetriNetMetaDataException, IOException, ImportPetriNetEventOutcome outcome = petriNetService.importPetriNet(new FileInputStream("src/test/resources/priority_test.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()); assert outcome.getNet() != null; - CreateCaseEventOutcome caseOutcome = workflowService.createCase(outcome.getNet().getStringId(), outcome.getNet().getTitle().getDefaultValue(), "color", superCreator.getLoggedSuper()); + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(outcome.getNet()) + .title(outcome.getNet().getTitle().getDefaultValue()) + .color("color") + .loggedUser(superCreator.getLoggedSuper()) + .build(); + CreateCaseEventOutcome caseOutcome = workflowService.createCase(createCaseParams); assert caseOutcome.getCase() != null; } diff --git a/src/test/java/com/netgrif/application/engine/rules/service/RuleEngineTest.java b/src/test/java/com/netgrif/application/engine/rules/service/RuleEngineTest.java index 421131b2b56..3e16360855d 100644 --- a/src/test/java/com/netgrif/application/engine/rules/service/RuleEngineTest.java +++ b/src/test/java/com/netgrif/application/engine/rules/service/RuleEngineTest.java @@ -5,7 +5,6 @@ import com.netgrif.application.engine.auth.domain.LoggedUser; import com.netgrif.application.engine.auth.service.interfaces.IUserService; import com.netgrif.application.engine.configuration.drools.RefreshableKieBase; -import com.netgrif.application.engine.importer.model.EventType; import com.netgrif.application.engine.importer.service.throwable.MissingIconKeyException; import com.netgrif.application.engine.petrinet.domain.VersionType; import com.netgrif.application.engine.petrinet.domain.throwable.MissingPetriNetMetaDataException; @@ -19,6 +18,7 @@ import com.netgrif.application.engine.workflow.domain.Task; import com.netgrif.application.engine.workflow.domain.eventoutcomes.caseoutcomes.CreateCaseEventOutcome; import com.netgrif.application.engine.workflow.domain.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome; +import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams; import com.netgrif.application.engine.workflow.service.interfaces.ITaskService; import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowService; import lombok.extern.slf4j.Slf4j; @@ -197,7 +197,13 @@ void testTransitionRules() throws IOException, MissingPetriNetMetaDataException, ruleRepository.save(rule3); ruleRepository.save(rule4); - CreateCaseEventOutcome caseOutcome = workflowService.createCase(outcome.getNet().getStringId(), "Original title", "original color", superUser); + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(outcome.getNet()) + .title("Original title") + .color("original color") + .loggedUser(superUser) + .build(); + CreateCaseEventOutcome caseOutcome = workflowService.createCase(createCaseParams); // TODO: release/8.0.0 AssertionError assert caseOutcome.getCase().getTitle().equals(NEW_CASE_TITLE); @@ -375,7 +381,13 @@ private StoredRule rule(String when, String then) { private Case newCase() throws IOException, MissingPetriNetMetaDataException, MissingIconKeyException { ImportPetriNetEventOutcome outcome = petriNetService.importPetriNet(new FileInputStream("src/test/resources/rule_engine_test.xml"), VersionType.MAJOR, superUser); - return workflowService.createCase(outcome.getNet().getStringId(), "Original title", "original color", superUser).getCase(); + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(outcome.getNet()) + .title("Original title") + .color("original color") + .loggedUser(superUser) + .build(); + return workflowService.createCase(createCaseParams).getCase(); } private Task findTask(Case caze, String trans) { diff --git a/src/test/java/com/netgrif/application/engine/rules/service/RuleEvaluationScheduleServiceTest.java b/src/test/java/com/netgrif/application/engine/rules/service/RuleEvaluationScheduleServiceTest.java index 45d67650f99..57e187f938d 100644 --- a/src/test/java/com/netgrif/application/engine/rules/service/RuleEvaluationScheduleServiceTest.java +++ b/src/test/java/com/netgrif/application/engine/rules/service/RuleEvaluationScheduleServiceTest.java @@ -15,6 +15,7 @@ import com.netgrif.application.engine.workflow.domain.Case; import com.netgrif.application.engine.workflow.domain.eventoutcomes.caseoutcomes.CreateCaseEventOutcome; import com.netgrif.application.engine.workflow.domain.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome; +import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams; import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowService; import lombok.extern.slf4j.Slf4j; import org.junit.jupiter.api.AfterEach; @@ -78,7 +79,13 @@ void testScheduledRule() throws IOException, MissingPetriNetMetaDataException, R .build(); ruleRepository.save(rule); - CreateCaseEventOutcome caseOutcome = workflowService.createCase(importOutcome.getNet().getStringId(), "Original title", "original color", user); + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(importOutcome.getNet()) + .title("Original title") + .color("original color") + .loggedUser(user) + .build(); + CreateCaseEventOutcome caseOutcome = workflowService.createCase(createCaseParams); ScheduleOutcome outcome = ruleEvaluationScheduleService.scheduleRuleEvaluationForCase(caseOutcome.getCase(), "rule2", TriggerBuilder.newTrigger().withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(1).withRepeatCount(5))); assert outcome.getJobDetail() != null; diff --git a/src/test/java/com/netgrif/application/engine/workflow/service/TaskServiceTest.java b/src/test/java/com/netgrif/application/engine/workflow/service/TaskServiceTest.java index 59983f22c1f..ba34d585476 100644 --- a/src/test/java/com/netgrif/application/engine/workflow/service/TaskServiceTest.java +++ b/src/test/java/com/netgrif/application/engine/workflow/service/TaskServiceTest.java @@ -20,6 +20,7 @@ import com.netgrif.application.engine.workflow.domain.Case; import com.netgrif.application.engine.workflow.domain.Task; import com.netgrif.application.engine.workflow.domain.eventoutcomes.caseoutcomes.CreateCaseEventOutcome; +import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams; import com.netgrif.application.engine.workflow.domain.repositories.CaseRepository; import com.netgrif.application.engine.workflow.domain.repositories.TaskRepository; import com.netgrif.application.engine.workflow.service.interfaces.ITaskService; @@ -91,14 +92,26 @@ public void setUp() throws Exception { petriNetService.importPetriNet(new FileInputStream("src/test/resources/prikladFM.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()); PetriNet net = petriNetRepository.findAll().get(0); - workflowService.createCase(net.getStringId(), "Storage Unit", "color", mockLoggedUser()); + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(net) + .title("Storage Unit") + .color("color") + .loggedUser(mockLoggedUser()) + .build(); + workflowService.createCase(createCaseParams); } @Test public void resetArcTest() throws TransitionNotExecutableException, MissingPetriNetMetaDataException, IOException, MissingIconKeyException { PetriNet net = petriNetService.importPetriNet(new FileInputStream("src/test/resources/reset_inhibitor_test.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()).getNet(); LoggedUser loggedUser = mockLoggedUser(); - CreateCaseEventOutcome outcome = workflowService.createCase(net.getStringId(), "Reset test", "color", loggedUser); + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(net) + .title("Reset test") + .color("color") + .loggedUser(loggedUser) + .build(); + CreateCaseEventOutcome outcome = workflowService.createCase(createCaseParams); User user = new User(); user.setName("name"); user.setPassword("password"); diff --git a/src/test/java/com/netgrif/application/engine/workflow/web/VariableArcsTest.java b/src/test/java/com/netgrif/application/engine/workflow/web/VariableArcsTest.java index 0de83af0a03..f09e213a051 100644 --- a/src/test/java/com/netgrif/application/engine/workflow/web/VariableArcsTest.java +++ b/src/test/java/com/netgrif/application/engine/workflow/web/VariableArcsTest.java @@ -17,7 +17,6 @@ import com.netgrif.application.engine.petrinet.domain.throwable.TransitionNotExecutableException; import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService; import com.netgrif.application.engine.petrinet.service.interfaces.IProcessRoleService; -import com.netgrif.application.engine.startup.DefaultRoleRunner; import com.netgrif.application.engine.startup.ImportHelper; import com.netgrif.application.engine.startup.SuperCreator; import com.netgrif.application.engine.startup.SystemUserRunner; @@ -26,6 +25,7 @@ import com.netgrif.application.engine.workflow.domain.Task; import com.netgrif.application.engine.workflow.domain.eventoutcomes.caseoutcomes.CreateCaseEventOutcome; import com.netgrif.application.engine.workflow.domain.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome; +import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams; 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.TaskReference; @@ -125,7 +125,13 @@ public void importTest() throws MissingIconKeyException { List<Arc> arcs = this.loaded.getArcs().values().stream().flatMap(List::stream).collect(Collectors.toList()); assert arcs.size() > 0; - CreateCaseEventOutcome caseOutcome = workflowService.createCase(this.loaded.getStringId(), "VARTEST", "red", mock.mockLoggedUser()); + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(this.loaded) + .title("VARTEST") + .color("red") + .loggedUser(mock.mockLoggedUser()) + .build(); + CreateCaseEventOutcome caseOutcome = workflowService.createCase(createCaseParams); assert caseOutcome.getCase().getPetriNet().getArcs() .values() diff --git a/src/test/resources/change_caseref_value_action_test.xml b/src/test/resources/change_caseref_value_action_test.xml index e82f26c7613..74ab34a4cf2 100644 --- a/src/test/resources/change_caseref_value_action_test.xml +++ b/src/test/resources/change_caseref_value_action_test.xml @@ -29,8 +29,14 @@ <action trigger="set"> <!-- @formatter:off --> caseref: f.caseref; - def net = petriNetService.getNewestVersionByIdentifier("change_value"); - def newCase = workflowService.createCase(net.stringId, "", "", userService.getLoggedOrSystem().transformToLoggedUser()).getACase() + def net = petriNetService.getNewestVersionByIdentifier("change_value") + def createCaseParams = CreateCaseParams.builder() + .petriNet(net) + .title("") + .color("") + .loggedUser(userService.getLoggedOrSystem().transformToLoggedUser()) + .build() + def newCase = workflowService.createCase(createCaseParams).getACase() def newValue = new ArrayList(caseref.value) newValue.add(newCase) change caseref value {return newValue} @@ -43,8 +49,14 @@ <action trigger="set"> <!-- @formatter:off --> caseref: f.caseref; - def net = petriNetService.getNewestVersionByIdentifier("test"); - def newCase = workflowService.createCase(net.stringId, "", "", userService.getLoggedOrSystem().transformToLoggedUser()).getACase() + def net = petriNetService.getNewestVersionByIdentifier("test") + def createCaseParams = CreateCaseParams.builder() + .petriNet(net) + .title("") + .color("") + .loggedUser(userService.getLoggedOrSystem().transformToLoggedUser()) + .build() + def newCase = workflowService.createCase(createCaseParams).getACase() def newValue = new ArrayList(caseref.value) newValue.add(newCase) try { From a943bdc1f353bdcbd2d96e3a51b0b8c390bf5ee2 Mon Sep 17 00:00:00 2001 From: chvostek <chvostek@netgrif.com> Date: Mon, 5 Aug 2024 15:07:44 +0200 Subject: [PATCH 23/48] [NAE-1998] Implement transactions for events - remove unused field in WorkflowService - update access modifiers in WorkflowService --- .../workflow/service/WorkflowService.java | 36 ++++++------------- 1 file changed, 10 insertions(+), 26 deletions(-) diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/WorkflowService.java b/src/main/java/com/netgrif/application/engine/workflow/service/WorkflowService.java index 2f1a8b437fd..e3a17ef7a20 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/WorkflowService.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/WorkflowService.java @@ -9,15 +9,12 @@ import com.netgrif.application.engine.history.domain.caseevents.DeleteCaseEventLog; import com.netgrif.application.engine.history.service.IHistoryService; import com.netgrif.application.engine.importer.model.CaseEventType; -import com.netgrif.application.engine.importer.service.FieldFactory; import com.netgrif.application.engine.petrinet.domain.I18nString; import com.netgrif.application.engine.petrinet.domain.PetriNet; import com.netgrif.application.engine.petrinet.domain.dataset.*; -import com.netgrif.application.engine.petrinet.domain.dataset.logic.action.ActionRunner; import com.netgrif.application.engine.petrinet.domain.events.EventPhase; import com.netgrif.application.engine.petrinet.domain.roles.ProcessRolePermission; import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService; -import com.netgrif.application.engine.petrinet.service.interfaces.IProcessRoleService; import com.netgrif.application.engine.rules.domain.facts.CaseCreatedFact; import com.netgrif.application.engine.rules.service.interfaces.IRuleEngine; import com.netgrif.application.engine.security.service.EncryptionService; @@ -40,7 +37,6 @@ import lombok.extern.slf4j.Slf4j; import org.bson.types.ObjectId; import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.context.ApplicationEventPublisher; import org.springframework.context.annotation.Lazy; import org.springframework.data.domain.Page; import org.springframework.data.domain.PageImpl; @@ -63,40 +59,28 @@ public class WorkflowService implements IWorkflowService { @Autowired - protected CaseRepository repository; + private CaseRepository repository; @Autowired - protected MongoTemplate mongoTemplate; + private MongoTemplate mongoTemplate; @Autowired - protected IPetriNetService petriNetService; + private IPetriNetService petriNetService; @Autowired - protected IProcessRoleService processRoleService; + private ITaskService taskService; @Autowired - protected ITaskService taskService; + private EncryptionService encryptionService; @Autowired - protected ApplicationEventPublisher publisher; + private IRuleEngine ruleEngine; @Autowired - protected EncryptionService encryptionService; + private IUserService userService; @Autowired - protected FieldFactory fieldFactory; - - @Autowired - protected IRuleEngine ruleEngine; - - @Autowired - protected ActionRunner actionsRunner; - - @Autowired - protected IUserService userService; - - @Autowired - protected IInitValueExpressionEvaluator initValueExpressionEvaluator; + private IInitValueExpressionEvaluator initValueExpressionEvaluator; @Lazy @Autowired @@ -105,7 +89,7 @@ public class WorkflowService implements IWorkflowService { @Autowired private IHistoryService historyService; - protected IElasticCaseService elasticCaseService; + private IElasticCaseService elasticCaseService; @Autowired private DataSetInitializer dataSetInitializer; @@ -139,7 +123,7 @@ public Case findOneNoNet(String caseId) { return caseOptional.orElseThrow(() -> new IllegalArgumentException("Could not find Case with id [" + caseId + "]")); } - protected void initialize(Case useCase) { + private void initialize(Case useCase) { setPetriNet(useCase); decryptDataSet(useCase); useCase.resolveImmediateDataFields(); From 910a017a1bc3cb68cac7d2159612361cddd1b132 Mon Sep 17 00:00:00 2001 From: chvostek <chvostek@netgrif.com> Date: Mon, 5 Aug 2024 16:22:15 +0200 Subject: [PATCH 24/48] [NAE-1998] Implement transactions for events - move eventoutcomes package - refactor WorkflowService.deleteCase - fix case title initialization - more optimization for WorkflowService.createCase --- .../engine/migration/ActionMigration.groovy | 2 +- .../logic/action/ActionDelegate.groovy | 23 +++-- .../dataset/logic/action/ActionRunner.groovy | 2 +- .../logic/action/FrontendActionOutcome.groovy | 4 +- .../engine/startup/ImportHelper.groovy | 8 +- .../orgstructure/groups/NextGroupService.java | 3 +- .../groups/interfaces/INextGroupService.java | 2 +- .../engine/petrinet/domain/PetriNet.java | 4 + .../petrinet/service/PetriNetService.java | 2 +- .../service/interfaces/IPetriNetService.java | 2 +- .../petrinet/web/PetriNetController.java | 6 +- ...galArgumentWithChangedFieldsException.java | 2 +- .../CreateTasksOutcome.java | 2 +- .../eventoutcomes/EventOutcome.java | 2 +- .../caseoutcomes/CaseEventOutcome.java | 6 +- .../caseoutcomes/CreateCaseEventOutcome.java | 4 +- .../caseoutcomes/DeleteCaseEventOutcome.java | 4 +- .../dataoutcomes/GetDataEventOutcome.java | 6 +- .../GetDataGroupsEventOutcome.java | 6 +- .../dataoutcomes/SetDataEventOutcome.java | 6 +- .../ImportPetriNetEventOutcome.java | 4 +- .../PetriNetEventOutcome.java | 4 +- .../response/EventOutcomeWithMessage.java | 4 +- .../EventOutcomeWithMessageResource.java | 4 +- .../taskoutcomes/AssignTaskEventOutcome.java | 4 +- .../taskoutcomes/CancelTaskEventOutcome.java | 4 +- .../DelegateTaskEventOutcome.java | 4 +- .../taskoutcomes/FinishTaskEventOutcome.java | 4 +- .../taskoutcomes/TaskEventOutcome.java | 6 +- .../domain/params/DeleteCaseParams.java | 52 ++++++++++ .../engine/workflow/service/DataService.java | 10 +- .../engine/workflow/service/EventService.java | 4 +- .../engine/workflow/service/TaskService.java | 36 +++---- .../workflow/service/WorkflowService.java | 94 ++++++++++++------- .../service/interfaces/IDataService.java | 6 +- .../service/interfaces/IEventService.java | 4 +- .../service/interfaces/ITaskService.java | 14 +-- .../service/interfaces/IWorkflowService.java | 17 ++-- .../workflow/web/AbstractTaskController.java | 8 +- .../workflow/web/PublicTaskController.java | 2 +- .../web/PublicWorkflowController.java | 6 +- .../engine/workflow/web/TaskController.java | 2 +- .../workflow/web/WorkflowController.java | 11 ++- .../engine/action/AssignRemoveTest.groovy | 8 +- .../engine/action/MenuItemApiTest.groovy | 6 +- .../auth/TaskAuthorizationServiceTest.groovy | 50 +++++++--- .../WorkflowAuthorizationServiceTest.groovy | 2 +- .../engine/elastic/ReindexTest.groovy | 2 +- .../engine/history/HistoryServiceTest.groovy | 2 +- .../importer/AllDataTransitionTest.groovy | 2 +- .../PredefinedRolesPermissionsTest.groovy | 4 +- .../engine/importer/UserListTest.groovy | 2 +- .../engine/insurance/EncryptionTest.groovy | 2 +- .../application/engine/ipc/CaseApiTest.groovy | 2 +- .../engine/menu/MenuImportExportTest.groovy | 2 +- .../ElasticSearchViewPermissionTest.groovy | 38 ++++++-- .../engine/petrinet/domain/EventTest.groovy | 2 +- .../domain/dataset/CaseFieldTest.groovy | 2 +- .../dataset/ChangeFieldValueInitTest.groovy | 2 +- .../domain/dataset/DynamicCaseNameTest.groovy | 2 +- .../domain/dataset/DynamicChoicesTest.groovy | 2 +- .../dataset/DynamicDefaultValueTest.groovy | 2 +- .../dataset/DynamicEnumerationTest.groovy | 2 +- .../DynamicValidationPerformanceTest.groovy | 2 +- .../service/CachePetriNetServiceTest.groovy | 2 +- .../service/PetriNetServiceTest.groovy | 2 +- .../engine/workflow/DataServiceTest.groovy | 2 +- .../workflow/WorkflowServiceTest.groovy | 5 +- .../ConstructorAndDestructorTest.java | 2 +- .../engine/importer/ImporterTest.java | 4 +- .../service/ProcessRoleServiceTest.java | 2 +- .../engine/rules/service/RuleEngineTest.java | 4 +- .../RuleEvaluationScheduleServiceTest.java | 4 +- .../workflow/service/TaskServiceTest.java | 2 +- .../engine/workflow/web/VariableArcsTest.java | 4 +- 75 files changed, 355 insertions(+), 216 deletions(-) rename src/main/java/com/netgrif/application/engine/workflow/domain/{outcome => outcomes}/CreateTasksOutcome.java (80%) rename src/main/java/com/netgrif/application/engine/workflow/domain/{ => outcomes}/eventoutcomes/EventOutcome.java (94%) rename src/main/java/com/netgrif/application/engine/workflow/domain/{ => outcomes}/eventoutcomes/caseoutcomes/CaseEventOutcome.java (77%) rename src/main/java/com/netgrif/application/engine/workflow/domain/{ => outcomes}/eventoutcomes/caseoutcomes/CreateCaseEventOutcome.java (79%) rename src/main/java/com/netgrif/application/engine/workflow/domain/{ => outcomes}/eventoutcomes/caseoutcomes/DeleteCaseEventOutcome.java (78%) rename src/main/java/com/netgrif/application/engine/workflow/domain/{ => outcomes}/eventoutcomes/dataoutcomes/GetDataEventOutcome.java (73%) rename src/main/java/com/netgrif/application/engine/workflow/domain/{ => outcomes}/eventoutcomes/dataoutcomes/GetDataGroupsEventOutcome.java (77%) rename src/main/java/com/netgrif/application/engine/workflow/domain/{ => outcomes}/eventoutcomes/dataoutcomes/SetDataEventOutcome.java (76%) rename src/main/java/com/netgrif/application/engine/workflow/domain/{ => outcomes}/eventoutcomes/petrinetoutcomes/ImportPetriNetEventOutcome.java (77%) rename src/main/java/com/netgrif/application/engine/workflow/domain/{ => outcomes}/eventoutcomes/petrinetoutcomes/PetriNetEventOutcome.java (81%) rename src/main/java/com/netgrif/application/engine/workflow/domain/{ => outcomes}/eventoutcomes/response/EventOutcomeWithMessage.java (84%) rename src/main/java/com/netgrif/application/engine/workflow/domain/{ => outcomes}/eventoutcomes/response/EventOutcomeWithMessageResource.java (80%) rename src/main/java/com/netgrif/application/engine/workflow/domain/{ => outcomes}/eventoutcomes/taskoutcomes/AssignTaskEventOutcome.java (75%) rename src/main/java/com/netgrif/application/engine/workflow/domain/{ => outcomes}/eventoutcomes/taskoutcomes/CancelTaskEventOutcome.java (75%) rename src/main/java/com/netgrif/application/engine/workflow/domain/{ => outcomes}/eventoutcomes/taskoutcomes/DelegateTaskEventOutcome.java (75%) rename src/main/java/com/netgrif/application/engine/workflow/domain/{ => outcomes}/eventoutcomes/taskoutcomes/FinishTaskEventOutcome.java (75%) rename src/main/java/com/netgrif/application/engine/workflow/domain/{ => outcomes}/eventoutcomes/taskoutcomes/TaskEventOutcome.java (74%) create mode 100644 src/main/java/com/netgrif/application/engine/workflow/domain/params/DeleteCaseParams.java diff --git a/src/main/groovy/com/netgrif/application/engine/migration/ActionMigration.groovy b/src/main/groovy/com/netgrif/application/engine/migration/ActionMigration.groovy index 20228cbce3d..fc8c34870ee 100644 --- a/src/main/groovy/com/netgrif/application/engine/migration/ActionMigration.groovy +++ b/src/main/groovy/com/netgrif/application/engine/migration/ActionMigration.groovy @@ -4,7 +4,7 @@ import com.netgrif.application.engine.auth.service.interfaces.IUserService import com.netgrif.application.engine.petrinet.domain.PetriNet import com.netgrif.application.engine.petrinet.domain.VersionType import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService -import com.netgrif.application.engine.workflow.domain.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome import groovy.util.logging.Slf4j import org.springframework.beans.factory.annotation.Autowired import org.springframework.core.io.ClassPathResource diff --git a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy index 3ae314fb488..c600a9c80a2 100644 --- a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy +++ b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy @@ -37,15 +37,16 @@ import com.netgrif.application.engine.startup.FilterRunner import com.netgrif.application.engine.transaction.NaeTransaction import com.netgrif.application.engine.utils.FullPageRequest import com.netgrif.application.engine.workflow.domain.* -import com.netgrif.application.engine.workflow.domain.eventoutcomes.EventOutcome -import com.netgrif.application.engine.workflow.domain.eventoutcomes.caseoutcomes.CreateCaseEventOutcome -import com.netgrif.application.engine.workflow.domain.eventoutcomes.dataoutcomes.GetDataEventOutcome -import com.netgrif.application.engine.workflow.domain.eventoutcomes.dataoutcomes.SetDataEventOutcome -import com.netgrif.application.engine.workflow.domain.eventoutcomes.taskoutcomes.AssignTaskEventOutcome -import com.netgrif.application.engine.workflow.domain.eventoutcomes.taskoutcomes.TaskEventOutcome +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.EventOutcome +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.caseoutcomes.CreateCaseEventOutcome +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.dataoutcomes.GetDataEventOutcome +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.dataoutcomes.SetDataEventOutcome +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.taskoutcomes.AssignTaskEventOutcome +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.taskoutcomes.TaskEventOutcome 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.service.FileFieldInputStream import com.netgrif.application.engine.workflow.service.TaskService import com.netgrif.application.engine.workflow.service.interfaces.* @@ -1519,7 +1520,10 @@ class ActionDelegate /*TODO: release/8.0.0: implements ActionAPI*/ { * @return */ def deleteFilter(Case filter) { - workflowService.deleteCase(filter.stringId) + DeleteCaseParams deleteCaseParams = DeleteCaseParams.builder() + .useCase(filter) + .build() + workflowService.deleteCase(deleteCaseParams) } /** @@ -1838,7 +1842,10 @@ class ActionDelegate /*TODO: release/8.0.0: implements ActionAPI*/ { */ def deleteMenuItem(Case item) { async.run { - workflowService.deleteCase(item.stringId) + DeleteCaseParams deleteCaseParams = DeleteCaseParams.builder() + .useCase(item) + .build() + workflowService.deleteCase(deleteCaseParams) } } diff --git a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionRunner.groovy b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionRunner.groovy index 0449d3aaddc..d69510f629f 100644 --- a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionRunner.groovy +++ b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionRunner.groovy @@ -5,7 +5,7 @@ import com.netgrif.application.engine.petrinet.domain.dataset.Field import com.netgrif.application.engine.transaction.NaeTransaction import com.netgrif.application.engine.workflow.domain.Case import com.netgrif.application.engine.workflow.domain.Task -import com.netgrif.application.engine.workflow.domain.eventoutcomes.EventOutcome +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.EventOutcome import com.netgrif.application.engine.workflow.service.interfaces.IFieldActionsCacheService import groovy.util.logging.Slf4j import org.springframework.beans.factory.annotation.Autowired diff --git a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/FrontendActionOutcome.groovy b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/FrontendActionOutcome.groovy index dc644ec4073..9ff4a063b1e 100644 --- a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/FrontendActionOutcome.groovy +++ b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/FrontendActionOutcome.groovy @@ -2,8 +2,8 @@ package com.netgrif.application.engine.petrinet.domain.dataset.logic.action import com.netgrif.application.engine.petrinet.domain.dataset.logic.FrontAction import com.netgrif.application.engine.workflow.domain.Case import com.netgrif.application.engine.workflow.domain.Task -import com.netgrif.application.engine.workflow.domain.eventoutcomes.EventOutcome -import com.netgrif.application.engine.workflow.domain.eventoutcomes.dataoutcomes.SetDataEventOutcome +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.EventOutcome +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.dataoutcomes.SetDataEventOutcome class FrontendActionOutcome { diff --git a/src/main/groovy/com/netgrif/application/engine/startup/ImportHelper.groovy b/src/main/groovy/com/netgrif/application/engine/startup/ImportHelper.groovy index f7718ad232b..b8b15f0985e 100644 --- a/src/main/groovy/com/netgrif/application/engine/startup/ImportHelper.groovy +++ b/src/main/groovy/com/netgrif/application/engine/startup/ImportHelper.groovy @@ -13,10 +13,10 @@ import com.netgrif.application.engine.petrinet.service.ProcessRoleService import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService import com.netgrif.application.engine.petrinet.service.interfaces.IUriService import com.netgrif.application.engine.workflow.domain.Case -import com.netgrif.application.engine.workflow.domain.eventoutcomes.dataoutcomes.SetDataEventOutcome -import com.netgrif.application.engine.workflow.domain.eventoutcomes.taskoutcomes.AssignTaskEventOutcome -import com.netgrif.application.engine.workflow.domain.eventoutcomes.taskoutcomes.CancelTaskEventOutcome -import com.netgrif.application.engine.workflow.domain.eventoutcomes.taskoutcomes.FinishTaskEventOutcome +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.dataoutcomes.SetDataEventOutcome +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.taskoutcomes.AssignTaskEventOutcome +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.repositories.CaseRepository import com.netgrif.application.engine.workflow.service.interfaces.IDataService diff --git a/src/main/java/com/netgrif/application/engine/orgstructure/groups/NextGroupService.java b/src/main/java/com/netgrif/application/engine/orgstructure/groups/NextGroupService.java index ba86d7689c1..9ef276a5882 100644 --- a/src/main/java/com/netgrif/application/engine/orgstructure/groups/NextGroupService.java +++ b/src/main/java/com/netgrif/application/engine/orgstructure/groups/NextGroupService.java @@ -11,7 +11,6 @@ import com.netgrif.application.engine.mail.interfaces.IMailService; import com.netgrif.application.engine.orgstructure.groups.interfaces.INextGroupService; import com.netgrif.application.engine.petrinet.domain.I18nString; -import com.netgrif.application.engine.petrinet.domain.PetriNet; import com.netgrif.application.engine.petrinet.domain.dataset.EnumerationMapField; import com.netgrif.application.engine.petrinet.domain.dataset.MapOptionsField; import com.netgrif.application.engine.petrinet.domain.throwable.TransitionNotExecutableException; @@ -20,7 +19,7 @@ import com.netgrif.application.engine.workflow.domain.Case; import com.netgrif.application.engine.workflow.domain.QCase; import com.netgrif.application.engine.workflow.domain.Task; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.caseoutcomes.CreateCaseEventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.caseoutcomes.CreateCaseEventOutcome; import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams; import com.netgrif.application.engine.workflow.service.interfaces.IDataService; import com.netgrif.application.engine.workflow.service.interfaces.ITaskService; diff --git a/src/main/java/com/netgrif/application/engine/orgstructure/groups/interfaces/INextGroupService.java b/src/main/java/com/netgrif/application/engine/orgstructure/groups/interfaces/INextGroupService.java index 448d79ba1dc..f31ef0030c7 100644 --- a/src/main/java/com/netgrif/application/engine/orgstructure/groups/interfaces/INextGroupService.java +++ b/src/main/java/com/netgrif/application/engine/orgstructure/groups/interfaces/INextGroupService.java @@ -3,7 +3,7 @@ import com.netgrif.application.engine.auth.domain.IUser; import com.netgrif.application.engine.petrinet.domain.I18nString; import com.netgrif.application.engine.workflow.domain.Case; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.caseoutcomes.CreateCaseEventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.caseoutcomes.CreateCaseEventOutcome; import com.querydsl.core.types.Predicate; import java.util.*; diff --git a/src/main/java/com/netgrif/application/engine/petrinet/domain/PetriNet.java b/src/main/java/com/netgrif/application/engine/petrinet/domain/PetriNet.java index 0c97c3c2668..92a71349192 100644 --- a/src/main/java/com/netgrif/application/engine/petrinet/domain/PetriNet.java +++ b/src/main/java/com/netgrif/application/engine/petrinet/domain/PetriNet.java @@ -390,6 +390,10 @@ public boolean hasDynamicCaseName() { return defaultCaseNameExpression != null; } + public boolean hasDefaultCaseName() { + return defaultCaseName != null; + } + @Override public String getStringId() { return id.toString(); diff --git a/src/main/java/com/netgrif/application/engine/petrinet/service/PetriNetService.java b/src/main/java/com/netgrif/application/engine/petrinet/service/PetriNetService.java index 3a064ebeb78..999f06be2b3 100644 --- a/src/main/java/com/netgrif/application/engine/petrinet/service/PetriNetService.java +++ b/src/main/java/com/netgrif/application/engine/petrinet/service/PetriNetService.java @@ -33,7 +33,7 @@ import com.netgrif.application.engine.rules.service.interfaces.IRuleEngine; import com.netgrif.application.engine.workflow.domain.Case; import com.netgrif.application.engine.workflow.domain.FileStorageConfiguration; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome; import com.netgrif.application.engine.workflow.service.interfaces.IEventService; import com.netgrif.application.engine.workflow.service.interfaces.IFieldActionsCacheService; import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowService; diff --git a/src/main/java/com/netgrif/application/engine/petrinet/service/interfaces/IPetriNetService.java b/src/main/java/com/netgrif/application/engine/petrinet/service/interfaces/IPetriNetService.java index 9f03b747219..1e2ca55b692 100644 --- a/src/main/java/com/netgrif/application/engine/petrinet/service/interfaces/IPetriNetService.java +++ b/src/main/java/com/netgrif/application/engine/petrinet/service/interfaces/IPetriNetService.java @@ -14,7 +14,7 @@ import com.netgrif.application.engine.petrinet.web.responsebodies.PetriNetImportReference; import com.netgrif.application.engine.petrinet.web.responsebodies.PetriNetReference; import com.netgrif.application.engine.petrinet.web.responsebodies.TransitionReference; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome; import org.bson.types.ObjectId; import org.springframework.core.io.FileSystemResource; import org.springframework.data.domain.Page; diff --git a/src/main/java/com/netgrif/application/engine/petrinet/web/PetriNetController.java b/src/main/java/com/netgrif/application/engine/petrinet/web/PetriNetController.java index 32435667252..80116c2cd5c 100644 --- a/src/main/java/com/netgrif/application/engine/petrinet/web/PetriNetController.java +++ b/src/main/java/com/netgrif/application/engine/petrinet/web/PetriNetController.java @@ -13,9 +13,9 @@ import com.netgrif.application.engine.petrinet.service.interfaces.IProcessRoleService; import com.netgrif.application.engine.petrinet.web.responsebodies.*; import com.netgrif.application.engine.workflow.domain.FileStorageConfiguration; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.response.EventOutcomeWithMessage; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.response.EventOutcomeWithMessageResource; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.response.EventOutcomeWithMessage; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.response.EventOutcomeWithMessageResource; import com.netgrif.application.engine.workflow.web.responsebodies.MessageResource; import io.swagger.v3.oas.annotations.Operation; import io.swagger.v3.oas.annotations.responses.ApiResponse; diff --git a/src/main/java/com/netgrif/application/engine/workflow/domain/IllegalArgumentWithChangedFieldsException.java b/src/main/java/com/netgrif/application/engine/workflow/domain/IllegalArgumentWithChangedFieldsException.java index 47d5a184d3b..c5d50e77698 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/domain/IllegalArgumentWithChangedFieldsException.java +++ b/src/main/java/com/netgrif/application/engine/workflow/domain/IllegalArgumentWithChangedFieldsException.java @@ -1,6 +1,6 @@ package com.netgrif.application.engine.workflow.domain; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.EventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.EventOutcome; import lombok.Getter; import lombok.Setter; diff --git a/src/main/java/com/netgrif/application/engine/workflow/domain/outcome/CreateTasksOutcome.java b/src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/CreateTasksOutcome.java similarity index 80% rename from src/main/java/com/netgrif/application/engine/workflow/domain/outcome/CreateTasksOutcome.java rename to src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/CreateTasksOutcome.java index 4f47d408f61..1a43a4a0db5 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/domain/outcome/CreateTasksOutcome.java +++ b/src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/CreateTasksOutcome.java @@ -1,4 +1,4 @@ -package com.netgrif.application.engine.workflow.domain.outcome; +package com.netgrif.application.engine.workflow.domain.outcomes; import com.netgrif.application.engine.workflow.domain.Task; import lombok.AllArgsConstructor; diff --git a/src/main/java/com/netgrif/application/engine/workflow/domain/eventoutcomes/EventOutcome.java b/src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/eventoutcomes/EventOutcome.java similarity index 94% rename from src/main/java/com/netgrif/application/engine/workflow/domain/eventoutcomes/EventOutcome.java rename to src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/eventoutcomes/EventOutcome.java index ba2310a190c..c97dd82e9e6 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/domain/eventoutcomes/EventOutcome.java +++ b/src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/eventoutcomes/EventOutcome.java @@ -1,4 +1,4 @@ -package com.netgrif.application.engine.workflow.domain.eventoutcomes; +package com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes; import com.netgrif.application.engine.petrinet.domain.I18nString; import com.netgrif.application.engine.petrinet.domain.dataset.logic.FrontAction; diff --git a/src/main/java/com/netgrif/application/engine/workflow/domain/eventoutcomes/caseoutcomes/CaseEventOutcome.java b/src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/eventoutcomes/caseoutcomes/CaseEventOutcome.java similarity index 77% rename from src/main/java/com/netgrif/application/engine/workflow/domain/eventoutcomes/caseoutcomes/CaseEventOutcome.java rename to src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/eventoutcomes/caseoutcomes/CaseEventOutcome.java index 485d46fa3f7..c9bf8f44ffd 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/domain/eventoutcomes/caseoutcomes/CaseEventOutcome.java +++ b/src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/eventoutcomes/caseoutcomes/CaseEventOutcome.java @@ -1,9 +1,9 @@ -package com.netgrif.application.engine.workflow.domain.eventoutcomes.caseoutcomes; +package com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.caseoutcomes; import com.netgrif.application.engine.petrinet.domain.I18nString; import com.netgrif.application.engine.workflow.domain.Case; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.EventOutcome; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.petrinetoutcomes.PetriNetEventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.EventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.petrinetoutcomes.PetriNetEventOutcome; import java.util.List; diff --git a/src/main/java/com/netgrif/application/engine/workflow/domain/eventoutcomes/caseoutcomes/CreateCaseEventOutcome.java b/src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/eventoutcomes/caseoutcomes/CreateCaseEventOutcome.java similarity index 79% rename from src/main/java/com/netgrif/application/engine/workflow/domain/eventoutcomes/caseoutcomes/CreateCaseEventOutcome.java rename to src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/eventoutcomes/caseoutcomes/CreateCaseEventOutcome.java index 972f9e4757d..ee83e5cddf2 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/domain/eventoutcomes/caseoutcomes/CreateCaseEventOutcome.java +++ b/src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/eventoutcomes/caseoutcomes/CreateCaseEventOutcome.java @@ -1,8 +1,8 @@ -package com.netgrif.application.engine.workflow.domain.eventoutcomes.caseoutcomes; +package com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.caseoutcomes; import com.netgrif.application.engine.petrinet.domain.I18nString; import com.netgrif.application.engine.workflow.domain.Case; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.EventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.EventOutcome; import java.util.List; diff --git a/src/main/java/com/netgrif/application/engine/workflow/domain/eventoutcomes/caseoutcomes/DeleteCaseEventOutcome.java b/src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/eventoutcomes/caseoutcomes/DeleteCaseEventOutcome.java similarity index 78% rename from src/main/java/com/netgrif/application/engine/workflow/domain/eventoutcomes/caseoutcomes/DeleteCaseEventOutcome.java rename to src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/eventoutcomes/caseoutcomes/DeleteCaseEventOutcome.java index 344b50a02b1..a7ed0c8b76f 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/domain/eventoutcomes/caseoutcomes/DeleteCaseEventOutcome.java +++ b/src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/eventoutcomes/caseoutcomes/DeleteCaseEventOutcome.java @@ -1,8 +1,8 @@ -package com.netgrif.application.engine.workflow.domain.eventoutcomes.caseoutcomes; +package com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.caseoutcomes; import com.netgrif.application.engine.petrinet.domain.I18nString; import com.netgrif.application.engine.workflow.domain.Case; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.EventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.EventOutcome; import lombok.Data; import java.util.List; diff --git a/src/main/java/com/netgrif/application/engine/workflow/domain/eventoutcomes/dataoutcomes/GetDataEventOutcome.java b/src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/eventoutcomes/dataoutcomes/GetDataEventOutcome.java similarity index 73% rename from src/main/java/com/netgrif/application/engine/workflow/domain/eventoutcomes/dataoutcomes/GetDataEventOutcome.java rename to src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/eventoutcomes/dataoutcomes/GetDataEventOutcome.java index 08d47545f7c..c5b42af440e 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/domain/eventoutcomes/dataoutcomes/GetDataEventOutcome.java +++ b/src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/eventoutcomes/dataoutcomes/GetDataEventOutcome.java @@ -1,11 +1,11 @@ -package com.netgrif.application.engine.workflow.domain.eventoutcomes.dataoutcomes; +package com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.dataoutcomes; import com.netgrif.application.engine.petrinet.domain.DataRef; import com.netgrif.application.engine.petrinet.domain.I18nString; import com.netgrif.application.engine.workflow.domain.Case; import com.netgrif.application.engine.workflow.domain.Task; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.EventOutcome; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.taskoutcomes.TaskEventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.EventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.taskoutcomes.TaskEventOutcome; import lombok.Data; import java.util.List; diff --git a/src/main/java/com/netgrif/application/engine/workflow/domain/eventoutcomes/dataoutcomes/GetDataGroupsEventOutcome.java b/src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/eventoutcomes/dataoutcomes/GetDataGroupsEventOutcome.java similarity index 77% rename from src/main/java/com/netgrif/application/engine/workflow/domain/eventoutcomes/dataoutcomes/GetDataGroupsEventOutcome.java rename to src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/eventoutcomes/dataoutcomes/GetDataGroupsEventOutcome.java index 896e04ebbc4..cdd958d106c 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/domain/eventoutcomes/dataoutcomes/GetDataGroupsEventOutcome.java +++ b/src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/eventoutcomes/dataoutcomes/GetDataGroupsEventOutcome.java @@ -1,11 +1,11 @@ -package com.netgrif.application.engine.workflow.domain.eventoutcomes.dataoutcomes; +package com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.dataoutcomes; import com.netgrif.application.engine.petrinet.domain.DataGroup; import com.netgrif.application.engine.petrinet.domain.I18nString; import com.netgrif.application.engine.workflow.domain.Case; import com.netgrif.application.engine.workflow.domain.Task; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.EventOutcome; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.taskoutcomes.TaskEventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.EventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.taskoutcomes.TaskEventOutcome; import lombok.Data; import java.util.List; diff --git a/src/main/java/com/netgrif/application/engine/workflow/domain/eventoutcomes/dataoutcomes/SetDataEventOutcome.java b/src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/eventoutcomes/dataoutcomes/SetDataEventOutcome.java similarity index 76% rename from src/main/java/com/netgrif/application/engine/workflow/domain/eventoutcomes/dataoutcomes/SetDataEventOutcome.java rename to src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/eventoutcomes/dataoutcomes/SetDataEventOutcome.java index f64439e90fe..77bdf255214 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/domain/eventoutcomes/dataoutcomes/SetDataEventOutcome.java +++ b/src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/eventoutcomes/dataoutcomes/SetDataEventOutcome.java @@ -1,10 +1,10 @@ -package com.netgrif.application.engine.workflow.domain.eventoutcomes.dataoutcomes; +package com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.dataoutcomes; import com.netgrif.application.engine.petrinet.domain.dataset.Field; import com.netgrif.application.engine.workflow.domain.Case; import com.netgrif.application.engine.workflow.domain.Task; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.EventOutcome; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.taskoutcomes.TaskEventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.EventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.taskoutcomes.TaskEventOutcome; import com.netgrif.application.engine.workflow.web.responsebodies.DataSet; import lombok.Data; diff --git a/src/main/java/com/netgrif/application/engine/workflow/domain/eventoutcomes/petrinetoutcomes/ImportPetriNetEventOutcome.java b/src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/eventoutcomes/petrinetoutcomes/ImportPetriNetEventOutcome.java similarity index 77% rename from src/main/java/com/netgrif/application/engine/workflow/domain/eventoutcomes/petrinetoutcomes/ImportPetriNetEventOutcome.java rename to src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/eventoutcomes/petrinetoutcomes/ImportPetriNetEventOutcome.java index a5e94680e3b..7a7230340df 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/domain/eventoutcomes/petrinetoutcomes/ImportPetriNetEventOutcome.java +++ b/src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/eventoutcomes/petrinetoutcomes/ImportPetriNetEventOutcome.java @@ -1,8 +1,8 @@ -package com.netgrif.application.engine.workflow.domain.eventoutcomes.petrinetoutcomes; +package com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.petrinetoutcomes; import com.netgrif.application.engine.petrinet.domain.I18nString; import com.netgrif.application.engine.petrinet.domain.PetriNet; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.EventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.EventOutcome; import lombok.Data; import java.util.List; diff --git a/src/main/java/com/netgrif/application/engine/workflow/domain/eventoutcomes/petrinetoutcomes/PetriNetEventOutcome.java b/src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/eventoutcomes/petrinetoutcomes/PetriNetEventOutcome.java similarity index 81% rename from src/main/java/com/netgrif/application/engine/workflow/domain/eventoutcomes/petrinetoutcomes/PetriNetEventOutcome.java rename to src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/eventoutcomes/petrinetoutcomes/PetriNetEventOutcome.java index 135a0a2367d..566d0a54a72 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/domain/eventoutcomes/petrinetoutcomes/PetriNetEventOutcome.java +++ b/src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/eventoutcomes/petrinetoutcomes/PetriNetEventOutcome.java @@ -1,8 +1,8 @@ -package com.netgrif.application.engine.workflow.domain.eventoutcomes.petrinetoutcomes; +package com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.petrinetoutcomes; import com.netgrif.application.engine.petrinet.domain.I18nString; import com.netgrif.application.engine.petrinet.domain.PetriNet; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.EventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.EventOutcome; import lombok.Data; import java.util.List; diff --git a/src/main/java/com/netgrif/application/engine/workflow/domain/eventoutcomes/response/EventOutcomeWithMessage.java b/src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/eventoutcomes/response/EventOutcomeWithMessage.java similarity index 84% rename from src/main/java/com/netgrif/application/engine/workflow/domain/eventoutcomes/response/EventOutcomeWithMessage.java rename to src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/eventoutcomes/response/EventOutcomeWithMessage.java index 95e602ab640..046f9ec272d 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/domain/eventoutcomes/response/EventOutcomeWithMessage.java +++ b/src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/eventoutcomes/response/EventOutcomeWithMessage.java @@ -1,6 +1,6 @@ -package com.netgrif.application.engine.workflow.domain.eventoutcomes.response; +package com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.response; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.EventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.EventOutcome; import com.netgrif.application.engine.workflow.web.responsebodies.ResponseMessage; import lombok.Data; diff --git a/src/main/java/com/netgrif/application/engine/workflow/domain/eventoutcomes/response/EventOutcomeWithMessageResource.java b/src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/eventoutcomes/response/EventOutcomeWithMessageResource.java similarity index 80% rename from src/main/java/com/netgrif/application/engine/workflow/domain/eventoutcomes/response/EventOutcomeWithMessageResource.java rename to src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/eventoutcomes/response/EventOutcomeWithMessageResource.java index ab740543f6f..4e392cc21ef 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/domain/eventoutcomes/response/EventOutcomeWithMessageResource.java +++ b/src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/eventoutcomes/response/EventOutcomeWithMessageResource.java @@ -1,6 +1,6 @@ -package com.netgrif.application.engine.workflow.domain.eventoutcomes.response; +package com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.response; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.EventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.EventOutcome; import org.springframework.hateoas.EntityModel; diff --git a/src/main/java/com/netgrif/application/engine/workflow/domain/eventoutcomes/taskoutcomes/AssignTaskEventOutcome.java b/src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/eventoutcomes/taskoutcomes/AssignTaskEventOutcome.java similarity index 75% rename from src/main/java/com/netgrif/application/engine/workflow/domain/eventoutcomes/taskoutcomes/AssignTaskEventOutcome.java rename to src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/eventoutcomes/taskoutcomes/AssignTaskEventOutcome.java index 03e403ec311..feaa3f26d54 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/domain/eventoutcomes/taskoutcomes/AssignTaskEventOutcome.java +++ b/src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/eventoutcomes/taskoutcomes/AssignTaskEventOutcome.java @@ -1,8 +1,8 @@ -package com.netgrif.application.engine.workflow.domain.eventoutcomes.taskoutcomes; +package com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.taskoutcomes; import com.netgrif.application.engine.workflow.domain.Case; import com.netgrif.application.engine.workflow.domain.Task; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.EventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.EventOutcome; import lombok.Data; import java.util.List; diff --git a/src/main/java/com/netgrif/application/engine/workflow/domain/eventoutcomes/taskoutcomes/CancelTaskEventOutcome.java b/src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/eventoutcomes/taskoutcomes/CancelTaskEventOutcome.java similarity index 75% rename from src/main/java/com/netgrif/application/engine/workflow/domain/eventoutcomes/taskoutcomes/CancelTaskEventOutcome.java rename to src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/eventoutcomes/taskoutcomes/CancelTaskEventOutcome.java index 022f901a20a..52862b1dd9a 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/domain/eventoutcomes/taskoutcomes/CancelTaskEventOutcome.java +++ b/src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/eventoutcomes/taskoutcomes/CancelTaskEventOutcome.java @@ -1,8 +1,8 @@ -package com.netgrif.application.engine.workflow.domain.eventoutcomes.taskoutcomes; +package com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.taskoutcomes; import com.netgrif.application.engine.workflow.domain.Case; import com.netgrif.application.engine.workflow.domain.Task; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.EventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.EventOutcome; import lombok.Data; import java.util.List; diff --git a/src/main/java/com/netgrif/application/engine/workflow/domain/eventoutcomes/taskoutcomes/DelegateTaskEventOutcome.java b/src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/eventoutcomes/taskoutcomes/DelegateTaskEventOutcome.java similarity index 75% rename from src/main/java/com/netgrif/application/engine/workflow/domain/eventoutcomes/taskoutcomes/DelegateTaskEventOutcome.java rename to src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/eventoutcomes/taskoutcomes/DelegateTaskEventOutcome.java index fbecc39e2d0..87a97589508 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/domain/eventoutcomes/taskoutcomes/DelegateTaskEventOutcome.java +++ b/src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/eventoutcomes/taskoutcomes/DelegateTaskEventOutcome.java @@ -1,8 +1,8 @@ -package com.netgrif.application.engine.workflow.domain.eventoutcomes.taskoutcomes; +package com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.taskoutcomes; import com.netgrif.application.engine.workflow.domain.Case; import com.netgrif.application.engine.workflow.domain.Task; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.EventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.EventOutcome; import lombok.Data; import java.util.List; diff --git a/src/main/java/com/netgrif/application/engine/workflow/domain/eventoutcomes/taskoutcomes/FinishTaskEventOutcome.java b/src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/eventoutcomes/taskoutcomes/FinishTaskEventOutcome.java similarity index 75% rename from src/main/java/com/netgrif/application/engine/workflow/domain/eventoutcomes/taskoutcomes/FinishTaskEventOutcome.java rename to src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/eventoutcomes/taskoutcomes/FinishTaskEventOutcome.java index 9fd45065606..f3f2725fbf7 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/domain/eventoutcomes/taskoutcomes/FinishTaskEventOutcome.java +++ b/src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/eventoutcomes/taskoutcomes/FinishTaskEventOutcome.java @@ -1,8 +1,8 @@ -package com.netgrif.application.engine.workflow.domain.eventoutcomes.taskoutcomes; +package com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.taskoutcomes; import com.netgrif.application.engine.workflow.domain.Case; import com.netgrif.application.engine.workflow.domain.Task; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.EventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.EventOutcome; import lombok.Data; import java.util.List; diff --git a/src/main/java/com/netgrif/application/engine/workflow/domain/eventoutcomes/taskoutcomes/TaskEventOutcome.java b/src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/eventoutcomes/taskoutcomes/TaskEventOutcome.java similarity index 74% rename from src/main/java/com/netgrif/application/engine/workflow/domain/eventoutcomes/taskoutcomes/TaskEventOutcome.java rename to src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/eventoutcomes/taskoutcomes/TaskEventOutcome.java index 2c605138fdc..9228da6e699 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/domain/eventoutcomes/taskoutcomes/TaskEventOutcome.java +++ b/src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/eventoutcomes/taskoutcomes/TaskEventOutcome.java @@ -1,10 +1,10 @@ -package com.netgrif.application.engine.workflow.domain.eventoutcomes.taskoutcomes; +package com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.taskoutcomes; import com.netgrif.application.engine.petrinet.domain.I18nString; import com.netgrif.application.engine.workflow.domain.Case; import com.netgrif.application.engine.workflow.domain.Task; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.EventOutcome; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.caseoutcomes.CaseEventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.EventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.caseoutcomes.CaseEventOutcome; import lombok.Data; import lombok.Getter; diff --git a/src/main/java/com/netgrif/application/engine/workflow/domain/params/DeleteCaseParams.java b/src/main/java/com/netgrif/application/engine/workflow/domain/params/DeleteCaseParams.java new file mode 100644 index 00000000000..7e7bc3d756d --- /dev/null +++ b/src/main/java/com/netgrif/application/engine/workflow/domain/params/DeleteCaseParams.java @@ -0,0 +1,52 @@ +package com.netgrif.application.engine.workflow.domain.params; + +import com.netgrif.application.engine.workflow.domain.Case; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; + +import java.util.HashMap; +import java.util.Map; + +/** + * todo javadoc + * */ +@Data +@Builder +@AllArgsConstructor +public class DeleteCaseParams { + + private String useCaseId; + private Case useCase; + @Builder.Default + private Map<String, String> params = new HashMap<>(); + + public DeleteCaseParams(Case useCase) { + this.useCase = useCase; + if (useCase != null) { + this.useCaseId = useCase.getStringId(); + } + } + + public DeleteCaseParams(String useCaseId) { + this.useCaseId = useCaseId; + } + + /** + * todo javadoc + * Builder extension of the {@link Builder} implementation for {@link }. Containing additional logic over the native builder + * implementation + * */ + public static class DeleteCaseParamsBuilder { + /** + * todo javadoc + * */ + public DeleteCaseParams.DeleteCaseParamsBuilder useCase(Case useCase) { + this.useCase = useCase; + if (useCase != null) { + this.useCaseId = useCase.getStringId(); + } + return this; + } + } +} diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/DataService.java b/src/main/java/com/netgrif/application/engine/workflow/service/DataService.java index b988423c2c0..930880efd0e 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/DataService.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/DataService.java @@ -23,11 +23,11 @@ import com.netgrif.application.engine.workflow.domain.DataFieldBehavior; import com.netgrif.application.engine.workflow.domain.EventNotExecutableException; import com.netgrif.application.engine.workflow.domain.Task; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.EventOutcome; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.dataoutcomes.GetDataEventOutcome; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.dataoutcomes.GetDataGroupsEventOutcome; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.dataoutcomes.SetDataEventOutcome; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.taskoutcomes.TaskEventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.EventOutcome; +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.outcomes.eventoutcomes.taskoutcomes.TaskEventOutcome; 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; diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/EventService.java b/src/main/java/com/netgrif/application/engine/workflow/service/EventService.java index 8c5e7de5eff..9527d320c23 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/EventService.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/EventService.java @@ -9,8 +9,8 @@ import com.netgrif.application.engine.petrinet.domain.events.EventPhase; import com.netgrif.application.engine.workflow.domain.Case; import com.netgrif.application.engine.workflow.domain.Task; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.EventOutcome; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.dataoutcomes.SetDataEventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.EventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.dataoutcomes.SetDataEventOutcome; import com.netgrif.application.engine.workflow.service.interfaces.IEventService; import lombok.extern.slf4j.Slf4j; import org.springframework.context.annotation.Lazy; diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/TaskService.java b/src/main/java/com/netgrif/application/engine/workflow/service/TaskService.java index 97ac8606552..0cc2c4b0ef0 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/TaskService.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/TaskService.java @@ -29,12 +29,11 @@ import com.netgrif.application.engine.rules.service.interfaces.IRuleEngine; import com.netgrif.application.engine.utils.DateUtils; import com.netgrif.application.engine.utils.FullPageRequest; -import com.netgrif.application.engine.validation.service.interfaces.IValidationService; import com.netgrif.application.engine.workflow.domain.*; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.EventOutcome; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.dataoutcomes.SetDataEventOutcome; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.taskoutcomes.*; -import com.netgrif.application.engine.workflow.domain.outcome.CreateTasksOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.EventOutcome; +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.repositories.TaskRepository; import com.netgrif.application.engine.workflow.domain.triggers.AutoTrigger; import com.netgrif.application.engine.workflow.domain.triggers.TimeTrigger; @@ -48,7 +47,6 @@ import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Qualifier; -import org.springframework.context.ApplicationEventPublisher; import org.springframework.data.domain.Page; import org.springframework.data.domain.PageImpl; import org.springframework.data.domain.PageRequest; @@ -70,41 +68,35 @@ public class TaskService implements ITaskService { @Autowired - protected ApplicationEventPublisher publisher; + private TaskRepository taskRepository; @Autowired - protected TaskRepository taskRepository; + private IUserService userService; @Autowired - protected IUserService userService; + private MongoTemplate mongoTemplate; @Autowired - protected MongoTemplate mongoTemplate; - - @Autowired - protected TaskSearchService searchService; + private TaskSearchService searchService; @Autowired @Qualifier("taskScheduler") - protected TaskScheduler scheduler; - - @Autowired - protected IWorkflowService workflowService; + private TaskScheduler scheduler; @Autowired - protected IDataService dataService; + private IWorkflowService workflowService; @Autowired - protected IProcessRoleService processRoleService; + private IDataService dataService; @Autowired - protected IEventService eventService; + private IProcessRoleService processRoleService; @Autowired - protected IHistoryService historyService; + private IEventService eventService; @Autowired - protected IValidationService validation; + private IHistoryService historyService; @Autowired private IRuleEngine ruleEngine; diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/WorkflowService.java b/src/main/java/com/netgrif/application/engine/workflow/service/WorkflowService.java index e3a17ef7a20..f0d6ee94067 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/WorkflowService.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/WorkflowService.java @@ -1,6 +1,7 @@ package com.netgrif.application.engine.workflow.service; import com.google.common.collect.Ordering; +import com.netgrif.application.engine.auth.domain.IUser; import com.netgrif.application.engine.auth.domain.LoggedUser; import com.netgrif.application.engine.auth.service.interfaces.IUserService; import com.netgrif.application.engine.elastic.service.interfaces.IElasticCaseService; @@ -22,10 +23,11 @@ import com.netgrif.application.engine.workflow.domain.Case; import com.netgrif.application.engine.workflow.domain.DataFieldValue; import com.netgrif.application.engine.workflow.domain.Task; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.EventOutcome; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.caseoutcomes.CreateCaseEventOutcome; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.caseoutcomes.DeleteCaseEventOutcome; -import com.netgrif.application.engine.workflow.domain.outcome.CreateTasksOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.EventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.caseoutcomes.CreateCaseEventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.caseoutcomes.DeleteCaseEventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.CreateTasksOutcome; +import com.netgrif.application.engine.workflow.domain.params.DeleteCaseParams; import com.netgrif.application.engine.workflow.domain.repositories.CaseRepository; import com.netgrif.application.engine.workflow.service.initializer.DataSetInitializer; import com.netgrif.application.engine.workflow.service.interfaces.IEventService; @@ -278,29 +280,33 @@ private void fillMissingAttributes(CreateCaseParams createCaseParams) throws Ill if (createCaseParams.getLoggedUser() == null) { throw new IllegalArgumentException("Logged user cannot be null on Case creation."); } - if (createCaseParams.getMakeTitle() == null && createCaseParams.getPetriNetId() != null) { - createCaseParams.setMakeTitle(resolveDefaultCaseTitle(createCaseParams)); - } if (createCaseParams.getPetriNet() == null) { - PetriNet petriNet = null; + PetriNet petriNet; if (createCaseParams.getPetriNetId() != null) { petriNet = petriNetService.get(new ObjectId(createCaseParams.getPetriNetId())).clone(); } else if (createCaseParams.getPetriNetIdentifier() != null) { petriNet = petriNetService.getNewestVersionByIdentifier(createCaseParams.getPetriNetIdentifier()).clone(); + } else { + throw new IllegalArgumentException("Could not find the PetriNet for the Case from provided inputs on case creation."); } createCaseParams.setPetriNet(petriNet); } + if (createCaseParams.getMakeTitle() == null && createCaseParams.getPetriNet() != null) { + createCaseParams.setMakeTitle(resolveDefaultCaseTitle(createCaseParams)); + } } private Function<Case, String> resolveDefaultCaseTitle(CreateCaseParams createCaseParams) { Locale locale = createCaseParams.getLocale(); - PetriNet petriNet = petriNetService.clone(new ObjectId(createCaseParams.getPetriNetId())); + PetriNet petriNet = createCaseParams.getPetriNet(); Function<Case, String> makeTitle; if (petriNet.hasDynamicCaseName()) { makeTitle = (u) -> initValueExpressionEvaluator.evaluateCaseName(u, petriNet.getDefaultCaseNameExpression(), createCaseParams.getParams()).getTranslation(locale); - } else { + } else if (petriNet.hasDefaultCaseName()) { makeTitle = (u) -> petriNet.getDefaultCaseName().getTranslation(locale); + } else { + makeTitle = (u) -> null; } return makeTitle; } @@ -316,67 +322,91 @@ public Page<Case> findAllByAuthor(String authorId, String petriNet, Pageable pag return new PageImpl<>(cases, pageable, mongoTemplate.count(new BasicQuery(queryString, "{id:1}"), Case.class)); } + /** + * todo javadoc + * */ @Override - public DeleteCaseEventOutcome deleteCase(String caseId) { - return deleteCase(caseId, new HashMap<>()); - } + @Transactional + public DeleteCaseEventOutcome deleteCase(DeleteCaseParams deleteCaseParams) { + fillMissingAttributes(deleteCaseParams); - @Override - public DeleteCaseEventOutcome deleteCase(String caseId, Map<String, String> params) { - Case useCase = findOne(caseId); - return deleteCase(useCase, params); - } + Case useCase = deleteCaseParams.getUseCase(); + + List<EventOutcome> preEventOutcomes = eventService.runActions(useCase.getPetriNet().getPreDeleteActions(), + useCase, Optional.empty(), deleteCaseParams.getParams()); - @Override - public DeleteCaseEventOutcome deleteCase(Case useCase, Map<String, String> params) { - DeleteCaseEventOutcome outcome = new DeleteCaseEventOutcome(useCase, eventService.runActions(useCase.getPetriNet().getPreDeleteActions(), useCase, Optional.empty(), params)); historyService.save(new DeleteCaseEventLog(useCase, EventPhase.PRE)); - log.info("[{}]: User [{}] is deleting case {}", useCase.getStringId(), userService.getLoggedOrSystem().getStringId(), useCase.getTitle()); + + log.info("[{}]: User [{}] is deleting case {}", useCase.getStringId(), userService.getLoggedOrSystem().getStringId(), + useCase.getTitle()); taskService.deleteTasksByCase(useCase.getStringId()); repository.delete(useCase); - outcome.addOutcomes(eventService.runActions(useCase.getPetriNet().getPostDeleteActions(), null, Optional.empty(), params)); + DeleteCaseEventOutcome outcome = new DeleteCaseEventOutcome(useCase, preEventOutcomes); + outcome.addOutcomes(eventService.runActions(useCase.getPetriNet().getPostDeleteActions(), null, + Optional.empty(), deleteCaseParams.getParams())); addMessageToOutcome(useCase.getPetriNet(), CaseEventType.DELETE, outcome); + historyService.save(new DeleteCaseEventLog(useCase, EventPhase.POST)); + return outcome; } - @Override - public DeleteCaseEventOutcome deleteCase(Case useCase) { - return deleteCase(useCase, new HashMap<>()); + /** + * todo javadoc + * */ + private void fillMissingAttributes(DeleteCaseParams deleteCaseParams) throws IllegalArgumentException { + if (deleteCaseParams.getUseCase() == null) { + if (deleteCaseParams.getUseCaseId() != null) { + deleteCaseParams.setUseCase(findOne(deleteCaseParams.getUseCaseId())); + } else { + throw new IllegalArgumentException("At least case id must be provided on case removal."); + } + } } @Override + @Transactional public void deleteInstancesOfPetriNet(PetriNet net) { - log.info("[{}]: User {} is deleting all cases and tasks of Petri net {} version {}", net.getStringId(), userService.getLoggedOrSystem().getStringId(), net.getIdentifier(), net.getVersion().toString()); + final IUser user = userService.getLoggedOrSystem(); + final LoggedUser loggedUser = user.transformToLoggedUser(); + + log.info("[{}]: User {} is deleting all cases and tasks of Petri net {} version {}", net.getStringId(), + user.getStringId(), net.getIdentifier(), net.getVersion().toString()); taskService.deleteTasksByPetriNetId(net.getStringId()); + CaseSearchRequest request = new CaseSearchRequest(); CaseSearchRequest.PetriNet netRequest = new CaseSearchRequest.PetriNet(); netRequest.processId = net.getStringId(); request.process = Collections.singletonList(netRequest); - long countCases = elasticCaseService.count(Collections.singletonList(request), userService.getLoggedOrSystem().transformToLoggedUser(), Locale.getDefault(), false); - log.info("[{}]: User {} is deleting {} cases of Petri net {} version {}", net.getStringId(), userService.getLoggedOrSystem().getStringId(), countCases, net.getIdentifier(), net.getVersion().toString()); + long countCases = elasticCaseService.count(Collections.singletonList(request), loggedUser, Locale.getDefault(), false); + + log.info("[{}]: User {} is deleting {} cases of Petri net {} version {}", net.getStringId(), user.getStringId(), + countCases, net.getIdentifier(), net.getVersion().toString()); + long pageCount = (countCases / 100) + 1; LongStream.range(0, pageCount) .forEach(i -> elasticCaseService.search( Collections.singletonList(request), - userService.getLoggedOrSystem().transformToLoggedUser(), + loggedUser, PageRequest.of((int) i, 100), Locale.getDefault(), false) .getContent() - .forEach(this::deleteCase)); + .forEach(useCase -> deleteCase(new DeleteCaseParams(useCase)))); } @Override + @Transactional public DeleteCaseEventOutcome deleteSubtreeRootedAt(String subtreeRootCaseId) { Case subtreeRoot = findOne(subtreeRootCaseId); if (subtreeRoot.getImmediateDataFields().contains("treeChildCases")) { ((List<String>) subtreeRoot.getDataSet().get("treeChildCases").getValue()).forEach(this::deleteSubtreeRootedAt); } - return deleteCase(subtreeRootCaseId); + + return deleteCase(new DeleteCaseParams(subtreeRoot)); } @Override diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/interfaces/IDataService.java b/src/main/java/com/netgrif/application/engine/workflow/service/interfaces/IDataService.java index cee726046fb..8236b0e6457 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/interfaces/IDataService.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/interfaces/IDataService.java @@ -8,9 +8,9 @@ import com.netgrif.application.engine.petrinet.domain.dataset.UserFieldValue; import com.netgrif.application.engine.workflow.domain.Case; import com.netgrif.application.engine.workflow.domain.Task; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.dataoutcomes.GetDataEventOutcome; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.dataoutcomes.GetDataGroupsEventOutcome; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.dataoutcomes.SetDataEventOutcome; +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.service.FileFieldInputStream; import com.netgrif.application.engine.workflow.web.responsebodies.DataSet; import org.springframework.data.domain.Page; diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/interfaces/IEventService.java b/src/main/java/com/netgrif/application/engine/workflow/service/interfaces/IEventService.java index dbdc45649f4..054371eeb55 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/interfaces/IEventService.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/interfaces/IEventService.java @@ -7,8 +7,8 @@ import com.netgrif.application.engine.petrinet.domain.events.EventPhase; import com.netgrif.application.engine.workflow.domain.Case; import com.netgrif.application.engine.workflow.domain.Task; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.EventOutcome; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.dataoutcomes.SetDataEventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.EventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.dataoutcomes.SetDataEventOutcome; import java.util.List; import java.util.Map; diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/interfaces/ITaskService.java b/src/main/java/com/netgrif/application/engine/workflow/service/interfaces/ITaskService.java index 135c3a6c3e3..685d1dade0e 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/interfaces/ITaskService.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/interfaces/ITaskService.java @@ -6,13 +6,13 @@ import com.netgrif.application.engine.workflow.domain.Case; import com.netgrif.application.engine.workflow.domain.Task; import com.netgrif.application.engine.workflow.domain.TaskNotFoundException; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.EventOutcome; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.dataoutcomes.SetDataEventOutcome; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.taskoutcomes.AssignTaskEventOutcome; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.taskoutcomes.CancelTaskEventOutcome; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.taskoutcomes.DelegateTaskEventOutcome; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.taskoutcomes.FinishTaskEventOutcome; -import com.netgrif.application.engine.workflow.domain.outcome.CreateTasksOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.EventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.dataoutcomes.SetDataEventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.taskoutcomes.AssignTaskEventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.taskoutcomes.CancelTaskEventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.taskoutcomes.DelegateTaskEventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.taskoutcomes.FinishTaskEventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.CreateTasksOutcome; import com.netgrif.application.engine.workflow.web.requestbodies.TaskSearchRequest; import com.netgrif.application.engine.workflow.web.responsebodies.TaskReference; import org.springframework.data.domain.Page; diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/interfaces/IWorkflowService.java b/src/main/java/com/netgrif/application/engine/workflow/service/interfaces/IWorkflowService.java index 44de825f231..47a8b63f241 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/interfaces/IWorkflowService.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/interfaces/IWorkflowService.java @@ -4,9 +4,10 @@ import com.netgrif.application.engine.petrinet.domain.PetriNet; import com.netgrif.application.engine.workflow.domain.Case; import com.netgrif.application.engine.workflow.domain.Task; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.caseoutcomes.CreateCaseEventOutcome; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.caseoutcomes.DeleteCaseEventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.caseoutcomes.CreateCaseEventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.caseoutcomes.DeleteCaseEventOutcome; import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams; +import com.netgrif.application.engine.workflow.domain.params.DeleteCaseParams; import com.querydsl.core.types.Predicate; import org.springframework.data.domain.Page; import org.springframework.data.domain.Pageable; @@ -26,22 +27,16 @@ public interface IWorkflowService { Page<Case> getAll(Pageable pageable); + Page<Case> findAllByAuthor(String authorId, String petriNet, Pageable pageable); + Case resolveUserRef(Case useCase); CreateCaseEventOutcome createCase(CreateCaseParams createCaseParams); - Page<Case> findAllByAuthor(String authorId, String petriNet, Pageable pageable); - - DeleteCaseEventOutcome deleteCase(String caseId, Map<String, String> params); - - DeleteCaseEventOutcome deleteCase(String caseId); + DeleteCaseEventOutcome deleteCase(DeleteCaseParams deleteCaseParams); DeleteCaseEventOutcome deleteSubtreeRootedAt(String caseId); - DeleteCaseEventOutcome deleteCase(Case useCase, Map<String, String> params); - - DeleteCaseEventOutcome deleteCase(Case useCase); - void deleteInstancesOfPetriNet(PetriNet net); void updateMarking(Case useCase); diff --git a/src/main/java/com/netgrif/application/engine/workflow/web/AbstractTaskController.java b/src/main/java/com/netgrif/application/engine/workflow/web/AbstractTaskController.java index bdbb309c038..a719a0402d4 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/web/AbstractTaskController.java +++ b/src/main/java/com/netgrif/application/engine/workflow/web/AbstractTaskController.java @@ -7,10 +7,10 @@ import com.netgrif.application.engine.workflow.domain.IllegalArgumentWithChangedFieldsException; import com.netgrif.application.engine.workflow.domain.MergeFilterOperation; import com.netgrif.application.engine.workflow.domain.Task; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.dataoutcomes.GetDataGroupsEventOutcome; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.dataoutcomes.SetDataEventOutcome; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.response.EventOutcomeWithMessage; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.response.EventOutcomeWithMessageResource; +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.response.EventOutcomeWithMessage; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.response.EventOutcomeWithMessageResource; import com.netgrif.application.engine.workflow.service.FileFieldInputStream; import com.netgrif.application.engine.workflow.service.interfaces.IDataService; import com.netgrif.application.engine.workflow.service.interfaces.ITaskService; diff --git a/src/main/java/com/netgrif/application/engine/workflow/web/PublicTaskController.java b/src/main/java/com/netgrif/application/engine/workflow/web/PublicTaskController.java index 724f7c9302c..61e73dda53a 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/web/PublicTaskController.java +++ b/src/main/java/com/netgrif/application/engine/workflow/web/PublicTaskController.java @@ -3,7 +3,7 @@ import com.netgrif.application.engine.auth.domain.LoggedUser; import com.netgrif.application.engine.auth.service.interfaces.IUserService; import com.netgrif.application.engine.workflow.domain.MergeFilterOperation; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.response.EventOutcomeWithMessage; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.response.EventOutcomeWithMessage; import com.netgrif.application.engine.workflow.service.interfaces.IDataService; import com.netgrif.application.engine.workflow.service.interfaces.ITaskService; import com.netgrif.application.engine.workflow.web.requestbodies.file.FileFieldRequest; diff --git a/src/main/java/com/netgrif/application/engine/workflow/web/PublicWorkflowController.java b/src/main/java/com/netgrif/application/engine/workflow/web/PublicWorkflowController.java index bc60019e7a2..6d9a16fff0f 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/web/PublicWorkflowController.java +++ b/src/main/java/com/netgrif/application/engine/workflow/web/PublicWorkflowController.java @@ -2,9 +2,9 @@ import com.netgrif.application.engine.auth.domain.LoggedUser; import com.netgrif.application.engine.auth.service.interfaces.IUserService; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.caseoutcomes.CreateCaseEventOutcome; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.response.EventOutcomeWithMessage; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.response.EventOutcomeWithMessageResource; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.caseoutcomes.CreateCaseEventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.response.EventOutcomeWithMessage; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.response.EventOutcomeWithMessageResource; import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams; import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowService; import com.netgrif.application.engine.workflow.web.requestbodies.CreateCaseBody; diff --git a/src/main/java/com/netgrif/application/engine/workflow/web/TaskController.java b/src/main/java/com/netgrif/application/engine/workflow/web/TaskController.java index 2713d655813..1abe294dfce 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/web/TaskController.java +++ b/src/main/java/com/netgrif/application/engine/workflow/web/TaskController.java @@ -5,7 +5,7 @@ import com.netgrif.application.engine.elastic.web.requestbodies.singleaslist.SingleElasticTaskSearchRequestAsList; import com.netgrif.application.engine.workflow.domain.MergeFilterOperation; import com.netgrif.application.engine.workflow.domain.Task; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.response.EventOutcomeWithMessage; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.response.EventOutcomeWithMessage; import com.netgrif.application.engine.workflow.service.interfaces.IDataService; import com.netgrif.application.engine.workflow.service.interfaces.ITaskService; import com.netgrif.application.engine.workflow.web.requestbodies.file.FileFieldRequest; diff --git a/src/main/java/com/netgrif/application/engine/workflow/web/WorkflowController.java b/src/main/java/com/netgrif/application/engine/workflow/web/WorkflowController.java index 687fab75369..dd4f74860c1 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/web/WorkflowController.java +++ b/src/main/java/com/netgrif/application/engine/workflow/web/WorkflowController.java @@ -6,11 +6,12 @@ import com.netgrif.application.engine.elastic.web.requestbodies.singleaslist.SingleCaseSearchRequestAsList; import com.netgrif.application.engine.workflow.domain.Case; import com.netgrif.application.engine.workflow.domain.MergeFilterOperation; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.caseoutcomes.CreateCaseEventOutcome; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.caseoutcomes.DeleteCaseEventOutcome; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.response.EventOutcomeWithMessage; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.response.EventOutcomeWithMessageResource; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.caseoutcomes.CreateCaseEventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.caseoutcomes.DeleteCaseEventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.response.EventOutcomeWithMessage; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.response.EventOutcomeWithMessageResource; import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams; +import com.netgrif.application.engine.workflow.domain.params.DeleteCaseParams; import com.netgrif.application.engine.workflow.service.FileFieldInputStream; import com.netgrif.application.engine.workflow.service.interfaces.IDataService; import com.netgrif.application.engine.workflow.service.interfaces.ITaskService; @@ -187,7 +188,7 @@ public EntityModel<EventOutcomeWithMessage> deleteCase(Authentication auth, @Pat if (deleteSubtree) { outcome = workflowService.deleteSubtreeRootedAt(caseId); } else { - outcome = workflowService.deleteCase(caseId); + outcome = workflowService.deleteCase(new DeleteCaseParams(caseId)); } return EventOutcomeWithMessageResource.successMessage("Case " + caseId + " was deleted", outcome); } diff --git a/src/test/groovy/com/netgrif/application/engine/action/AssignRemoveTest.groovy b/src/test/groovy/com/netgrif/application/engine/action/AssignRemoveTest.groovy index 800ec81addf..3400ae4841e 100644 --- a/src/test/groovy/com/netgrif/application/engine/action/AssignRemoveTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/action/AssignRemoveTest.groovy @@ -8,8 +8,9 @@ import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetServi import com.netgrif.application.engine.startup.ImportHelper import com.netgrif.application.engine.startup.SuperCreator import com.netgrif.application.engine.workflow.domain.Case -import com.netgrif.application.engine.workflow.domain.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome 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.repositories.CaseRepository import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowService import groovy.transform.CompileStatic @@ -83,7 +84,10 @@ class AssignRemoveTest { assert userService.system.processRoles.size() == roleCount + 4 // delete - workflowService.deleteCase(caze.stringId) + DeleteCaseParams deleteCaseParams = DeleteCaseParams.builder() + .useCase(caze) + .build() + workflowService.deleteCase(deleteCaseParams) assert userService.system.processRoles.size() == roleCount } } diff --git a/src/test/groovy/com/netgrif/application/engine/action/MenuItemApiTest.groovy b/src/test/groovy/com/netgrif/application/engine/action/MenuItemApiTest.groovy index 3be69d0475e..0ce465a0026 100644 --- a/src/test/groovy/com/netgrif/application/engine/action/MenuItemApiTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/action/MenuItemApiTest.groovy @@ -17,6 +17,7 @@ import com.netgrif.application.engine.startup.SuperCreator import com.netgrif.application.engine.workflow.domain.Case import com.netgrif.application.engine.workflow.domain.QCase import com.netgrif.application.engine.workflow.domain.menu.MenuItemConstants +import com.netgrif.application.engine.workflow.domain.params.DeleteCaseParams 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 @@ -320,7 +321,10 @@ class MenuItemApiTest { assert workflowService.findOne(testFolder.stringId) != null assert workflowService.findOne(leafItemId) != null - workflowService.deleteCase(testFolder) + DeleteCaseParams deleteCaseParams = DeleteCaseParams.builder() + .useCase(testFolder) + .build() + workflowService.deleteCase(deleteCaseParams) sleep(2000) netgrifFolder = workflowService.findOne(netgrifFolderId) assert !(netgrifFolder.dataSet[MenuItemConstants.PREFERENCE_ITEM_FIELD_CHILD_ITEM_IDS.attributeId].value as ArrayList).contains(testFolder.stringId) diff --git a/src/test/groovy/com/netgrif/application/engine/auth/TaskAuthorizationServiceTest.groovy b/src/test/groovy/com/netgrif/application/engine/auth/TaskAuthorizationServiceTest.groovy index b8a4a7d85c8..30fdbc99749 100644 --- a/src/test/groovy/com/netgrif/application/engine/auth/TaskAuthorizationServiceTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/auth/TaskAuthorizationServiceTest.groovy @@ -17,8 +17,9 @@ import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetServi import com.netgrif.application.engine.startup.ImportHelper import com.netgrif.application.engine.startup.SuperCreator import com.netgrif.application.engine.workflow.domain.Case -import com.netgrif.application.engine.workflow.domain.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams +import com.netgrif.application.engine.workflow.domain.params.DeleteCaseParams import com.netgrif.application.engine.workflow.service.interfaces.IDataService import com.netgrif.application.engine.workflow.service.interfaces.ITaskAuthorizationService import com.netgrif.application.engine.workflow.service.interfaces.ITaskService @@ -284,7 +285,10 @@ class TaskAuthorizationServiceTest { Case case_ = workflowService.createCase(createCaseParams).getCase() assert taskAuthorizationService.canCallAssign(testUser.transformToLoggedUser(), case_.getTaskStringId("1")) userService.removeRole(testUser, positiveRole.getStringId()) - workflowService.deleteCase(case_.stringId) + DeleteCaseParams deleteCaseParams = DeleteCaseParams.builder() + .useCase(case_) + .build() + workflowService.deleteCase(deleteCaseParams) } @Test @@ -300,7 +304,10 @@ class TaskAuthorizationServiceTest { Case case_ = workflowService.createCase(createCaseParams).getCase() assert !taskAuthorizationService.canCallAssign(testUser.transformToLoggedUser(), case_.getTaskStringId("1")) userService.removeRole(testUser, negativeRole.getStringId()) - workflowService.deleteCase(case_.stringId) + DeleteCaseParams deleteCaseParams = DeleteCaseParams.builder() + .useCase(case_) + .build() + workflowService.deleteCase(deleteCaseParams) } @Test @@ -320,7 +327,10 @@ class TaskAuthorizationServiceTest { sleep(4000) assert taskAuthorizationService.canCallAssign(testUser.transformToLoggedUser(), taskId) - workflowService.deleteCase(case_.stringId) + DeleteCaseParams deleteCaseParams = DeleteCaseParams.builder() + .useCase(case_) + .build() + workflowService.deleteCase(deleteCaseParams) } @Test @@ -339,7 +349,7 @@ class TaskAuthorizationServiceTest { sleep(4000) assert !taskAuthorizationService.canCallAssign(testUser.transformToLoggedUser(), taskId) - workflowService.deleteCase(case_.stringId) + workflowService.deleteCase(new DeleteCaseParams(case_)) } @Test @@ -361,7 +371,10 @@ class TaskAuthorizationServiceTest { assert taskAuthorizationService.canCallAssign(testUser.transformToLoggedUser(), taskId) userService.removeRole(testUser, positiveRole.getStringId()) - workflowService.deleteCase(case_.stringId) + DeleteCaseParams deleteCaseParams = DeleteCaseParams.builder() + .useCase(case_) + .build() + workflowService.deleteCase(deleteCaseParams) } @Test @@ -380,7 +393,10 @@ class TaskAuthorizationServiceTest { taskService.assignTask(testUser.transformToLoggedUser(), taskId) assert taskAuthorizationService.canCallFinish(testUser.transformToLoggedUser(), taskId) userService.removeRole(testUser, positiveRole.getStringId()) - workflowService.deleteCase(case_.stringId) + DeleteCaseParams deleteCaseParams = DeleteCaseParams.builder() + .useCase(case_) + .build() + workflowService.deleteCase(deleteCaseParams) } @Test @@ -399,7 +415,10 @@ class TaskAuthorizationServiceTest { taskService.assignTask(testUser.transformToLoggedUser(), taskId) assert !taskAuthorizationService.canCallFinish(testUser.transformToLoggedUser(), taskId) userService.removeRole(testUser, negativeRole.getStringId()) - workflowService.deleteCase(case_.stringId) + DeleteCaseParams deleteCaseParams = DeleteCaseParams.builder() + .useCase(case_) + .build() + workflowService.deleteCase(deleteCaseParams) } @Test @@ -419,7 +438,10 @@ class TaskAuthorizationServiceTest { taskService.assignTask(testUser.transformToLoggedUser(), taskId) assert taskAuthorizationService.canCallFinish(testUser.transformToLoggedUser(), taskId) - workflowService.deleteCase(case_.stringId) + DeleteCaseParams deleteCaseParams = DeleteCaseParams.builder() + .useCase(case_) + .build() + workflowService.deleteCase(deleteCaseParams) } @Test @@ -439,7 +461,10 @@ class TaskAuthorizationServiceTest { taskService.assignTask(testUser.transformToLoggedUser(), taskId) assert !taskAuthorizationService.canCallFinish(testUser.transformToLoggedUser(), taskId) - workflowService.deleteCase(case_.stringId) + DeleteCaseParams deleteCaseParams = DeleteCaseParams.builder() + .useCase(case_) + .build() + workflowService.deleteCase(deleteCaseParams) } @Test @@ -462,7 +487,10 @@ class TaskAuthorizationServiceTest { taskService.assignTask(testUser.transformToLoggedUser(), taskId) assert taskAuthorizationService.canCallFinish(testUser.transformToLoggedUser(), taskId) userService.removeRole(testUser, positiveRole.getStringId()) - workflowService.deleteCase(case_.stringId) + DeleteCaseParams deleteCaseParams = DeleteCaseParams.builder() + .useCase(case_) + .build() + workflowService.deleteCase(deleteCaseParams) } } diff --git a/src/test/groovy/com/netgrif/application/engine/auth/WorkflowAuthorizationServiceTest.groovy b/src/test/groovy/com/netgrif/application/engine/auth/WorkflowAuthorizationServiceTest.groovy index a5a1f515511..57b4e3d6420 100644 --- a/src/test/groovy/com/netgrif/application/engine/auth/WorkflowAuthorizationServiceTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/auth/WorkflowAuthorizationServiceTest.groovy @@ -16,7 +16,7 @@ import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetServi import com.netgrif.application.engine.startup.ImportHelper import com.netgrif.application.engine.startup.SuperCreator import com.netgrif.application.engine.workflow.domain.Case -import com.netgrif.application.engine.workflow.domain.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams import com.netgrif.application.engine.workflow.service.interfaces.IDataService import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowAuthorizationService diff --git a/src/test/groovy/com/netgrif/application/engine/elastic/ReindexTest.groovy b/src/test/groovy/com/netgrif/application/engine/elastic/ReindexTest.groovy index c9b3e57200f..bc9659e9429 100644 --- a/src/test/groovy/com/netgrif/application/engine/elastic/ReindexTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/elastic/ReindexTest.groovy @@ -8,7 +8,7 @@ import com.netgrif.application.engine.petrinet.domain.VersionType import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService import com.netgrif.application.engine.startup.SuperCreator import com.netgrif.application.engine.workflow.domain.Case -import com.netgrif.application.engine.workflow.domain.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowService import org.junit.jupiter.api.BeforeEach diff --git a/src/test/groovy/com/netgrif/application/engine/history/HistoryServiceTest.groovy b/src/test/groovy/com/netgrif/application/engine/history/HistoryServiceTest.groovy index e836758e19e..f99be804732 100644 --- a/src/test/groovy/com/netgrif/application/engine/history/HistoryServiceTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/history/HistoryServiceTest.groovy @@ -9,7 +9,7 @@ import com.netgrif.application.engine.petrinet.domain.dataset.NumberField import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService import com.netgrif.application.engine.startup.SuperCreator import com.netgrif.application.engine.workflow.domain.Case -import com.netgrif.application.engine.workflow.domain.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams import com.netgrif.application.engine.workflow.service.interfaces.IDataService import com.netgrif.application.engine.workflow.service.interfaces.ITaskService diff --git a/src/test/groovy/com/netgrif/application/engine/importer/AllDataTransitionTest.groovy b/src/test/groovy/com/netgrif/application/engine/importer/AllDataTransitionTest.groovy index cf72ca4ca40..ffa72a05ddf 100644 --- a/src/test/groovy/com/netgrif/application/engine/importer/AllDataTransitionTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/importer/AllDataTransitionTest.groovy @@ -8,7 +8,7 @@ import com.netgrif.application.engine.petrinet.domain.VersionType import com.netgrif.application.engine.petrinet.domain.throwable.MissingPetriNetMetaDataException import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService import com.netgrif.application.engine.startup.SuperCreator -import com.netgrif.application.engine.workflow.domain.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome import groovy.transform.CompileStatic import org.junit.jupiter.api.BeforeEach import org.junit.jupiter.api.Test diff --git a/src/test/groovy/com/netgrif/application/engine/importer/PredefinedRolesPermissionsTest.groovy b/src/test/groovy/com/netgrif/application/engine/importer/PredefinedRolesPermissionsTest.groovy index cabe9c15a5a..0eb67b14216 100644 --- a/src/test/groovy/com/netgrif/application/engine/importer/PredefinedRolesPermissionsTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/importer/PredefinedRolesPermissionsTest.groovy @@ -13,8 +13,8 @@ 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.TaskPair -import com.netgrif.application.engine.workflow.domain.eventoutcomes.caseoutcomes.CreateCaseEventOutcome -import com.netgrif.application.engine.workflow.domain.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.caseoutcomes.CreateCaseEventOutcome +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams import com.netgrif.application.engine.workflow.service.interfaces.ITaskService import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowService diff --git a/src/test/groovy/com/netgrif/application/engine/importer/UserListTest.groovy b/src/test/groovy/com/netgrif/application/engine/importer/UserListTest.groovy index cd77dd3626c..134a7d2e9e7 100644 --- a/src/test/groovy/com/netgrif/application/engine/importer/UserListTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/importer/UserListTest.groovy @@ -13,7 +13,7 @@ import com.netgrif.application.engine.utils.FullPageRequest import com.netgrif.application.engine.workflow.domain.Case import com.netgrif.application.engine.workflow.domain.QCase import com.netgrif.application.engine.workflow.domain.Task -import com.netgrif.application.engine.workflow.domain.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome import com.netgrif.application.engine.workflow.domain.repositories.CaseRepository import com.netgrif.application.engine.workflow.service.interfaces.IDataService import com.netgrif.application.engine.workflow.service.interfaces.ITaskService diff --git a/src/test/groovy/com/netgrif/application/engine/insurance/EncryptionTest.groovy b/src/test/groovy/com/netgrif/application/engine/insurance/EncryptionTest.groovy index d0e0ac01ddb..2f3ab5f4a38 100644 --- a/src/test/groovy/com/netgrif/application/engine/insurance/EncryptionTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/insurance/EncryptionTest.groovy @@ -9,7 +9,7 @@ import com.netgrif.application.engine.petrinet.domain.VersionType import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService import com.netgrif.application.engine.startup.SuperCreator import com.netgrif.application.engine.workflow.domain.Case -import com.netgrif.application.engine.workflow.domain.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams import com.netgrif.application.engine.workflow.domain.repositories.CaseRepository import com.netgrif.application.engine.workflow.service.TaskService diff --git a/src/test/groovy/com/netgrif/application/engine/ipc/CaseApiTest.groovy b/src/test/groovy/com/netgrif/application/engine/ipc/CaseApiTest.groovy index 673f585d081..34fe9810b7a 100644 --- a/src/test/groovy/com/netgrif/application/engine/ipc/CaseApiTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/ipc/CaseApiTest.groovy @@ -7,7 +7,7 @@ import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetServi import com.netgrif.application.engine.startup.ImportHelper import com.netgrif.application.engine.startup.SuperCreator import com.netgrif.application.engine.workflow.domain.Case -import com.netgrif.application.engine.workflow.domain.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome import com.netgrif.application.engine.workflow.domain.repositories.CaseRepository import org.junit.jupiter.api.BeforeEach import org.junit.jupiter.api.Test diff --git a/src/test/groovy/com/netgrif/application/engine/menu/MenuImportExportTest.groovy b/src/test/groovy/com/netgrif/application/engine/menu/MenuImportExportTest.groovy index 2ddad1eab53..83364068e72 100644 --- a/src/test/groovy/com/netgrif/application/engine/menu/MenuImportExportTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/menu/MenuImportExportTest.groovy @@ -14,7 +14,7 @@ import com.netgrif.application.engine.workflow.domain.Case import com.netgrif.application.engine.workflow.domain.QCase import com.netgrif.application.engine.workflow.domain.QTask import com.netgrif.application.engine.workflow.domain.Task -import com.netgrif.application.engine.workflow.domain.eventoutcomes.dataoutcomes.SetDataEventOutcome +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.dataoutcomes.SetDataEventOutcome import com.netgrif.application.engine.workflow.domain.menu.MenuAndFilters import com.netgrif.application.engine.workflow.domain.repositories.CaseRepository import com.netgrif.application.engine.workflow.service.UserFilterSearchService diff --git a/src/test/groovy/com/netgrif/application/engine/permissions/ElasticSearchViewPermissionTest.groovy b/src/test/groovy/com/netgrif/application/engine/permissions/ElasticSearchViewPermissionTest.groovy index 6d72fbfac92..93355dc93dc 100644 --- a/src/test/groovy/com/netgrif/application/engine/permissions/ElasticSearchViewPermissionTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/permissions/ElasticSearchViewPermissionTest.groovy @@ -20,8 +20,9 @@ import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetServi import com.netgrif.application.engine.startup.ImportHelper import com.netgrif.application.engine.startup.SuperCreator import com.netgrif.application.engine.workflow.domain.Case -import com.netgrif.application.engine.workflow.domain.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams +import com.netgrif.application.engine.workflow.domain.params.DeleteCaseParams 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 @@ -114,7 +115,10 @@ class ElasticSearchViewPermissionTest { Page<Case> casePage = elasticCaseService.search([caseSearchRequest] as List, testUser.transformToLoggedUser(), PageRequest.of(0, 20), LocaleContextHolder.getLocale(), false) assert casePage.getContent().size() == 0 - workflowService.deleteCase(case_.getStringId()) + DeleteCaseParams deleteCaseParams = DeleteCaseParams.builder() + .useCase(case_) + .build() + workflowService.deleteCase(deleteCaseParams) } @Test @@ -138,7 +142,10 @@ class ElasticSearchViewPermissionTest { assert casePage.getContent().size() == 1 assert casePage.getContent()[0].stringId == case_.stringId userService.removeRole(testUser, posViewRole.getStringId()) - workflowService.deleteCase(case_.getStringId()) + DeleteCaseParams deleteCaseParams = DeleteCaseParams.builder() + .useCase(case_) + .build() + workflowService.deleteCase(deleteCaseParams) } @Test @@ -159,7 +166,10 @@ class ElasticSearchViewPermissionTest { assert casePage.getContent().size() == 0 && case_.negativeViewRoles.contains(negViewRole.stringId) userService.removeRole(testUser, negViewRole.getStringId()) - workflowService.deleteCase(case_.getStringId()) + DeleteCaseParams deleteCaseParams = DeleteCaseParams.builder() + .useCase(case_) + .build() + workflowService.deleteCase(deleteCaseParams) } @Test @@ -177,7 +187,10 @@ class ElasticSearchViewPermissionTest { Page<Case> casePage = elasticCaseService.search([caseSearchRequest] as List, testUser.transformToLoggedUser(), PageRequest.of(0, 20), LocaleContextHolder.getLocale(), false) assert casePage.getContent().size() == 0 - workflowService.deleteCase(case_.getStringId()) + DeleteCaseParams deleteCaseParams = DeleteCaseParams.builder() + .useCase(case_) + .build() + workflowService.deleteCase(deleteCaseParams) } @Test @@ -201,7 +214,10 @@ class ElasticSearchViewPermissionTest { Page<Case> casePage = elasticCaseService.search([caseSearchRequest] as List, testUser.transformToLoggedUser(), PageRequest.of(0, 20), LocaleContextHolder.getLocale(), false) assert casePage.getContent().size() == 1 && casePage.getContent()[0].stringId == case_.stringId && case_.viewUsers.contains(testUser.getStringId()) - workflowService.deleteCase(case_.getStringId()) + DeleteCaseParams deleteCaseParams = DeleteCaseParams.builder() + .useCase(case_) + .build() + workflowService.deleteCase(deleteCaseParams) } @Test @@ -225,7 +241,10 @@ class ElasticSearchViewPermissionTest { Page<Case> casePage = elasticCaseService.search([caseSearchRequest] as List, testUser.transformToLoggedUser(), PageRequest.of(0, 20), LocaleContextHolder.getLocale(), false) assert casePage.getContent().size() == 0 && case_.negativeViewUsers.contains(testUser.getStringId()) - workflowService.deleteCase(case_.getStringId()) + DeleteCaseParams deleteCaseParams = DeleteCaseParams.builder() + .useCase(case_) + .build() + workflowService.deleteCase(deleteCaseParams) } @Test @@ -252,6 +271,9 @@ class ElasticSearchViewPermissionTest { assert casePage.getContent().size() == 1 && case_.viewUsers.contains(testUser.stringId) userService.removeRole(testUser, negViewRole.getStringId()) - workflowService.deleteCase(case_.getStringId()) + DeleteCaseParams deleteCaseParams = DeleteCaseParams.builder() + .useCase(case_) + .build() + workflowService.deleteCase(deleteCaseParams) } } diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/EventTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/EventTest.groovy index c4f3666dd9b..6efc963cf1d 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/EventTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/EventTest.groovy @@ -11,7 +11,7 @@ import com.netgrif.application.engine.startup.ImportHelper import com.netgrif.application.engine.startup.SuperCreator import com.netgrif.application.engine.startup.SystemUserRunner import com.netgrif.application.engine.workflow.domain.Case -import com.netgrif.application.engine.workflow.domain.eventoutcomes.taskoutcomes.TaskEventOutcome +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.taskoutcomes.TaskEventOutcome import com.netgrif.application.engine.workflow.domain.repositories.CaseRepository import com.netgrif.application.engine.workflow.domain.repositories.TaskRepository import com.netgrif.application.engine.workflow.service.TaskService diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/CaseFieldTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/CaseFieldTest.groovy index d131cd14cfb..fa117c8474d 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/CaseFieldTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/CaseFieldTest.groovy @@ -7,7 +7,7 @@ import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetServi import com.netgrif.application.engine.startup.ImportHelper import com.netgrif.application.engine.startup.SuperCreator import com.netgrif.application.engine.workflow.domain.Case -import com.netgrif.application.engine.workflow.domain.eventoutcomes.dataoutcomes.SetDataEventOutcome +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.dataoutcomes.SetDataEventOutcome import com.netgrif.application.engine.workflow.domain.repositories.CaseRepository import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowService import com.netgrif.application.engine.workflow.web.responsebodies.DataSet diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/ChangeFieldValueInitTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/ChangeFieldValueInitTest.groovy index c029fddfdee..fa97895ce45 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/ChangeFieldValueInitTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/ChangeFieldValueInitTest.groovy @@ -8,7 +8,7 @@ import com.netgrif.application.engine.startup.SuperCreator import com.netgrif.application.engine.workflow.domain.Case import com.netgrif.application.engine.workflow.domain.QTask import com.netgrif.application.engine.workflow.domain.Task -import com.netgrif.application.engine.workflow.domain.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome import com.netgrif.application.engine.workflow.service.interfaces.ITaskService import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowService import org.junit.jupiter.api.BeforeEach diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicCaseNameTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicCaseNameTest.groovy index e47e59608d7..08f0a1dfce5 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicCaseNameTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicCaseNameTest.groovy @@ -5,7 +5,7 @@ import com.netgrif.application.engine.petrinet.domain.VersionType import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService import com.netgrif.application.engine.startup.SuperCreator import com.netgrif.application.engine.workflow.domain.Case -import com.netgrif.application.engine.workflow.domain.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowService import org.junit.jupiter.api.BeforeEach diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicChoicesTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicChoicesTest.groovy index 85f56582407..cf831cef8ae 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicChoicesTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicChoicesTest.groovy @@ -5,7 +5,7 @@ import com.netgrif.application.engine.petrinet.domain.VersionType 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.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome import com.netgrif.application.engine.workflow.domain.repositories.CaseRepository import com.netgrif.application.engine.workflow.service.interfaces.IDataService import com.netgrif.application.engine.workflow.service.interfaces.ITaskService diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicDefaultValueTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicDefaultValueTest.groovy index 89c02c355dc..b3ee44fe972 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicDefaultValueTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicDefaultValueTest.groovy @@ -6,7 +6,7 @@ import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetServi import com.netgrif.application.engine.startup.ImportHelper import com.netgrif.application.engine.startup.SuperCreator import com.netgrif.application.engine.workflow.domain.Case -import com.netgrif.application.engine.workflow.domain.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome import groovy.transform.CompileStatic import org.junit.jupiter.api.BeforeEach import org.junit.jupiter.api.Test diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicEnumerationTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicEnumerationTest.groovy index 14fee16971f..b952275d990 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicEnumerationTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicEnumerationTest.groovy @@ -8,7 +8,7 @@ import com.netgrif.application.engine.startup.ImportHelper import com.netgrif.application.engine.startup.SuperCreator import com.netgrif.application.engine.utils.FullPageRequest import com.netgrif.application.engine.workflow.domain.Task -import com.netgrif.application.engine.workflow.domain.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome import com.netgrif.application.engine.workflow.domain.repositories.CaseRepository import com.netgrif.application.engine.workflow.service.interfaces.IDataService import com.netgrif.application.engine.workflow.service.interfaces.ITaskService diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicValidationPerformanceTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicValidationPerformanceTest.groovy index a3992a8c08a..2fcb9cbe694 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicValidationPerformanceTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicValidationPerformanceTest.groovy @@ -7,7 +7,7 @@ import com.netgrif.application.engine.startup.ImportHelper 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.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome 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 diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/service/CachePetriNetServiceTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/service/CachePetriNetServiceTest.groovy index 5c7d20bfe17..92390b6e583 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/service/CachePetriNetServiceTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/service/CachePetriNetServiceTest.groovy @@ -13,7 +13,7 @@ import com.netgrif.application.engine.petrinet.domain.roles.ProcessRole 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.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome import org.junit.jupiter.api.BeforeEach import org.junit.jupiter.api.Test import org.junit.jupiter.api.extension.ExtendWith diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/service/PetriNetServiceTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/service/PetriNetServiceTest.groovy index 3e241f6de76..3d97a0f31ab 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/service/PetriNetServiceTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/service/PetriNetServiceTest.groovy @@ -18,7 +18,7 @@ import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetServi import com.netgrif.application.engine.petrinet.service.interfaces.IProcessRoleService import com.netgrif.application.engine.startup.ImportHelper import com.netgrif.application.engine.startup.SuperCreator -import com.netgrif.application.engine.workflow.domain.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome import com.netgrif.application.engine.workflow.domain.repositories.CaseRepository import com.netgrif.application.engine.workflow.domain.repositories.TaskRepository import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowService diff --git a/src/test/groovy/com/netgrif/application/engine/workflow/DataServiceTest.groovy b/src/test/groovy/com/netgrif/application/engine/workflow/DataServiceTest.groovy index e03ce2136cf..7f13557a817 100644 --- a/src/test/groovy/com/netgrif/application/engine/workflow/DataServiceTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/workflow/DataServiceTest.groovy @@ -9,7 +9,7 @@ import com.netgrif.application.engine.petrinet.domain.VersionType 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.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome import com.netgrif.application.engine.workflow.service.interfaces.IDataService import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowService import groovy.transform.CompileStatic diff --git a/src/test/groovy/com/netgrif/application/engine/workflow/WorkflowServiceTest.groovy b/src/test/groovy/com/netgrif/application/engine/workflow/WorkflowServiceTest.groovy index f85a06ace65..12a9eb79ae1 100644 --- a/src/test/groovy/com/netgrif/application/engine/workflow/WorkflowServiceTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/workflow/WorkflowServiceTest.groovy @@ -60,11 +60,12 @@ class WorkflowServiceTest { @Test @Disabled + // todo remove void testblabla() { def testNetWithTriggers = petriNetService.importPetriNet(stream("petriNets/test_with_triggers.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()).getNet() - def testNet = petriNetService.importPetriNet(stream("petriNets/mortgage.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()).getNet() + def testNet = petriNetService.importPetriNet(stream("petriNets/test_without_triggers.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()).getNet() - int iterations = 2 + int iterations = 1000 def paramsWithoutTrigger = CreateCaseParams.builder() .petriNet(testNet) .loggedUser(superCreator.getLoggedSuper()) diff --git a/src/test/java/com/netgrif/application/engine/importer/ConstructorAndDestructorTest.java b/src/test/java/com/netgrif/application/engine/importer/ConstructorAndDestructorTest.java index 51cf5337193..a5fbc7b5c4c 100644 --- a/src/test/java/com/netgrif/application/engine/importer/ConstructorAndDestructorTest.java +++ b/src/test/java/com/netgrif/application/engine/importer/ConstructorAndDestructorTest.java @@ -8,7 +8,7 @@ import com.netgrif.application.engine.startup.SuperCreator; import com.netgrif.application.engine.workflow.domain.Case; import com.netgrif.application.engine.workflow.domain.QCase; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome; import com.netgrif.application.engine.workflow.domain.repositories.CaseRepository; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; diff --git a/src/test/java/com/netgrif/application/engine/importer/ImporterTest.java b/src/test/java/com/netgrif/application/engine/importer/ImporterTest.java index 0cda1f2c4e2..460a5078149 100644 --- a/src/test/java/com/netgrif/application/engine/importer/ImporterTest.java +++ b/src/test/java/com/netgrif/application/engine/importer/ImporterTest.java @@ -11,8 +11,8 @@ import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService; import com.netgrif.application.engine.startup.SuperCreator; import com.netgrif.application.engine.utils.FullPageRequest; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.caseoutcomes.CreateCaseEventOutcome; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.caseoutcomes.CreateCaseEventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome; import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams; import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowService; import org.junit.jupiter.api.BeforeEach; diff --git a/src/test/java/com/netgrif/application/engine/petrinet/service/ProcessRoleServiceTest.java b/src/test/java/com/netgrif/application/engine/petrinet/service/ProcessRoleServiceTest.java index ab62d721947..89e2b0ca93e 100644 --- a/src/test/java/com/netgrif/application/engine/petrinet/service/ProcessRoleServiceTest.java +++ b/src/test/java/com/netgrif/application/engine/petrinet/service/ProcessRoleServiceTest.java @@ -7,7 +7,7 @@ import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService; import com.netgrif.application.engine.petrinet.service.interfaces.IProcessRoleService; import com.netgrif.application.engine.startup.SuperCreator; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; diff --git a/src/test/java/com/netgrif/application/engine/rules/service/RuleEngineTest.java b/src/test/java/com/netgrif/application/engine/rules/service/RuleEngineTest.java index 3e16360855d..89064ece05d 100644 --- a/src/test/java/com/netgrif/application/engine/rules/service/RuleEngineTest.java +++ b/src/test/java/com/netgrif/application/engine/rules/service/RuleEngineTest.java @@ -16,8 +16,8 @@ import com.netgrif.application.engine.rules.domain.facts.*; import com.netgrif.application.engine.workflow.domain.Case; import com.netgrif.application.engine.workflow.domain.Task; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.caseoutcomes.CreateCaseEventOutcome; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.caseoutcomes.CreateCaseEventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome; import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams; import com.netgrif.application.engine.workflow.service.interfaces.ITaskService; import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowService; diff --git a/src/test/java/com/netgrif/application/engine/rules/service/RuleEvaluationScheduleServiceTest.java b/src/test/java/com/netgrif/application/engine/rules/service/RuleEvaluationScheduleServiceTest.java index 57e187f938d..a0a0f91934d 100644 --- a/src/test/java/com/netgrif/application/engine/rules/service/RuleEvaluationScheduleServiceTest.java +++ b/src/test/java/com/netgrif/application/engine/rules/service/RuleEvaluationScheduleServiceTest.java @@ -13,8 +13,8 @@ import com.netgrif.application.engine.rules.service.throwable.RuleEvaluationScheduleException; import com.netgrif.application.engine.startup.SuperCreator; import com.netgrif.application.engine.workflow.domain.Case; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.caseoutcomes.CreateCaseEventOutcome; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.caseoutcomes.CreateCaseEventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome; import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams; import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowService; import lombok.extern.slf4j.Slf4j; diff --git a/src/test/java/com/netgrif/application/engine/workflow/service/TaskServiceTest.java b/src/test/java/com/netgrif/application/engine/workflow/service/TaskServiceTest.java index ba34d585476..16f2091b6d2 100644 --- a/src/test/java/com/netgrif/application/engine/workflow/service/TaskServiceTest.java +++ b/src/test/java/com/netgrif/application/engine/workflow/service/TaskServiceTest.java @@ -19,7 +19,7 @@ import com.netgrif.application.engine.startup.UriRunner; import com.netgrif.application.engine.workflow.domain.Case; import com.netgrif.application.engine.workflow.domain.Task; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.caseoutcomes.CreateCaseEventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.caseoutcomes.CreateCaseEventOutcome; import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams; import com.netgrif.application.engine.workflow.domain.repositories.CaseRepository; import com.netgrif.application.engine.workflow.domain.repositories.TaskRepository; diff --git a/src/test/java/com/netgrif/application/engine/workflow/web/VariableArcsTest.java b/src/test/java/com/netgrif/application/engine/workflow/web/VariableArcsTest.java index f09e213a051..b8ac57092f8 100644 --- a/src/test/java/com/netgrif/application/engine/workflow/web/VariableArcsTest.java +++ b/src/test/java/com/netgrif/application/engine/workflow/web/VariableArcsTest.java @@ -23,8 +23,8 @@ import com.netgrif.application.engine.workflow.domain.Case; import com.netgrif.application.engine.workflow.domain.QTask; import com.netgrif.application.engine.workflow.domain.Task; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.caseoutcomes.CreateCaseEventOutcome; -import com.netgrif.application.engine.workflow.domain.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.caseoutcomes.CreateCaseEventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome; import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams; import com.netgrif.application.engine.workflow.service.interfaces.ITaskService; import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowService; From 022a16d987bdb3330bc30813e237a06e426e6fb5 Mon Sep 17 00:00:00 2001 From: chvostek <chvostek@netgrif.com> Date: Tue, 6 Aug 2024 14:51:14 +0200 Subject: [PATCH 25/48] [NAE-1998] Implement transactions for events - optimize TaskService.assignTask - optimize TaskService.finishTask - optimize TaskService.cancelTask - fix some warnings --- .../logic/action/ActionDelegate.groovy | 70 ++- .../startup/DefaultFiltersRunner.groovy | 14 +- .../engine/startup/ImportHelper.groovy | 27 +- .../orgstructure/groups/NextGroupService.java | 5 +- .../domain/outcomes/DoEventTaskOutcome.java | 14 + .../outcomes/UpdateTaskStateOutcome.java | 12 + .../workflow/domain/params/TaskParams.java | 42 ++ .../service/FilterImportExportService.java | 3 +- .../service/MenuImportExportService.java | 14 +- .../engine/workflow/service/TaskService.java | 407 ++++++++++-------- .../service/interfaces/ITaskService.java | 42 +- .../workflow/web/AbstractTaskController.java | 19 +- .../engine-processes/import_filters.xml | 2 +- .../netgrif/application/engine/Async.groovy | 6 +- .../engine/action/MenuItemApiTest.groovy | 9 +- .../auth/TaskAuthorizationServiceTest.groovy | 31 +- .../export/service/ExportServiceTest.groovy | 27 +- .../filters/FilterImportExportTest.groovy | 3 +- .../engine/history/HistoryServiceTest.groovy | 7 +- .../ImpersonationServiceTest.groovy | 27 +- .../engine/petrinet/domain/EventTest.groovy | 2 +- .../petrinet/domain/ImporterTest.groovy | 3 +- .../dataset/ChangeCasePropertyTest.groovy | 9 +- .../dataset/ChangeFieldValueInitTest.groovy | 7 +- .../dataset/DynamicEnumerationTest.groovy | 2 +- .../domain/dataset/FileFieldTest.groovy | 4 +- .../domain/dataset/FileListFieldTest.groovy | 22 +- .../workflow/SetDataOnButtonTest.groovy | 5 +- .../engine/workflow/TaskStateTest.groovy | 5 +- .../workflow/WorkflowServiceTest.groovy | 32 +- .../engine/rules/service/RuleEngineTest.java | 21 +- .../workflow/service/TaskServiceTest.java | 5 +- .../engine/workflow/web/VariableArcsTest.java | 102 ++++- 33 files changed, 635 insertions(+), 365 deletions(-) create mode 100644 src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/DoEventTaskOutcome.java create mode 100644 src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/UpdateTaskStateOutcome.java create mode 100644 src/main/java/com/netgrif/application/engine/workflow/domain/params/TaskParams.java diff --git a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy index c600a9c80a2..e633e092327 100644 --- a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy +++ b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy @@ -38,6 +38,7 @@ import com.netgrif.application.engine.transaction.NaeTransaction import com.netgrif.application.engine.utils.FullPageRequest import com.netgrif.application.engine.workflow.domain.* import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.EventOutcome +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.caseoutcomes.CaseEventOutcome import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.caseoutcomes.CreateCaseEventOutcome import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.dataoutcomes.GetDataEventOutcome import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.dataoutcomes.SetDataEventOutcome @@ -47,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.TaskParams import com.netgrif.application.engine.workflow.service.FileFieldInputStream import com.netgrif.application.engine.workflow.service.TaskService import com.netgrif.application.engine.workflow.service.interfaces.* @@ -605,9 +607,11 @@ class ActionDelegate /*TODO: release/8.0.0: implements ActionAPI*/ { } private addTaskOutcomes(Task task, DataSet dataSet) { - this.outcomes.add(taskService.assignTask(task.stringId)) - this.outcomes.add(dataService.setData(task.stringId, dataSet, userService.loggedOrSystem)) - this.outcomes.add(taskService.finishTask(task.stringId)) + AssignTaskEventOutcome assignOutcome = taskService.assignTask(new TaskParams(task)) + this.outcomes.add(assignOutcome) + SetDataEventOutcome setDataOutcome = dataService.setData(assignOutcome.getTask(), dataSet, userService.loggedOrSystem) + this.outcomes.add(setDataOutcome) + this.outcomes.add(taskService.finishTask(new TaskParams(setDataOutcome.getTask()))) } List<String> searchCases(Closure<Predicate> predicates) { @@ -828,14 +832,22 @@ class ActionDelegate /*TODO: release/8.0.0: implements ActionAPI*/ { Task assignTask(String transitionId, Case aCase = useCase, IUser user = userService.loggedOrSystem, Map<String, String> params = [:]) { String taskId = getTaskId(transitionId, aCase) - AssignTaskEventOutcome outcome = taskService.assignTask(user.transformToLoggedUser(), taskId, params) - this.outcomes.add(outcome) - updateCase() - return outcome.getTask() + TaskParams taskParams = TaskParams.builder() + .taskId(taskId) + .useCase(aCase) + .user(user) + .params(params) + .build() + return addTaskOutcomeAndReturnTask(taskService.assignTask(taskParams)) } Task assignTask(Task task, IUser user = userService.loggedOrSystem, Map<String, String> params = [:]) { - return addTaskOutcomeAndReturnTask(taskService.assignTask(task, user, params)) + TaskParams taskParams = TaskParams.builder() + .task(task) + .user(user) + .params(params) + .build() + return addTaskOutcomeAndReturnTask(taskService.assignTask(taskParams)) } void assignTasks(List<Task> tasks, IUser assignee = userService.loggedOrSystem, Map<String, String> params = [:]) { @@ -844,11 +856,22 @@ class ActionDelegate /*TODO: release/8.0.0: implements ActionAPI*/ { Task cancelTask(String transitionId, Case aCase = useCase, IUser user = userService.loggedOrSystem, Map<String, String> params = [:]) { String taskId = getTaskId(transitionId, aCase) - return addTaskOutcomeAndReturnTask(taskService.cancelTask(user.transformToLoggedUser(), taskId, params)) + TaskParams taskParams = TaskParams.builder() + .taskId(taskId) + .useCase(aCase) + .user(user) + .params(params) + .build() + return addTaskOutcomeAndReturnTask(taskService.cancelTask(taskParams)) } Task cancelTask(Task task, IUser user = userService.loggedOrSystem, Map<String, String> params = [:]) { - return addTaskOutcomeAndReturnTask(taskService.cancelTask(task, user, params)) + TaskParams taskParams = TaskParams.builder() + .task(task) + .user(user) + .params(params) + .build() + return addTaskOutcomeAndReturnTask(taskService.cancelTask(taskParams)) } void cancelTasks(List<Task> tasks, IUser user = userService.loggedOrSystem, Map<String, String> params = [:]) { @@ -857,17 +880,28 @@ class ActionDelegate /*TODO: release/8.0.0: implements ActionAPI*/ { private Task addTaskOutcomeAndReturnTask(TaskEventOutcome outcome) { this.outcomes.add(outcome) - updateCase() + updateCase(outcome) return outcome.getTask() } void finishTask(String transitionId, Case aCase = useCase, IUser user = userService.loggedOrSystem, Map<String, String> params = [:]) { String taskId = getTaskId(transitionId, aCase) - addTaskOutcomeAndReturnTask(taskService.finishTask(user.transformToLoggedUser(), taskId, params)) + TaskParams taskParams = TaskParams.builder() + .taskId(taskId) + .useCase(aCase) + .user(user) + .params(params) + .build() + addTaskOutcomeAndReturnTask(taskService.finishTask(taskParams)) } void finishTask(Task task, IUser user = userService.loggedOrSystem, Map<String, String> params = [:]) { - addTaskOutcomeAndReturnTask(taskService.finishTask(task, user, params)) + TaskParams taskParams = TaskParams.builder() + .task(task) + .user(user) + .params(params) + .build() + addTaskOutcomeAndReturnTask(taskService.finishTask(taskParams)) } void finishTasks(List<Task> tasks, IUser finisher = userService.loggedOrSystem, Map<String, String> params = [:]) { @@ -1161,7 +1195,7 @@ class ActionDelegate /*TODO: release/8.0.0: implements ActionAPI*/ { void deleteUser(IUser user) { List<Task> tasks = taskService.findByUser(new FullPageRequest(), user).toList() if (tasks != null && tasks.size() > 0) - taskService.cancelTasks(tasks, user) + taskService.cancelTasks(tasks, user, params) QCase qCase = new QCase("case") List<Case> cases = workflowService.searchAll(qCase.author.eq(user.transformToAuthor())).toList() @@ -2109,6 +2143,14 @@ class ActionDelegate /*TODO: release/8.0.0: implements ActionAPI*/ { initFieldsMap(action.fieldIds, useCase) } + void updateCase(CaseEventOutcome outcome) { + if (!useCase) { + return + } + useCase = outcome.getCase() + initFieldsMap(action.fieldIds, useCase) + } + @Deprecated Map<String, Case> createMenuItem(String id, String uri, String query, String icon, String title, List<String> allowedNets, Map<String, String> roles, Map<String, String> bannedRoles = [:], Case group = null, List<String> defaultHeaders = []) { if (existsMenuItem(id)) { diff --git a/src/main/groovy/com/netgrif/application/engine/startup/DefaultFiltersRunner.groovy b/src/main/groovy/com/netgrif/application/engine/startup/DefaultFiltersRunner.groovy index 795e38acea1..2ebc820c555 100644 --- a/src/main/groovy/com/netgrif/application/engine/startup/DefaultFiltersRunner.groovy +++ b/src/main/groovy/com/netgrif/application/engine/startup/DefaultFiltersRunner.groovy @@ -3,26 +3,22 @@ package com.netgrif.application.engine.startup import com.netgrif.application.engine.auth.service.interfaces.IUserService import com.netgrif.application.engine.petrinet.domain.I18nString import com.netgrif.application.engine.petrinet.domain.PetriNet -import com.netgrif.application.engine.petrinet.domain.dataset.EnumerationMapField -import com.netgrif.application.engine.petrinet.domain.dataset.Field -import com.netgrif.application.engine.petrinet.domain.dataset.FilterField -import com.netgrif.application.engine.petrinet.domain.dataset.NumberField -import com.netgrif.application.engine.petrinet.domain.dataset.TextField +import com.netgrif.application.engine.petrinet.domain.dataset.* import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService import com.netgrif.application.engine.workflow.domain.Case import com.netgrif.application.engine.workflow.domain.QCase import com.netgrif.application.engine.workflow.domain.QTask import com.netgrif.application.engine.workflow.domain.Task import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams +import com.netgrif.application.engine.workflow.domain.params.TaskParams 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 import com.netgrif.application.engine.workflow.web.responsebodies.DataSet -import groovy.transform.CompileStatic import lombok.extern.slf4j.Slf4j import org.springframework.beans.factory.annotation.Autowired -import org.springframework.stereotype.Component import org.springframework.beans.factory.annotation.Value +import org.springframework.stereotype.Component @Slf4j @Component @@ -282,7 +278,7 @@ class DefaultFiltersRunner extends AbstractOrderedCommandLineRunner { filterCase.setIcon(icon) filterCase = this.workflowService.save(filterCase) Task newFilterTask = this.taskService.searchOne(QTask.task.transitionId.eq(AUTO_CREATE_TRANSITION).and(QTask.task.caseId.eq(filterCase.getStringId()))) - this.taskService.assignTask(newFilterTask, this.userService.getLoggedOrSystem()) + this.taskService.assignTask(new TaskParams(newFilterTask, this.userService.getLoggedOrSystem())) DataSet dataSet = new DataSet([ (FILTER_TYPE_FIELD_ID): new EnumerationMapField(rawValue: filterType), @@ -309,7 +305,7 @@ class DefaultFiltersRunner extends AbstractOrderedCommandLineRunner { filterCase.dataSet.get(FILTER_I18N_TITLE_FIELD_ID).rawValue = translatedTitle workflowService.save(filterCase) - this.taskService.finishTask(newFilterTask, this.userService.getLoggedOrSystem()) + this.taskService.finishTask(new TaskParams(newFilterTask, this.userService.getLoggedOrSystem())) return Optional.of(this.workflowService.findOne(filterCase.getStringId())) } } diff --git a/src/main/groovy/com/netgrif/application/engine/startup/ImportHelper.groovy b/src/main/groovy/com/netgrif/application/engine/startup/ImportHelper.groovy index b8b15f0985e..edac7bcb125 100644 --- a/src/main/groovy/com/netgrif/application/engine/startup/ImportHelper.groovy +++ b/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.TaskParams import com.netgrif.application.engine.workflow.domain.repositories.CaseRepository import com.netgrif.application.engine.workflow.service.interfaces.IDataService import com.netgrif.application.engine.workflow.service.interfaces.ITaskService @@ -108,12 +109,12 @@ class ImportHelper { return Optional.of(petriNet) } - ProcessRole getProcessRoleByImportId(PetriNet net, String roleId) { + static ProcessRole getProcessRoleByImportId(PetriNet net, String roleId) { ProcessRole role = net.roles.values().find { it -> it.importId == roleId } return role } - Map<String, ProcessRole> getProcessRolesByImportId(PetriNet net, Map<String, String> importId) { + static Map<String, ProcessRole> getProcessRolesByImportId(PetriNet net, Map<String, String> importId) { HashMap<String, ProcessRole> roles = new HashMap<>() importId.each { it -> roles.put(it.getKey(), getProcessRoleByImportId(net, it.getValue())) @@ -130,7 +131,7 @@ class ImportHelper { return map } - IUser createUser(User user, Authority[] authorities, ProcessRole[] roles) { + IUser createUser(IUser user, Authority[] authorities, ProcessRole[] roles) { authorities.each { user.addAuthority(it) } roles.each { user.addProcessRole(it) } user.state = UserState.ACTIVE @@ -157,28 +158,28 @@ class ImportHelper { return createCase(title, net, superCreator.loggedSuper ?: userService.getSystem().transformToLoggedUser()) } - AssignTaskEventOutcome assignTask(String taskTitle, String caseId, LoggedUser author) { - return taskService.assignTask(author, getTaskId(taskTitle, caseId)) + AssignTaskEventOutcome assignTask(String taskTitle, String caseId, IUser author) { + return taskService.assignTask(new TaskParams(getTaskId(taskTitle, caseId), author)) } AssignTaskEventOutcome assignTaskToSuper(String taskTitle, String caseId) { - return assignTask(taskTitle, caseId, superCreator.loggedSuper ?: userService.getSystem().transformToLoggedUser()) + return assignTask(taskTitle, caseId, superCreator.superUser ?: userService.getSystem()) } - FinishTaskEventOutcome finishTask(String taskTitle, String caseId, LoggedUser author) { - return taskService.finishTask(author, getTaskId(taskTitle, caseId)) + FinishTaskEventOutcome finishTask(String taskTitle, String caseId, IUser author) { + return taskService.finishTask(new TaskParams(getTaskId(taskTitle, caseId), author)) } FinishTaskEventOutcome finishTaskAsSuper(String taskTitle, String caseId) { - return finishTask(taskTitle, caseId, superCreator.loggedSuper ?: userService.getSystem().transformToLoggedUser()) + return finishTask(taskTitle, caseId, superCreator.superUser ?: userService.getSystem()) } - CancelTaskEventOutcome cancelTask(String taskTitle, String caseId, LoggedUser user) { - return taskService.cancelTask(user, getTaskId(taskTitle, caseId)) + CancelTaskEventOutcome cancelTask(String taskTitle, String caseId, IUser user) { + return taskService.cancelTask(new TaskParams(getTaskId(taskTitle, caseId), user)) } CancelTaskEventOutcome cancelTaskAsSuper(String taskTitle, String caseId) { - return cancelTask(taskTitle, caseId, superCreator.loggedSuper ?: userService.getSystem().transformToLoggedUser()) + return cancelTask(taskTitle, caseId, superCreator.superUser ?: userService.getSystem()) } String getTaskId(String taskTitle, String caseId) { @@ -199,6 +200,6 @@ class ImportHelper { } void updateSuperUser() { - superCreator.setAllToSuperUser(); + superCreator.setAllToSuperUser() } } diff --git a/src/main/java/com/netgrif/application/engine/orgstructure/groups/NextGroupService.java b/src/main/java/com/netgrif/application/engine/orgstructure/groups/NextGroupService.java index 9ef276a5882..63e22d5262c 100644 --- a/src/main/java/com/netgrif/application/engine/orgstructure/groups/NextGroupService.java +++ b/src/main/java/com/netgrif/application/engine/orgstructure/groups/NextGroupService.java @@ -21,6 +21,7 @@ import com.netgrif.application.engine.workflow.domain.Task; import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.caseoutcomes.CreateCaseEventOutcome; import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams; +import com.netgrif.application.engine.workflow.domain.params.TaskParams; 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; @@ -118,8 +119,8 @@ public CreateCaseEventOutcome createGroup(String title, IUser author) { dataService.setData(initTask.getStringId(), taskData, author); try { - taskService.assignTask(author.transformToLoggedUser(), initTask.getStringId()); - taskService.finishTask(author.transformToLoggedUser(), initTask.getStringId()); + taskService.assignTask(new TaskParams(initTask, author)); + taskService.finishTask(new TaskParams(initTask, author)); } catch (TransitionNotExecutableException e) { log.error(e.getMessage()); } diff --git a/src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/DoEventTaskOutcome.java b/src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/DoEventTaskOutcome.java new file mode 100644 index 00000000000..bb8b676154e --- /dev/null +++ b/src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/DoEventTaskOutcome.java @@ -0,0 +1,14 @@ +package com.netgrif.application.engine.workflow.domain.outcomes; + +import com.netgrif.application.engine.workflow.domain.Case; +import com.netgrif.application.engine.workflow.domain.Task; +import lombok.AllArgsConstructor; +import lombok.Data; + +@Data +@AllArgsConstructor +public class DoEventTaskOutcome { + + private Task task; + private Case useCase; +} diff --git a/src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/UpdateTaskStateOutcome.java b/src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/UpdateTaskStateOutcome.java new file mode 100644 index 00000000000..822c1392da7 --- /dev/null +++ b/src/main/java/com/netgrif/application/engine/workflow/domain/outcomes/UpdateTaskStateOutcome.java @@ -0,0 +1,12 @@ +package com.netgrif.application.engine.workflow.domain.outcomes; + +import lombok.AllArgsConstructor; +import lombok.Data; + +@Data +@AllArgsConstructor +public class UpdateTaskStateOutcome { + + private boolean wasChanged; + private boolean mustBeExecuted; +} diff --git a/src/main/java/com/netgrif/application/engine/workflow/domain/params/TaskParams.java b/src/main/java/com/netgrif/application/engine/workflow/domain/params/TaskParams.java new file mode 100644 index 00000000000..85749bcf4d2 --- /dev/null +++ b/src/main/java/com/netgrif/application/engine/workflow/domain/params/TaskParams.java @@ -0,0 +1,42 @@ +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 TaskParams { + + private String taskId; + private Task task; + private Case useCase; + private IUser user; + @Builder.Default + private Map<String, String> params = new HashMap<>(); + + public TaskParams(Task task) { + this.task = task; + } + + public TaskParams(Task task, IUser user) { + this.task = task; + this.user = user; + } + + public TaskParams(String taskId) { + this.taskId = taskId; + } + + public TaskParams(String taskId, IUser user) { + this.taskId = taskId; + this.user = user; + } +} diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/FilterImportExportService.java b/src/main/java/com/netgrif/application/engine/workflow/service/FilterImportExportService.java index ed8a0ab9b5a..a9a3c9e7ec0 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/FilterImportExportService.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/FilterImportExportService.java @@ -249,7 +249,8 @@ protected Map<String, String> performImport(FilterImportExportList filterList) t // filterCase.get().getDataSet().get(FIELD_FILTER).addBehavior(IMPORT_FILTER_TRANSITION, Collections.singleton(FieldBehavior.VISIBLE)); workflowService.save(filterCase.get()); }); - taskService.assignTasks(taskService.findAllById(new ArrayList<>(importedFilterTaskIds.values())), userService.getLoggedUser()); + taskService.assignTasks(taskService.findAllById(new ArrayList<>(importedFilterTaskIds.values())), + userService.getLoggedUser(), new HashMap<>()); changeFilterField(importedFilterTaskIds.values()); return importedFilterTaskIds; } diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/MenuImportExportService.java b/src/main/java/com/netgrif/application/engine/workflow/service/MenuImportExportService.java index 9a236c18996..1a6bb14ffcc 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/MenuImportExportService.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/MenuImportExportService.java @@ -20,12 +20,12 @@ import com.netgrif.application.engine.workflow.domain.menu.MenuEntry; import com.netgrif.application.engine.workflow.domain.menu.MenuEntryRole; import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams; +import com.netgrif.application.engine.workflow.domain.params.TaskParams; import com.netgrif.application.engine.workflow.service.interfaces.*; import com.netgrif.application.engine.workflow.web.responsebodies.DataSet; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; -import org.springframework.transaction.annotation.Transactional; import javax.xml.XMLConstants; import javax.xml.transform.stream.StreamSource; @@ -179,8 +179,8 @@ public List<String> importMenu(List<Case> menuItemCases, FileFieldValue ffv, Str Task importedFilterTask = taskService.findOne(taskId); Case filterCase = workflowService.findOne(importedFilterTask.getCaseId()); try { - taskService.assignTask(importedFilterTask.getStringId()); - taskService.finishTask(importedFilterTask.getStringId()); + taskService.assignTask(new TaskParams(importedFilterTask)); + taskService.finishTask(new TaskParams(importedFilterTask)); workflowService.save(filterCase); } catch (TransitionNotExecutableException e) { log.error("Failed to execute \"import_filter\" task with id: " + taskId, e); @@ -258,7 +258,7 @@ public String createMenuItemCase(StringBuilder resultMessage, MenuEntry item, St QTask qTask = new QTask("task"); Task task = taskService.searchOne(qTask.transitionId.eq("init").and(qTask.caseId.eq(menuItemCase.getStringId()))); try { - taskService.assignTask(task, userService.getLoggedUser()); + taskService.assignTask(new TaskParams(task, userService.getLoggedUser())); // TODO: release/8.0.0 // menuItemCase.getDataSet().get(MENU_IDENTIFIER).setValue(menuIdentifier); // menuItemCase.getDataSet().get(PARENT_ID).setValue(parentId); @@ -275,8 +275,7 @@ public String createMenuItemCase(StringBuilder resultMessage, MenuEntry item, St return task.getCaseId() + "," + filterCase.getStringId() + "," + item.getUseIcon().toString(); } - @Transactional - protected MenuAndFilters loadFromXML(FileFieldValue ffv) throws IOException, IllegalMenuFileException { + private MenuAndFilters loadFromXML(FileFieldValue ffv) throws IOException, IllegalMenuFileException { File f = new File(ffv.getPath()); validateFilterXML(new FileInputStream(f)); SimpleModule module = new SimpleModule().addDeserializer(Object.class, FilterDeserializer.getInstance()); @@ -285,8 +284,7 @@ protected MenuAndFilters loadFromXML(FileFieldValue ffv) throws IOException, Ill return xmlMapper.readValue(xml, MenuAndFilters.class); } - @Transactional - protected FileFieldValue createXML(MenuAndFilters menuAndFilters, String parentId, FileField fileField) throws IOException { + private FileFieldValue createXML(MenuAndFilters menuAndFilters, String parentId, FileField fileField) throws IOException { FileFieldValue ffv = new FileFieldValue(); try { ffv.setName("menu_" + userService.getLoggedUser().getFullName().replaceAll("\\s+", "") + ".xml"); diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/TaskService.java b/src/main/java/com/netgrif/application/engine/workflow/service/TaskService.java index 0cc2c4b0ef0..bb8929f3888 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/TaskService.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/TaskService.java @@ -30,10 +30,14 @@ import com.netgrif.application.engine.utils.DateUtils; import com.netgrif.application.engine.utils.FullPageRequest; import com.netgrif.application.engine.workflow.domain.*; +import com.netgrif.application.engine.workflow.domain.outcomes.DoEventTaskOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.UpdateTaskStateOutcome; import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.EventOutcome; +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.dataoutcomes.GetDataEventOutcome; 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.TaskParams; import com.netgrif.application.engine.workflow.domain.repositories.TaskRepository; import com.netgrif.application.engine.workflow.domain.triggers.AutoTrigger; import com.netgrif.application.engine.workflow.domain.triggers.TimeTrigger; @@ -55,6 +59,7 @@ import org.springframework.data.mongodb.core.query.BasicQuery; import org.springframework.scheduling.TaskScheduler; import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; import java.time.LocalDateTime; import java.util.*; @@ -105,288 +110,308 @@ public class TaskService implements ITaskService { * todo javadoc * */ @Override + @Transactional public List<EventOutcome> executeTask(Task task, Case useCase) { log.info("[{}]: executeTask [{}] in case [{}]", useCase.getStringId(), task.getTransitionId(), useCase.getTitle()); List<EventOutcome> outcomes = new ArrayList<>(); try { log.info("assignTask [{}] in case [{}]", task.getTitle(), useCase.getTitle()); - outcomes.add(assignTask(task.getStringId())); + AssignTaskEventOutcome assignOutcome = assignTask(new TaskParams(task)); + outcomes.add(assignOutcome); log.info("getData [{}] in case [{}]", task.getTitle(), useCase.getTitle()); - outcomes.add(dataService.getData(task.getStringId(), userService.getSystem())); + GetDataEventOutcome getDataOutcome = dataService.getData(assignOutcome.getTask(), assignOutcome.getCase(), + userService.getSystem()); + outcomes.add(getDataOutcome); log.info("finishTask [{}] in case [{}]", task.getTitle(), useCase.getTitle()); - outcomes.add(finishTask(task.getStringId())); + outcomes.add(finishTask(new TaskParams(getDataOutcome.getTask()))); } catch (TransitionNotExecutableException e) { log.error("execution of task [{}] in case [{}] failed: ", task.getTitle(), useCase.getTitle(), e); } return outcomes; } + /** + * todo javadoc + * */ @Override - public List<AssignTaskEventOutcome> assignTasks(List<Task> tasks, IUser user) throws TransitionNotExecutableException { - return assignTasks(tasks, user, new HashMap<>()); - } - - @Override + @Transactional public List<AssignTaskEventOutcome> assignTasks(List<Task> tasks, IUser user, Map<String, String> params) throws TransitionNotExecutableException { List<AssignTaskEventOutcome> outcomes = new ArrayList<>(); for (Task task : tasks) { - outcomes.add(assignTask(task, user, params)); + outcomes.add( + assignTask(TaskParams.builder() + .task(task) + .user(user) + .params(params) + .build()) + ); } return outcomes; } + /** + * todo javadoc + * */ @Override - public AssignTaskEventOutcome assignTask(String taskId) throws TransitionNotExecutableException { - return assignTask(taskId, new HashMap<>()); - } + @Transactional + public AssignTaskEventOutcome assignTask(TaskParams taskParams) throws TransitionNotExecutableException { + fillMissingAttributes(taskParams); - @Override - public AssignTaskEventOutcome assignTask(String taskId, Map<String, String> params) throws TransitionNotExecutableException { - LoggedUser user = userService.getLoggedOrSystem().transformToLoggedUser(); - return assignTask(user, taskId, params); - } + Task task = taskParams.getTask(); + Case useCase = taskParams.getUseCase(); + IUser user = taskParams.getUser(); - @Override - public AssignTaskEventOutcome assignTask(LoggedUser loggedUser, String taskId) throws TransitionNotExecutableException { - return assignTask(loggedUser, taskId, new HashMap<>()); - } + Transition transition = useCase.getPetriNet().getTransition(task.getTransitionId()); - @Override - public AssignTaskEventOutcome assignTask(LoggedUser loggedUser, String taskId, Map<String, String> params) throws TransitionNotExecutableException, TaskNotFoundException { - Optional<Task> taskOptional = taskRepository.findById(taskId); - if (taskOptional.isEmpty()) { - throw new TaskNotFoundException("Could not find task with id [" + taskId + "]"); + List<EventOutcome> outcomes = new ArrayList<>(eventService.runActions(transition.getPreAssignActions(), useCase, + task, transition, taskParams.getParams())); + + if (!outcomes.isEmpty()) { + useCase = workflowService.findOne(task.getCaseId()); + task = findOne(task.getStringId()); } - IUser user = userService.getUserFromLoggedUser(loggedUser); - return assignTask(taskOptional.get(), user, params); - } - @Override - public AssignTaskEventOutcome assignTask(Task task, IUser user) throws TransitionNotExecutableException { - return assignTask(task, user, new HashMap<>()); - } + useCase = evaluateRules(useCase, task, EventType.ASSIGN, EventPhase.PRE); + DoEventTaskOutcome doOutcome = doAssignTaskToUser(user, task, transition, useCase); + useCase = doOutcome.getUseCase(); + task = doOutcome.getTask(); - @Override - public AssignTaskEventOutcome assignTask(Task task, IUser user, Map<String, String> params) throws TransitionNotExecutableException { - Case useCase = workflowService.findOne(task.getCaseId()); - Transition transition = useCase.getPetriNet().getTransition(task.getTransitionId()); - List<EventOutcome> outcomes = new ArrayList<>(eventService.runActions(transition.getPreAssignActions(), workflowService.findOne(task.getCaseId()), task, transition, params)); - useCase = workflowService.findOne(task.getCaseId()); - task = findOne(task.getStringId()); - evaluateRules(useCase.getStringId(), task, EventType.ASSIGN, EventPhase.PRE); - useCase = workflowService.findOne(task.getCaseId()); - assignTaskToUser(user, task, useCase.getStringId()); - useCase = workflowService.findOne(task.getCaseId()); historyService.save(new AssignTaskEventLog(task, useCase, EventPhase.PRE, user)); - outcomes.addAll((eventService.runActions(transition.getPostAssignActions(), workflowService.findOne(task.getCaseId()), task, transition, params))); - useCase = workflowService.findOne(task.getCaseId()); - evaluateRules(useCase.getStringId(), task, EventType.ASSIGN, EventPhase.POST); - useCase = workflowService.findOne(task.getCaseId()); + + List<EventOutcome> postEventOutcomes = eventService.runActions(transition.getPostAssignActions(), useCase, task, + transition, taskParams.getParams()); + if (!postEventOutcomes.isEmpty()) { + outcomes.addAll(postEventOutcomes); + useCase = workflowService.findOne(useCase.getStringId()); + } + + useCase = evaluateRules(useCase, task, EventType.ASSIGN, EventPhase.POST); + historyService.save(new AssignTaskEventLog(task, useCase, EventPhase.POST, user)); - AssignTaskEventOutcome outcome = new AssignTaskEventOutcome(workflowService.findOne(task.getCaseId()), task, outcomes); + AssignTaskEventOutcome outcome = new AssignTaskEventOutcome(useCase, task, outcomes); addMessageToOutcome(transition, EventType.ASSIGN, outcome); - log.info("[{}]: Task [{}] in case [{}] assigned to [{}]", useCase.getStringId(), task.getTitle(), useCase.getTitle(), user.getSelfOrImpersonated().getEmail()); + log.info("[{}]: Task [{}] in case [{}] assigned to [{}]", useCase.getStringId(), task.getTitle(), useCase.getTitle(), + user.getSelfOrImpersonated().getEmail()); return outcome; } - protected Case assignTaskToUser(IUser user, Task task, String useCaseId) throws TransitionNotExecutableException { - Case useCase = workflowService.findOne(useCaseId); - useCase.getPetriNet().initializeArcs(); + private DoEventTaskOutcome doAssignTaskToUser(IUser user, Task task, Case useCase) throws TransitionNotExecutableException { Transition transition = useCase.getPetriNet().getTransition(task.getTransitionId()); + return doAssignTaskToUser(user, task, transition, useCase); + } - log.info("[{}]: Assigning task [{}] to user [{}]", useCaseId, task.getTitle(), user.getSelfOrImpersonated().getEmail()); + private DoEventTaskOutcome doAssignTaskToUser(IUser user, Task task, Transition transition, Case useCase) throws TransitionNotExecutableException { + useCase.getPetriNet().initializeArcs(); + + log.info("[{}]: Assigning task [{}] to user [{}]", useCase.getStringId(), task.getTitle(), user.getSelfOrImpersonated().getEmail()); startExecution(transition, useCase); task.setUserId(user.getSelfOrImpersonated().getStringId()); task.setLastAssigned(LocalDateTime.now()); task.setUser(user.getSelfOrImpersonated()); - workflowService.save(useCase); + useCase = workflowService.save(useCase); save(task); - reloadTasks(workflowService.findOne(useCase.getStringId())); - return workflowService.findOne(useCase.getStringId()); - } - @Override - public List<FinishTaskEventOutcome> finishTasks(List<Task> tasks, IUser user) throws TransitionNotExecutableException { - return finishTasks(tasks, user, new HashMap<>()); + boolean anyTaskExecuted = reloadTasks(useCase); + if (anyTaskExecuted) { + useCase = workflowService.findOne(useCase.getStringId()); + } + return new DoEventTaskOutcome(task, useCase); } @Override + @Transactional public List<FinishTaskEventOutcome> finishTasks(List<Task> tasks, IUser user, Map<String, String> params) throws TransitionNotExecutableException { List<FinishTaskEventOutcome> outcomes = new ArrayList<>(); for (Task task : tasks) { - outcomes.add(finishTask(task, user, params)); + outcomes.add( + finishTask(TaskParams.builder() + .task(task) + .user(user) + .params(params) + .build()) + ); } return outcomes; } + /** + * todo javadoc + * */ @Override - public FinishTaskEventOutcome finishTask(String taskId) throws IllegalArgumentException, TransitionNotExecutableException { - return finishTask(taskId, new HashMap<>()); - } - - @Override - public FinishTaskEventOutcome finishTask(String taskId, Map<String, String> params) throws IllegalArgumentException, TransitionNotExecutableException { - LoggedUser user = userService.getLoggedOrSystem().transformToLoggedUser(); - return finishTask(user, taskId, params); - } + @Transactional + public FinishTaskEventOutcome finishTask(TaskParams taskParams) throws TransitionNotExecutableException { + fillMissingAttributes(taskParams); - @Override - public FinishTaskEventOutcome finishTask(LoggedUser loggedUser, String taskId) throws IllegalArgumentException, TransitionNotExecutableException { - return finishTask(loggedUser, taskId, new HashMap<>()); - } - - @Override - public FinishTaskEventOutcome finishTask(LoggedUser loggedUser, String taskId, Map<String, String> params) throws IllegalArgumentException, TransitionNotExecutableException { - Optional<Task> taskOptional = taskRepository.findById(taskId); - if (taskOptional.isEmpty()) { - throw new IllegalArgumentException("Could not find task with id [" + taskId + "]"); - } - Task task = taskOptional.get(); - IUser user = userService.getUserFromLoggedUser(loggedUser); + Task task = taskParams.getTask(); + Case useCase = taskParams.getUseCase(); + IUser user = taskParams.getUser(); + LoggedUser loggedUser = user.transformToLoggedUser(); // for anonymous user validation if (task.getUserId() == null) { - throw new IllegalArgumentException("Task with id=" + taskId + " is not assigned to any user."); + throw new IllegalArgumentException("Task with id=" + task.getUserId() + " is not assigned to any user."); } // TODO: 14. 4. 2017 replace with @PreAuthorize if (!task.getUserId().equals(user.getSelfOrImpersonated().getStringId()) && !loggedUser.isAnonymous()) { throw new IllegalArgumentException("User that is not assigned tried to finish task"); } - return finishTask(task, user, params); - } - - @Override - public FinishTaskEventOutcome finishTask(Task task, IUser user) throws TransitionNotExecutableException { - return finishTask(task, user, new HashMap<>()); - } - - @Override - public FinishTaskEventOutcome finishTask(Task task, IUser user, Map<String, String> params) throws TransitionNotExecutableException { - Case useCase = workflowService.findOne(task.getCaseId()); Transition transition = useCase.getPetriNet().getTransition(task.getTransitionId()); log.info("[{}]: Finishing task [{}] to user [{}]", useCase.getStringId(), task.getTitle(), user.getSelfOrImpersonated().getEmail()); validateData(transition, useCase); - List<EventOutcome> outcomes = new ArrayList<>(eventService.runActions(transition.getPreFinishActions(), workflowService.findOne(task.getCaseId()), task, transition, params)); - useCase = workflowService.findOne(task.getCaseId()); - task = findOne(task.getStringId()); - evaluateRules(useCase.getStringId(), task, EventType.FINISH, EventPhase.PRE); - useCase = workflowService.findOne(task.getCaseId()); + List<EventOutcome> outcomes = new ArrayList<>(eventService.runActions(transition.getPreFinishActions(), useCase, + task, transition, taskParams.getParams())); + if (!outcomes.isEmpty()) { + useCase = workflowService.findOne(task.getCaseId()); + task = findOne(task.getStringId()); + } + + useCase = evaluateRules(useCase, task, EventType.FINISH, EventPhase.PRE); + DoEventTaskOutcome doOutcome = doFinishTaskByAssignedUser(task, transition, useCase); + useCase = doOutcome.getUseCase(); + task = doOutcome.getTask(); - finishExecution(transition, useCase.getStringId()); - task.setLastFinished(LocalDateTime.now()); - task.setFinishedBy(task.getUserId()); - task.setUserId(null); - save(task); - reloadTasks(workflowService.findOne(task.getCaseId())); - useCase = workflowService.findOne(task.getCaseId()); historyService.save(new FinishTaskEventLog(task, useCase, EventPhase.PRE, user)); - outcomes.addAll(eventService.runActions(transition.getPostFinishActions(), workflowService.findOne(task.getCaseId()), task, transition, params)); - useCase = workflowService.findOne(task.getCaseId()); - evaluateRules(useCase.getStringId(), task, EventType.FINISH, EventPhase.POST); - useCase = workflowService.findOne(task.getCaseId()); - FinishTaskEventOutcome outcome = new FinishTaskEventOutcome(workflowService.findOne(task.getCaseId()), task, outcomes); - addMessageToOutcome(transition, EventType.FINISH, outcome); + + List<EventOutcome> postFinishOutcomes = eventService.runActions(transition.getPostFinishActions(), useCase, task, + transition, taskParams.getParams()); + if (!postFinishOutcomes.isEmpty()) { + outcomes.addAll(postFinishOutcomes); + useCase = workflowService.findOne(task.getCaseId()); + } + + useCase = evaluateRules(useCase, task, EventType.FINISH, EventPhase.POST); + historyService.save(new FinishTaskEventLog(task, useCase, EventPhase.POST, user)); - log.info("[{}]: Task [{}] in case [{}] assigned to [{}] was finished", useCase.getStringId(), task.getTitle(), useCase.getTitle(), user.getSelfOrImpersonated().getEmail()); + FinishTaskEventOutcome outcome = new FinishTaskEventOutcome(useCase, task, outcomes); + addMessageToOutcome(transition, EventType.FINISH, outcome); + + log.info("[{}]: Task [{}] in case [{}] assigned to [{}] was finished", useCase.getStringId(), task.getTitle(), + useCase.getTitle(), user.getSelfOrImpersonated().getEmail()); return outcome; } - @Override - public List<CancelTaskEventOutcome> cancelTasks(List<Task> tasks, IUser user) { - return cancelTasks(tasks, user, new HashMap<>()); + private DoEventTaskOutcome doFinishTaskByAssignedUser(Task task, Transition transition, Case useCase) throws TransitionNotExecutableException { + useCase = finishExecution(transition, useCase); + + task.setLastFinished(LocalDateTime.now()); + task.setFinishedBy(task.getUserId()); + task.setUserId(null); + save(task); + + boolean anyTaskExecuted = reloadTasks(useCase); + if (anyTaskExecuted) { + useCase = workflowService.findOne(useCase.getStringId()); + } + return new DoEventTaskOutcome(task, useCase); } @Override + @Transactional public List<CancelTaskEventOutcome> cancelTasks(List<Task> tasks, IUser user, Map<String, String> params) { List<CancelTaskEventOutcome> outcomes = new ArrayList<>(); for (Task task : tasks) { - outcomes.add(cancelTask(task, user, params)); + outcomes.add( + cancelTask(TaskParams.builder() + .task(task) + .user(user) + .params(params) + .build()) + ); } return outcomes; } + /** + * todo javadoc + * */ @Override - public CancelTaskEventOutcome cancelTask(LoggedUser loggedUser, String taskId) { - return cancelTask(loggedUser, taskId, new HashMap<>()); - } + @Transactional + public CancelTaskEventOutcome cancelTask(TaskParams taskParams) { + fillMissingAttributes(taskParams); - @Override - public CancelTaskEventOutcome cancelTask(LoggedUser loggedUser, String taskId, Map<String, String> params) { - Optional<Task> taskOptional = taskRepository.findById(taskId); - if (taskOptional.isEmpty()) { - throw new IllegalArgumentException("Could not find task with id [" + taskId + "]"); - } - IUser user = userService.getUserFromLoggedUser(loggedUser); - return cancelTask(taskOptional.get(), user, params); - } + Task task = taskParams.getTask(); + IUser user = taskParams.getUser(); + Case useCase = taskParams.getUseCase(); - @Override - public CancelTaskEventOutcome cancelTask(Task task, IUser user) { - return cancelTask(task, user, new HashMap<>()); - } - - @Override - public CancelTaskEventOutcome cancelTask(Task task, IUser user, Map<String, String> params) { - Case useCase = workflowService.findOne(task.getCaseId()); Transition transition = useCase.getPetriNet().getTransition(task.getTransitionId()); log.info("[{}]: Canceling task [{}] to user [{}]", useCase.getStringId(), task.getTitle(), user.getSelfOrImpersonated().getEmail()); - List<EventOutcome> outcomes = new ArrayList<>(eventService.runActions(transition.getPreCancelActions(), workflowService.findOne(task.getCaseId()), task, transition, params)); - useCase = workflowService.findOne(task.getCaseId()); - task = findOne(task.getStringId()); - evaluateRules(useCase.getStringId(), task, EventType.CANCEL, EventPhase.PRE); - useCase = workflowService.findOne(task.getCaseId()); - task = returnTokens(task, useCase.getStringId()); - reloadTasks(workflowService.findOne(task.getCaseId())); - useCase = workflowService.findOne(task.getCaseId()); + List<EventOutcome> outcomes = new ArrayList<>(eventService.runActions(transition.getPreCancelActions(), useCase, + task, transition, taskParams.getParams())); + if (!outcomes.isEmpty()) { + useCase = workflowService.findOne(task.getCaseId()); + task = findOne(task.getStringId()); + } + + useCase = evaluateRules(useCase, task, EventType.CANCEL, EventPhase.PRE); + DoEventTaskOutcome doOutcome = doCancelTaskToUser(task, useCase); + useCase = doOutcome.getUseCase(); + task = doOutcome.getTask(); + historyService.save(new CancelTaskEventLog(task, useCase, EventPhase.PRE, user)); - outcomes.addAll(eventService.runActions(transition.getPostCancelActions(), workflowService.findOne(task.getCaseId()), task, transition, params)); - useCase = workflowService.findOne(task.getCaseId()); - evaluateRules(useCase.getStringId(), task, EventType.CANCEL, EventPhase.POST); - useCase = workflowService.findOne(task.getCaseId()); - CancelTaskEventOutcome outcome = new CancelTaskEventOutcome(workflowService.findOne(task.getCaseId()), task); + + List<EventOutcome> postEventOutcomes = eventService.runActions(transition.getPostCancelActions(), useCase, task, + transition, taskParams.getParams()); + if (!postEventOutcomes.isEmpty()) { + outcomes.addAll(postEventOutcomes); + useCase = workflowService.findOne(task.getCaseId()); + } + + useCase = evaluateRules(useCase, task, EventType.CANCEL, EventPhase.POST); + + CancelTaskEventOutcome outcome = new CancelTaskEventOutcome(useCase, task); outcome.setOutcomes(outcomes); addMessageToOutcome(transition, EventType.CANCEL, outcome); historyService.save(new CancelTaskEventLog(task, useCase, EventPhase.POST, user)); - log.info("[{}]: Task [{}] in case [{}] assigned to [{}] was cancelled", useCase.getStringId(), task.getTitle(), useCase.getTitle(), user.getSelfOrImpersonated().getEmail()); + + log.info("[{}]: Task [{}] in case [{}] assigned to [{}] was cancelled", useCase.getStringId(), task.getTitle(), + useCase.getTitle(), user.getSelfOrImpersonated().getEmail()); return outcome; } - private Task returnTokens(Task task, String useCaseId) { - Case useCase = workflowService.findOne(useCaseId); + private DoEventTaskOutcome doCancelTaskToUser(Task task, Case useCase) { PetriNet net = useCase.getPetriNet(); + Case finalUseCase = useCase; net.getArcsOfTransition(task.getTransitionId()).stream() .filter(arc -> arc.getSource() instanceof Place) .forEach(arc -> { - arc.rollbackExecution(useCase.getConsumedTokens().get(arc.getStringId())); - useCase.getConsumedTokens().remove(arc.getStringId()); + arc.rollbackExecution(finalUseCase.getConsumedTokens().get(arc.getStringId())); + finalUseCase.getConsumedTokens().remove(arc.getStringId()); }); workflowService.updateMarking(useCase); task.setUserId(null); // TODO: NAE-1848 should this be null? task.setLastAssigned(null); + task = save(task); workflowService.save(useCase); - return task; + boolean anyTaskExecuted = reloadTasks(useCase); + if (anyTaskExecuted) { + useCase = workflowService.findOne(useCase.getStringId()); + } + + return new DoEventTaskOutcome(task, useCase); } @Override + @Transactional public DelegateTaskEventOutcome delegateTask(LoggedUser loggedUser, String delegatedId, String taskId) throws TransitionNotExecutableException { return delegateTask(loggedUser, delegatedId, taskId, new HashMap<>()); } @Override + @Transactional public DelegateTaskEventOutcome delegateTask(LoggedUser loggedUser, String delegatedId, String taskId, Map<String, String> params) throws TransitionNotExecutableException { IUser delegatedUser = userService.resolveById(delegatedId, true); IUser delegateUser = userService.getUserFromLoggedUser(loggedUser); @@ -404,11 +429,11 @@ public DelegateTaskEventOutcome delegateTask(LoggedUser loggedUser, String deleg List<EventOutcome> outcomes = new ArrayList<>(eventService.runActions(transition.getPreDelegateActions(), workflowService.findOne(task.getCaseId()), task, transition, params)); task = findOne(task.getStringId()); - evaluateRules(useCase.getStringId(), task, EventType.DELEGATE, EventPhase.PRE); + evaluateRules(workflowService.findOne(useCase.getStringId()), task, EventType.DELEGATE, EventPhase.PRE); delegate(delegatedUser, task, useCase); historyService.save(new DelegateTaskEventLog(task, useCase, EventPhase.PRE, delegateUser, delegatedUser.getStringId())); outcomes.addAll(eventService.runActions(transition.getPostDelegateActions(), workflowService.findOne(task.getCaseId()), task, transition, params)); - evaluateRules(useCase.getStringId(), task, EventType.DELEGATE, EventPhase.POST); + evaluateRules(workflowService.findOne(useCase.getStringId()), task, EventType.DELEGATE, EventPhase.POST); reloadTasks(workflowService.findOne(task.getCaseId())); @@ -420,18 +445,32 @@ public DelegateTaskEventOutcome delegateTask(LoggedUser loggedUser, String deleg return outcome; } - protected void delegate(IUser delegated, Task task, Case useCase) throws TransitionNotExecutableException { + private void delegate(IUser delegated, Task task, Case useCase) throws TransitionNotExecutableException { if (task.getUserId() != null) { task.setUserId(delegated.getStringId()); task.setUser(delegated); save(task); } else { - assignTaskToUser(delegated, task, useCase.getStringId()); + doAssignTaskToUser(delegated, task, useCase); + } + } + + private void fillMissingAttributes(TaskParams taskParams) { + if (taskParams.getTask() == null) { + Task task = findOne(taskParams.getTaskId()); + taskParams.setTask(task); + } + if (taskParams.getUseCase() == null) { + Case useCase = workflowService.findOne(taskParams.getTask().getCaseId()); + taskParams.setUseCase(useCase); + } + if (taskParams.getUser() == null) { + IUser user = userService.getLoggedOrSystem(); + taskParams.setUser(user); } } - protected Case evaluateRules(String caseId, Task task, EventType eventType, EventPhase eventPhase) { - Case useCase = workflowService.findOne(caseId); + private Case evaluateRules(Case useCase, Task task, EventType eventType, EventPhase eventPhase) { log.info("[{}]: Task [{}] in case [{}] evaluating rules of event {} of phase {}", useCase.getStringId(), task.getTitle(), useCase.getTitle(), eventType.name(), eventPhase.name()); int rulesExecuted = ruleEngine.evaluateRules(useCase, task, TransitionEventFact.of(task, eventType, eventPhase)); if (rulesExecuted == 0) { @@ -456,7 +495,8 @@ protected Case evaluateRules(String caseId, Task task, EventType eventType, Even * </table> */ @Override - public void reloadTasks(Case useCase) { + @Transactional + public boolean reloadTasks(Case useCase) { log.info("[{}]: Reloading tasks in [{}]", useCase.getStringId(), useCase.getTitle()); List<String> taskIds = useCase.getTasks().values().stream() .map(taskPair -> taskPair.getTaskId().toString()) @@ -464,7 +504,12 @@ public void reloadTasks(Case useCase) { Optional<Task> autoTriggerTaskOpt = reloadAndSaveTasks((List<Task>) taskRepository.findAllById(taskIds), useCase); - autoTriggerTaskOpt.ifPresent(task -> executeTask(task, workflowService.findOne(useCase.getStringId()))); + if (autoTriggerTaskOpt.isPresent()) { + executeTask(autoTriggerTaskOpt.get(), workflowService.findOne(useCase.getStringId())); + return true; + } else { + return false; + } } /** @@ -473,13 +518,18 @@ public void reloadTasks(Case useCase) { private Optional<Task> reloadAndSaveTasks(List<Task> tasks, Case useCase) { Task autoTriggered = null; PetriNet net = useCase.getPetriNet(); + List<Task> changedTasks = new ArrayList<>(); for (Task task : tasks) { Transition transition = net.getTransition(task.getTransitionId()); - if (updateStateOfTask(task, transition, net)) { + UpdateTaskStateOutcome updateTaskStateOutcome = updateStateOfTask(task, transition, net); + if (updateTaskStateOutcome.isMustBeExecuted()) { autoTriggered = task; } + if (updateTaskStateOutcome.isWasChanged()) { + changedTasks.add(task); + } } - save(tasks); + save(changedTasks); return autoTriggered == null ? Optional.empty() : Optional.of(autoTriggered); } @@ -563,13 +613,15 @@ private Task createTaskFromTransition(Transition transition, Case useCase) { * todo javadoc * returns true if it is autotrigger * */ - private boolean updateStateOfTask(Task task, Transition transition, PetriNet net) { + private UpdateTaskStateOutcome updateStateOfTask(Task task, Transition transition, PetriNet net) { if (isExecutable(transition, net)) { + boolean willBeChanged = task.getState() != State.ENABLED; task.setState(State.ENABLED); - return task.isAutoTriggered(); + return new UpdateTaskStateOutcome(willBeChanged, task.isAutoTriggered()); } else { + boolean willBeChanged = task.getState() != State.DISABLED; task.setState(State.DISABLED); - return false; + return new UpdateTaskStateOutcome(willBeChanged, false); } } @@ -585,13 +637,12 @@ private boolean isExecutable(Transition transition, PetriNet net) { .allMatch(Arc::isExecutable); } - private void finishExecution(Transition transition, String useCaseId) throws TransitionNotExecutableException { - Case useCase = workflowService.findOne(useCaseId); - log.info("[{}]: Finish execution of task [{}] in case [{}]", useCaseId, transition.getTitle(), useCase.getTitle()); + private Case finishExecution(Transition transition, Case useCase) throws TransitionNotExecutableException { + log.info("[{}]: Finish execution of task [{}] in case [{}]", useCase.getStringId(), transition.getTitle(), useCase.getTitle()); execute(transition, useCase, arc -> arc.getSource().equals(transition)); Supplier<Stream<Arc>> arcStreamSupplier = () -> useCase.getPetriNet().getArcsOfTransition(transition.getStringId()).stream(); arcStreamSupplier.get().filter(arc -> useCase.getConsumedTokens().containsKey(arc.getStringId())).forEach(arc -> useCase.getConsumedTokens().remove(arc.getStringId())); - workflowService.save(useCase); + return workflowService.save(useCase); } private void startExecution(Transition transition, Case useCase) throws TransitionNotExecutableException { @@ -599,7 +650,7 @@ private void startExecution(Transition transition, Case useCase) throws Transiti execute(transition, useCase, arc -> arc.getDestination().equals(transition)); } - protected void execute(Transition transition, Case useCase, Predicate<Arc> predicate) throws TransitionNotExecutableException { + private void execute(Transition transition, Case useCase, Predicate<Arc> predicate) throws TransitionNotExecutableException { Supplier<Stream<Arc>> filteredSupplier = () -> useCase.getPetriNet().getArcsOfTransition(transition.getStringId()).stream().filter(predicate); if (!filteredSupplier.get().allMatch(Arc::isExecutable)) { @@ -813,9 +864,9 @@ public Task resolveUserRef(Task task, Case useCase) { return; } List<String> userIds = getExistingUsers(userListField.getValue().getValue()); - if (userIds != null && userIds.size() != 0 && permission.containsKey(RolePermission.VIEW) && !permission.get(RolePermission.VIEW)) { + if (userIds != null && !userIds.isEmpty() && permission.containsKey(RolePermission.VIEW) && !permission.get(RolePermission.VIEW)) { task.getNegativeViewUsers().addAll(userIds); - } else if (userIds != null && userIds.size() != 0) { + } else if (userIds != null && !userIds.isEmpty()) { task.addUsers(new HashSet<>(userIds), permission); } }); diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/interfaces/ITaskService.java b/src/main/java/com/netgrif/application/engine/workflow/service/interfaces/ITaskService.java index 685d1dade0e..5dc7c1c032e 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/interfaces/ITaskService.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/interfaces/ITaskService.java @@ -5,7 +5,6 @@ import com.netgrif.application.engine.petrinet.domain.throwable.TransitionNotExecutableException; import com.netgrif.application.engine.workflow.domain.Case; import com.netgrif.application.engine.workflow.domain.Task; -import com.netgrif.application.engine.workflow.domain.TaskNotFoundException; import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.EventOutcome; import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.dataoutcomes.SetDataEventOutcome; import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.taskoutcomes.AssignTaskEventOutcome; @@ -13,6 +12,7 @@ import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.taskoutcomes.DelegateTaskEventOutcome; import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.taskoutcomes.FinishTaskEventOutcome; import com.netgrif.application.engine.workflow.domain.outcomes.CreateTasksOutcome; +import com.netgrif.application.engine.workflow.domain.params.TaskParams; import com.netgrif.application.engine.workflow.web.requestbodies.TaskSearchRequest; import com.netgrif.application.engine.workflow.web.responsebodies.TaskReference; import org.springframework.data.domain.Page; @@ -25,7 +25,7 @@ // TODO: release/8.0.0 remove LoggedUser, create TaskEventContext class to merge all params public interface ITaskService { - void reloadTasks(Case useCase); + boolean reloadTasks(Case useCase); CreateTasksOutcome createAndSetTasksInCase(Case useCase); @@ -55,49 +55,17 @@ public interface ITaskService { List<EventOutcome> executeTask(Task task, Case useCase); - List<FinishTaskEventOutcome> finishTasks(List<Task> tasks, IUser user) throws TransitionNotExecutableException; - List<FinishTaskEventOutcome> finishTasks(List<Task> tasks, IUser user, Map<String, String> params) throws TransitionNotExecutableException; - FinishTaskEventOutcome finishTask(Task task, IUser user) throws TransitionNotExecutableException; - - FinishTaskEventOutcome finishTask(Task task, IUser user, Map<String, String> params) throws TransitionNotExecutableException; - - FinishTaskEventOutcome finishTask(LoggedUser loggedUser, String taskId) throws IllegalArgumentException, TransitionNotExecutableException; - - FinishTaskEventOutcome finishTask(LoggedUser loggedUser, String taskId, Map<String, String> params) throws IllegalArgumentException, TransitionNotExecutableException; - - FinishTaskEventOutcome finishTask(String taskId) throws IllegalArgumentException, TransitionNotExecutableException; - - FinishTaskEventOutcome finishTask(String taskId, Map<String, String> params) throws IllegalArgumentException, TransitionNotExecutableException; - - List<AssignTaskEventOutcome> assignTasks(List<Task> tasks, IUser user) throws TransitionNotExecutableException; + FinishTaskEventOutcome finishTask(TaskParams taskParams) throws TransitionNotExecutableException; List<AssignTaskEventOutcome> assignTasks(List<Task> tasks, IUser user, Map<String, String> params) throws TransitionNotExecutableException; - AssignTaskEventOutcome assignTask(Task task, IUser user) throws TransitionNotExecutableException; - - AssignTaskEventOutcome assignTask(Task task, IUser user, Map<String, String> params) throws TransitionNotExecutableException; - - AssignTaskEventOutcome assignTask(LoggedUser loggedUser, String taskId) throws TransitionNotExecutableException, TaskNotFoundException; - - AssignTaskEventOutcome assignTask(LoggedUser loggedUser, String taskId, Map<String, String> params) throws TransitionNotExecutableException, TaskNotFoundException; - - AssignTaskEventOutcome assignTask(String taskId) throws TransitionNotExecutableException; - - AssignTaskEventOutcome assignTask(String taskId, Map<String, String> params) throws TransitionNotExecutableException; - - List<CancelTaskEventOutcome> cancelTasks(List<Task> tasks, IUser user); + AssignTaskEventOutcome assignTask(TaskParams taskParams) throws TransitionNotExecutableException; List<CancelTaskEventOutcome> cancelTasks(List<Task> tasks, IUser user, Map<String, String> params); - CancelTaskEventOutcome cancelTask(Task task, IUser user); - - CancelTaskEventOutcome cancelTask(Task task, IUser user, Map<String, String> params); - - CancelTaskEventOutcome cancelTask(LoggedUser loggedUser, String taskId); - - CancelTaskEventOutcome cancelTask(LoggedUser loggedUser, String taskId, Map<String, String> params); + CancelTaskEventOutcome cancelTask(TaskParams taskParams); // TODO: release/8.0.0 delegate is deprecated DelegateTaskEventOutcome delegateTask(LoggedUser loggedUser, String delegatedId, String taskId) throws TransitionNotExecutableException; diff --git a/src/main/java/com/netgrif/application/engine/workflow/web/AbstractTaskController.java b/src/main/java/com/netgrif/application/engine/workflow/web/AbstractTaskController.java index a719a0402d4..7a04ddf509a 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/web/AbstractTaskController.java +++ b/src/main/java/com/netgrif/application/engine/workflow/web/AbstractTaskController.java @@ -11,6 +11,7 @@ import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.dataoutcomes.SetDataEventOutcome; import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.response.EventOutcomeWithMessage; import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.response.EventOutcomeWithMessageResource; +import com.netgrif.application.engine.workflow.domain.params.TaskParams; import com.netgrif.application.engine.workflow.service.FileFieldInputStream; import com.netgrif.application.engine.workflow.service.interfaces.IDataService; import com.netgrif.application.engine.workflow.service.interfaces.ITaskService; @@ -89,7 +90,11 @@ public TaskResource getOne(String taskId, Locale locale) { public EntityModel<EventOutcomeWithMessage> assign(LoggedUser loggedUser, String taskId) { try { - return EventOutcomeWithMessageResource.successMessage("LocalisedTask " + taskId + " assigned to " + loggedUser.getFullName(), taskService.assignTask(loggedUser, taskId)); + TaskParams taskParams = TaskParams.builder() + .taskId(taskId) + .user(loggedUser.transformToUser()) + .build(); + return EventOutcomeWithMessageResource.successMessage("LocalisedTask " + taskId + " assigned to " + loggedUser.getFullName(), taskService.assignTask(taskParams)); } catch (TransitionNotExecutableException e) { log.error("Assigning task [{}] failed: ", taskId, e); return EventOutcomeWithMessageResource.errorMessage("LocalisedTask " + taskId + " cannot be assigned"); @@ -107,7 +112,11 @@ public EntityModel<EventOutcomeWithMessage> delegate(LoggedUser loggedUser, Stri public EntityModel<EventOutcomeWithMessage> finish(LoggedUser loggedUser, String taskId) { try { - return EventOutcomeWithMessageResource.successMessage("LocalisedTask " + taskId + " finished", taskService.finishTask(loggedUser, taskId)); + TaskParams taskParams = TaskParams.builder() + .taskId(taskId) + .user(loggedUser.transformToUser()) + .build(); + return EventOutcomeWithMessageResource.successMessage("LocalisedTask " + taskId + " finished", taskService.finishTask(taskParams)); } catch (Exception e) { log.error("Finishing task [{}] failed: ", taskId, e); if (e instanceof IllegalArgumentWithChangedFieldsException) { @@ -120,7 +129,11 @@ public EntityModel<EventOutcomeWithMessage> finish(LoggedUser loggedUser, String public EntityModel<EventOutcomeWithMessage> cancel(LoggedUser loggedUser, String taskId) { try { - return EventOutcomeWithMessageResource.successMessage("LocalisedTask " + taskId + " canceled", taskService.cancelTask(loggedUser, taskId)); + TaskParams taskParams = TaskParams.builder() + .taskId(taskId) + .user(loggedUser.transformToUser()) + .build(); + return EventOutcomeWithMessageResource.successMessage("LocalisedTask " + taskId + " canceled", taskService.cancelTask(taskParams)); } catch (Exception e) { log.error("Canceling task [{}] failed: ", taskId, e); if (e instanceof IllegalArgumentWithChangedFieldsException) { diff --git a/src/main/resources/petriNets/engine-processes/import_filters.xml b/src/main/resources/petriNets/engine-processes/import_filters.xml index ba4f173f298..ebb3a505d97 100644 --- a/src/main/resources/petriNets/engine-processes/import_filters.xml +++ b/src/main/resources/petriNets/engine-processes/import_filters.xml @@ -136,7 +136,7 @@ <action> importedFilters: f.imported_filters; - taskService.finishTasks(taskService.findAllById(importedFilters.value), userService.getLoggedUser()) + taskService.finishTasks(taskService.findAllById(importedFilters.value), userService.getLoggedUser(), new HashMap<>()) change importedFilters value { [] } </action> </actions> diff --git a/src/test/groovy/com/netgrif/application/engine/Async.groovy b/src/test/groovy/com/netgrif/application/engine/Async.groovy index fa7758e6bd7..37b7f027c4b 100644 --- a/src/test/groovy/com/netgrif/application/engine/Async.groovy +++ b/src/test/groovy/com/netgrif/application/engine/Async.groovy @@ -3,11 +3,11 @@ package com.netgrif.application.engine import com.netgrif.application.engine.startup.ImportHelper import com.netgrif.application.engine.workflow.domain.State import com.netgrif.application.engine.workflow.domain.Task +import com.netgrif.application.engine.workflow.domain.params.TaskParams import com.netgrif.application.engine.workflow.service.interfaces.ITaskService import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowService import groovy.transform.CompileStatic import groovy.util.logging.Slf4j -import org.junit.Ignore import org.junit.jupiter.api.Test import org.junit.jupiter.api.extension.ExtendWith import org.springframework.beans.factory.annotation.Autowired @@ -44,8 +44,8 @@ class Async { def t1Id = $case.getTaskStringId("t1") - taskService.assignTask(t1Id) - taskService.finishTask(t1Id) + taskService.assignTask(new TaskParams(t1Id)) + taskService.finishTask(new TaskParams(t1Id)) $case = workflowService.findOne($case.stringId) List<Task> tasks = taskService.findAllByCase($case.stringId) diff --git a/src/test/groovy/com/netgrif/application/engine/action/MenuItemApiTest.groovy b/src/test/groovy/com/netgrif/application/engine/action/MenuItemApiTest.groovy index 0ce465a0026..2815aac994b 100644 --- a/src/test/groovy/com/netgrif/application/engine/action/MenuItemApiTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/action/MenuItemApiTest.groovy @@ -18,6 +18,7 @@ import com.netgrif.application.engine.workflow.domain.Case import com.netgrif.application.engine.workflow.domain.QCase import com.netgrif.application.engine.workflow.domain.menu.MenuItemConstants import com.netgrif.application.engine.workflow.domain.params.DeleteCaseParams +import com.netgrif.application.engine.workflow.domain.params.TaskParams 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 @@ -245,26 +246,26 @@ class MenuItemApiTest { String newIdentifier = "new_identifier" String duplicateTaskId = testFolder.tasks.find { it.transition == "duplicate_item" }.task - taskService.assignTask(duplicateTaskId) + taskService.assignTask(new TaskParams(duplicateTaskId)) assertThrows(IllegalArgumentException.class, () -> { testFolder.dataSet[MenuItemConstants.PREFERENCE_ITEM_FIELD_DUPLICATE_TITLE.attributeId].value = new I18nString("") testFolder.dataSet[MenuItemConstants.PREFERENCE_ITEM_FIELD_DUPLICATE_IDENTIFIER.attributeId].value = newIdentifier testFolder = workflowService.save(testFolder) - taskService.finishTask(duplicateTaskId) + taskService.finishTask(new TaskParams(duplicateTaskId)) }) assertThrows(IllegalArgumentException.class, () -> { testFolder.dataSet[MenuItemConstants.PREFERENCE_ITEM_FIELD_DUPLICATE_TITLE.attributeId].value = new I18nString(newTitle) testFolder.dataSet[MenuItemConstants.PREFERENCE_ITEM_FIELD_DUPLICATE_IDENTIFIER.attributeId].value = "new_menu_item" testFolder = workflowService.save(testFolder) - taskService.finishTask(duplicateTaskId) + taskService.finishTask(new TaskParams(duplicateTaskId)) }) testFolder.dataSet[MenuItemConstants.PREFERENCE_ITEM_FIELD_DUPLICATE_TITLE.attributeId].value = new I18nString(newTitle) testFolder.dataSet[MenuItemConstants.PREFERENCE_ITEM_FIELD_DUPLICATE_IDENTIFIER.attributeId].value = newIdentifier testFolder = workflowService.save(testFolder) - taskService.finishTask(duplicateTaskId) + taskService.finishTask(new TaskParams(duplicateTaskId)) Case duplicated = workflowService.searchOne(QCase.case$.processIdentifier.eq("preference_item").and(QCase.case$.dataSet.get(MenuItemConstants.PREFERENCE_ITEM_FIELD_IDENTIFIER.attributeId).value.eq(newIdentifier))) assert duplicated != null diff --git a/src/test/groovy/com/netgrif/application/engine/auth/TaskAuthorizationServiceTest.groovy b/src/test/groovy/com/netgrif/application/engine/auth/TaskAuthorizationServiceTest.groovy index 30fdbc99749..2750da0cea6 100644 --- a/src/test/groovy/com/netgrif/application/engine/auth/TaskAuthorizationServiceTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/auth/TaskAuthorizationServiceTest.groovy @@ -20,6 +20,7 @@ import com.netgrif.application.engine.workflow.domain.Case import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome 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.TaskParams import com.netgrif.application.engine.workflow.service.interfaces.IDataService import com.netgrif.application.engine.workflow.service.interfaces.ITaskAuthorizationService import com.netgrif.application.engine.workflow.service.interfaces.ITaskService @@ -390,7 +391,11 @@ class TaskAuthorizationServiceTest { Case case_ = workflowService.createCase(createCaseParams).getCase() String taskId = case_.getTaskStringId("1") - taskService.assignTask(testUser.transformToLoggedUser(), taskId) + TaskParams taskParams = TaskParams.builder() + .taskId(taskId) + .user(testUser) + .build() + taskService.assignTask(taskParams) assert taskAuthorizationService.canCallFinish(testUser.transformToLoggedUser(), taskId) userService.removeRole(testUser, positiveRole.getStringId()) DeleteCaseParams deleteCaseParams = DeleteCaseParams.builder() @@ -412,7 +417,11 @@ class TaskAuthorizationServiceTest { Case case_ = workflowService.createCase(createCaseParams).getCase() String taskId = case_.getTaskStringId("1") - taskService.assignTask(testUser.transformToLoggedUser(), taskId) + TaskParams taskParams = TaskParams.builder() + .taskId(taskId) + .user(testUser) + .build() + taskService.assignTask(taskParams) assert !taskAuthorizationService.canCallFinish(testUser.transformToLoggedUser(), taskId) userService.removeRole(testUser, negativeRole.getStringId()) DeleteCaseParams deleteCaseParams = DeleteCaseParams.builder() @@ -436,7 +445,11 @@ class TaskAuthorizationServiceTest { ] as Map<String, Field<?>>), superCreator.getSuperUser()).getCase() sleep(4000) - taskService.assignTask(testUser.transformToLoggedUser(), taskId) + TaskParams taskParams = TaskParams.builder() + .taskId(taskId) + .user(testUser) + .build() + taskService.assignTask(taskParams) assert taskAuthorizationService.canCallFinish(testUser.transformToLoggedUser(), taskId) DeleteCaseParams deleteCaseParams = DeleteCaseParams.builder() .useCase(case_) @@ -459,7 +472,11 @@ class TaskAuthorizationServiceTest { ] as Map<String, Field<?>>), superCreator.getSuperUser()).getCase() sleep(4000) - taskService.assignTask(testUser.transformToLoggedUser(), taskId) + TaskParams taskParams = TaskParams.builder() + .taskId(taskId) + .user(testUser) + .build() + taskService.assignTask(taskParams) assert !taskAuthorizationService.canCallFinish(testUser.transformToLoggedUser(), taskId) DeleteCaseParams deleteCaseParams = DeleteCaseParams.builder() .useCase(case_) @@ -484,7 +501,11 @@ class TaskAuthorizationServiceTest { ] as Map<String, Field<?>>), superCreator.getSuperUser()).getCase() sleep(4000) - taskService.assignTask(testUser.transformToLoggedUser(), taskId) + TaskParams taskParams = TaskParams.builder() + .taskId(taskId) + .user(testUser) + .build() + taskService.assignTask(taskParams) assert taskAuthorizationService.canCallFinish(testUser.transformToLoggedUser(), taskId) userService.removeRole(testUser, positiveRole.getStringId()) DeleteCaseParams deleteCaseParams = DeleteCaseParams.builder() diff --git a/src/test/groovy/com/netgrif/application/engine/export/service/ExportServiceTest.groovy b/src/test/groovy/com/netgrif/application/engine/export/service/ExportServiceTest.groovy index 8a2a1212b11..889756012e2 100644 --- a/src/test/groovy/com/netgrif/application/engine/export/service/ExportServiceTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/export/service/ExportServiceTest.groovy @@ -1,6 +1,7 @@ package com.netgrif.application.engine.export.service import com.netgrif.application.engine.TestHelper +import com.netgrif.application.engine.auth.domain.IUser import com.netgrif.application.engine.auth.service.interfaces.IUserService import com.netgrif.application.engine.elastic.web.requestbodies.ElasticTaskSearchRequest import com.netgrif.application.engine.export.service.interfaces.IExportService @@ -12,6 +13,7 @@ import com.netgrif.application.engine.startup.ImportHelper import com.netgrif.application.engine.workflow.domain.Case import com.netgrif.application.engine.workflow.domain.QTask import com.netgrif.application.engine.workflow.domain.Task +import com.netgrif.application.engine.workflow.domain.params.TaskParams import com.netgrif.application.engine.workflow.domain.repositories.TaskRepository import com.netgrif.application.engine.workflow.service.interfaces.ITaskService import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowService @@ -24,7 +26,7 @@ import org.junit.jupiter.api.extension.ExtendWith import org.springframework.beans.factory.annotation.Autowired import org.springframework.boot.test.context.SpringBootTest import org.springframework.test.context.ActiveProfiles -import org.springframework.test.context.junit.jupiter.SpringExtension; +import org.springframework.test.context.junit.jupiter.SpringExtension @SpringBootTest @@ -79,14 +81,15 @@ class ExportServiceTest { @Order(2) void testCaseMongoExport() { String exportTask = mainCase.getTaskStringId("t1") - taskService.assignTask(userService.findByEmail("super@netgrif.com", false).transformToLoggedUser(), exportTask) + IUser user = userService.findByEmail("super@netgrif.com", false) + taskService.assignTask(new TaskParams(exportTask, user)) File csvFile = new File("src/test/resources/csv/case_mongo_export.csv") assert csvFile.readLines().size() == 11 String[] headerSplit = csvFile.readLines()[0].split(",") assert (headerSplit.contains("immediate_multichoice") && headerSplit.contains("immediate_number") && !headerSplit.contains("text")) - taskService.cancelTask(userService.getLoggedOrSystem().transformToLoggedUser(), exportTask) + taskService.cancelTask(new TaskParams(exportTask, user)) } @Test @@ -94,21 +97,23 @@ class ExportServiceTest { void testCaseElasticExport() { Thread.sleep(5000) //Elastic wait String exportTask = mainCase.getTaskStringId("t2") - taskService.assignTask(userService.findByEmail("super@netgrif.com", false).transformToLoggedUser(), exportTask) + IUser user = userService.findByEmail("super@netgrif.com", false) + taskService.assignTask(new TaskParams(exportTask, user)) File csvFile = new File("src/test/resources/csv/case_elastic_export.csv") assert csvFile.readLines().size() == 11 String[] headerSplit = csvFile.readLines()[0].split(",") assert (headerSplit.contains("text") && !headerSplit.contains("immediate_multichoice") && !headerSplit.contains("immediate_number")) - taskService.cancelTask(userService.getLoggedOrSystem().transformToLoggedUser(), exportTask) + taskService.cancelTask(new TaskParams(exportTask, userService.getLoggedOrSystem())) } @Test @Order(4) void testTaskMongoExport() { String exportTask = mainCase.getTaskStringId("t3") - taskService.assignTask(userService.findByEmail("super@netgrif.com", false).transformToLoggedUser(), exportTask) + IUser user = userService.findByEmail("super@netgrif.com", false) + taskService.assignTask(new TaskParams(exportTask, user)) File csvFile = new File("src/test/resources/csv/task_mongo_export.csv") assert csvFile.readLines().size() == 11 String[] headerSplit = csvFile.readLines()[0].split(",") @@ -116,7 +121,7 @@ class ExportServiceTest { && headerSplit.contains("immediate_number") && headerSplit.contains("text") && !headerSplit.contains("no_export")) - taskService.cancelTask(userService.getLoggedOrSystem().transformToLoggedUser(), exportTask) + taskService.cancelTask(new TaskParams(exportTask, userService.getLoggedOrSystem())) } @Test @@ -125,7 +130,8 @@ class ExportServiceTest { void testTaskElasticExport() { Thread.sleep(10000) //Elastic wait String exportTask = mainCase.getTaskStringId("t4") - taskService.assignTask(userService.findByEmail("super@netgrif.com", false).transformToLoggedUser(), exportTask) + IUser user = userService.findByEmail("super@netgrif.com", false) + taskService.assignTask(new TaskParams(exportTask, user)) Thread.sleep(20000) //Elastic wait def processId = petriNetService.getNewestVersionByIdentifier("export_test").stringId @@ -141,14 +147,15 @@ class ExportServiceTest { && headerSplit.contains("immediate_number") && !headerSplit.contains("text") && !headerSplit.contains("no_export")) - taskService.cancelTask(userService.findByEmail("super@netgrif.com", false).transformToLoggedUser(), exportTask) + taskService.cancelTask(new TaskParams(exportTask, user)) } @Test void buildDefaultCsvTaskHeaderTest(){ def processId = petriNetService.getNewestVersionByIdentifier("export_test").stringId String exportTask = mainCase.getTaskStringId("t4") - taskService.assignTask(userService.findByEmail("super@netgrif.com", false).transformToLoggedUser(), exportTask) + IUser user = userService.findByEmail("super@netgrif.com", false) + taskService.assignTask(new TaskParams(exportTask, user)) List<Task> task = taskRepository.findAll(QTask.task.processId.eq(processId).and(QTask.task.transitionId.eq("t4"))) as List<Task> Set<String> header = exportService.buildDefaultCsvTaskHeader(task) assert header != null diff --git a/src/test/groovy/com/netgrif/application/engine/filters/FilterImportExportTest.groovy b/src/test/groovy/com/netgrif/application/engine/filters/FilterImportExportTest.groovy index bb9716a1deb..fb7eb5cd27d 100644 --- a/src/test/groovy/com/netgrif/application/engine/filters/FilterImportExportTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/filters/FilterImportExportTest.groovy @@ -17,6 +17,7 @@ import com.netgrif.application.engine.startup.FilterRunner import com.netgrif.application.engine.startup.ImportHelper import com.netgrif.application.engine.workflow.domain.* import com.netgrif.application.engine.workflow.domain.filter.FilterImportExportList +import com.netgrif.application.engine.workflow.domain.params.TaskParams import com.netgrif.application.engine.workflow.service.UserFilterSearchService import com.netgrif.application.engine.workflow.service.interfaces.IDataService import com.netgrif.application.engine.workflow.service.interfaces.IFilterImportExportService @@ -157,7 +158,7 @@ class FilterImportExportTest { this.dataService.setData(importTask, new DataSet([ (IMPORTED_FILTERS_FIELD): new TaskField(rawValue: importedTasksIds) ] as Map<String, Field<?>>)) - this.taskService.finishTask(importTask, dummyUser) + this.taskService.finishTask(new TaskParams(importTask, dummyUser)) Thread.sleep(1000) filterCases = this.userFilterSearchService.autocompleteFindFilters("") List<String> filterCasesNames = filterCases.stream().map({ filterCase -> filterCase.title }).collect(Collectors.toList()) diff --git a/src/test/groovy/com/netgrif/application/engine/history/HistoryServiceTest.groovy b/src/test/groovy/com/netgrif/application/engine/history/HistoryServiceTest.groovy index f99be804732..db78a4d92c7 100644 --- a/src/test/groovy/com/netgrif/application/engine/history/HistoryServiceTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/history/HistoryServiceTest.groovy @@ -11,6 +11,7 @@ import com.netgrif.application.engine.startup.SuperCreator import com.netgrif.application.engine.workflow.domain.Case import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams +import com.netgrif.application.engine.workflow.domain.params.TaskParams 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 @@ -75,7 +76,7 @@ class HistoryServiceTest { int count = historyService.findAllAssignTaskEventLogsByCaseId(caze.getStringId()).size() assert count == 0 String task = caze.tasks.values().find { it.transitionId == "1" }.taskStringId - taskService.assignTask(superCreator.getLoggedSuper(), task) + taskService.assignTask(new TaskParams(task, superCreator.getSuperUser())) Thread.sleep(1000) // HistoryService::save is @Async assert historyService.findAllAssignTaskEventLogsByCaseId(caze.getStringId()).size() == count + 2 // 2 PRE POST } @@ -92,9 +93,9 @@ class HistoryServiceTest { int count = historyService.findAllFinishTaskEventLogsByCaseId(caze.getStringId()).size() assert count == 0 String task = caze.tasks.values().find { it.transitionId == "1" }.taskStringId - taskService.assignTask(superCreator.getLoggedSuper(), task) + taskService.assignTask(new TaskParams(task, superCreator.getSuperUser())) assert historyService.findAllFinishTaskEventLogsByCaseId(caze.getStringId()).size() == count - taskService.finishTask(superCreator.getLoggedSuper(), task) + taskService.finishTask(new TaskParams(task, superCreator.getSuperUser())) Thread.sleep(1000) // HistoryService::save is @Async assert historyService.findAllFinishTaskEventLogsByCaseId(caze.getStringId()).size() == count + 2 // 2 PRE POST } diff --git a/src/test/groovy/com/netgrif/application/engine/impersonation/ImpersonationServiceTest.groovy b/src/test/groovy/com/netgrif/application/engine/impersonation/ImpersonationServiceTest.groovy index e0578a3d8a0..5d30763d034 100644 --- a/src/test/groovy/com/netgrif/application/engine/impersonation/ImpersonationServiceTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/impersonation/ImpersonationServiceTest.groovy @@ -22,6 +22,7 @@ import com.netgrif.application.engine.startup.ImpersonationRunner import com.netgrif.application.engine.startup.ImportHelper import com.netgrif.application.engine.workflow.domain.Case import com.netgrif.application.engine.workflow.domain.Task +import com.netgrif.application.engine.workflow.domain.params.TaskParams import com.netgrif.application.engine.workflow.service.interfaces.* import com.netgrif.application.engine.workflow.web.requestbodies.TaskSearchRequest import com.netgrif.application.engine.workflow.web.requestbodies.taskSearch.TaskSearchCaseRequest @@ -119,7 +120,7 @@ class ImpersonationServiceTest { void before() { testHelper.truncateDbs() - SessionRepositoryFilter<?> filter = wac.getBean(SessionRepositoryFilter.class); + SessionRepositoryFilter<?> filter = wac.getBean(SessionRepositoryFilter.class) mvc = MockMvcBuilders.webAppContextSetup(wac).addFilters(filter).apply(springSecurity()).build() testNet = helper.createNet("impersonation_test.xml").get() @@ -218,7 +219,11 @@ class ImpersonationServiceTest { assert tasks.content[0].stringId == testTask1.stringId assert taskAuthorizationService.canCallAssign(userService.loggedUserFromContext, testTask1.stringId) - taskService.assignTask(userService.loggedUser.transformToLoggedUser(), testTask1.stringId) + TaskParams taskParams = TaskParams.builder() + .taskId(testTask1.stringId) + .user(userService.loggedUser) + .build() + taskService.assignTask(taskParams) testTask1 = reloadTask(testTask1) assert testTask1.userId == user2.stringId @@ -226,7 +231,11 @@ class ImpersonationServiceTest { assert taskAuthorizationService.canCallSaveFile(userService.loggedUserFromContext, testTask1.stringId) assert taskAuthorizationService.canCallFinish(userService.loggedUserFromContext, testTask1.stringId) - taskService.finishTask(userService.loggedUser.transformToLoggedUser(), testTask1.stringId) + taskParams = TaskParams.builder() + .taskId(testTask1.stringId) + .user(userService.loggedUser) + .build() + taskService.finishTask(taskParams) } @Test @@ -317,8 +326,16 @@ class ImpersonationServiceTest { ((MultichoiceMapField) caze.dataSet.get("impersonated_authorities")).options = (caze.dataSet.get("impersonated_authorities").rawValue as List).collectEntries { [(it): new I18nString(it as String)] } as Map<String, I18nString> caze = workflowService.save(caze) def initTask = caze.getTaskStringId("t2") - taskService.assignTask(userService.system.transformToLoggedUser(), initTask) - taskService.finishTask(userService.system.transformToLoggedUser(), initTask) + TaskParams taskParams = TaskParams.builder() + .taskId(initTask) + .user(userService.system) + .build() + taskService.assignTask(taskParams) + taskParams = TaskParams.builder() + .taskId(initTask) + .user(userService.system) + .build() + taskService.finishTask(taskParams) return workflowService.findOne(caze.stringId) } diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/EventTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/EventTest.groovy index 6efc963cf1d..f11a1de7217 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/EventTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/EventTest.groovy @@ -69,7 +69,7 @@ class EventTest { private SystemUserRunner userRunner @Autowired - private IPetriNetService petriNetService; + private IPetriNetService petriNetService @Autowired private TestHelper testHelper diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/ImporterTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/ImporterTest.groovy index 3b5058dd074..5673b6bc5af 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/ImporterTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/ImporterTest.groovy @@ -13,6 +13,7 @@ import com.netgrif.application.engine.startup.SuperCreator import com.netgrif.application.engine.workflow.domain.Case import com.netgrif.application.engine.workflow.domain.DataFieldBehavior import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams +import com.netgrif.application.engine.workflow.domain.params.TaskParams import com.netgrif.application.engine.workflow.service.interfaces.ITaskService import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowService import groovy.transform.CompileStatic @@ -300,7 +301,7 @@ class ImporterTest { .loggedUser(superCreator.loggedSuper) .build() Case testCase = workflowService.createCase(createCaseParams).getCase() - taskService.assignTask(testCase.getTaskStringId("t1")) + taskService.assignTask(new TaskParams(testCase.getTaskStringId("t1"))) testCase = workflowService.findOne(testCase.getStringId()) assert testCase.getDataSet().get("text_field").getRawValue() == "Hello world!" assert testCase.getDataSet().get("tester_text_field").getRawValue() == "Hello world!" diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/ChangeCasePropertyTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/ChangeCasePropertyTest.groovy index a8b8ab385c0..499673f5e8e 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/ChangeCasePropertyTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/ChangeCasePropertyTest.groovy @@ -10,6 +10,7 @@ import com.netgrif.application.engine.startup.SuperCreator import com.netgrif.application.engine.workflow.domain.Case import com.netgrif.application.engine.workflow.domain.QTask import com.netgrif.application.engine.workflow.domain.Task +import com.netgrif.application.engine.workflow.domain.params.TaskParams 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 @@ -74,8 +75,8 @@ class ChangeCasePropertyTest { Task testCaseTask = taskService.searchOne(QTask.task.caseTitle.eq(TEST_CASE_TITLE) & QTask.task.transitionId.eq(TEST_TRANSITION)) assert testCaseTask - taskService.assignTask(testCaseTask.getStringId()) - taskService.finishTask(testCaseTask.getStringId()) + taskService.assignTask(new TaskParams(testCaseTask)) + taskService.finishTask(new TaskParams(testCaseTask)) testCase = workflowService.findOne(testCase.getStringId()) testCaseTask = taskService.findOne(testCaseTask.getStringId()) @@ -93,11 +94,11 @@ class ChangeCasePropertyTest { Task testCaseTask = taskService.searchOne(QTask.task.caseTitle.eq(TEST_CASE_TITLE) & QTask.task.transitionId.eq(TEST_TRANSITION)) assert testCaseTask - taskService.assignTask(testCaseTask.getStringId()) + taskService.assignTask(new TaskParams(testCaseTask)) dataService.setData(testCaseTask.stringId, new DataSet([ "bln": new BooleanField(rawValue: true) ] as Map<String, Field<?>>), superCreator.getSuperUser()) - taskService.finishTask(testCaseTask.getStringId()) + taskService.finishTask(new TaskParams(testCaseTask)) testCase = workflowService.findOne(testCase.getStringId()) testCaseTask = taskService.findOne(testCaseTask.getStringId()) diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/ChangeFieldValueInitTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/ChangeFieldValueInitTest.groovy index fa97895ce45..b0649a38dac 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/ChangeFieldValueInitTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/ChangeFieldValueInitTest.groovy @@ -9,6 +9,7 @@ import com.netgrif.application.engine.workflow.domain.Case import com.netgrif.application.engine.workflow.domain.QTask 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.TaskParams import com.netgrif.application.engine.workflow.service.interfaces.ITaskService import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowService import org.junit.jupiter.api.BeforeEach @@ -49,7 +50,7 @@ class ChangeFieldValueInitTest { @Test void testInitValues() { - ImportPetriNetEventOutcome optNet = petriNetService.importPetriNet(new FileInputStream("src/test/resources/petriNets/change_field_value_init.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()); + ImportPetriNetEventOutcome optNet = petriNetService.importPetriNet(new FileInputStream("src/test/resources/petriNets/change_field_value_init.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()) Case useCase = importHelper.createCase("test", optNet.getNet()) assert useCase.dataSet.get("text_static").rawValue == "TEST VALUE" @@ -74,8 +75,8 @@ class ChangeFieldValueInitTest { Case execute(String trans, Case useCase) { Task task = taskService.searchOne(QTask.task.caseId.eq(useCase.getStringId()) & QTask.task.transitionId.eq(trans)) - taskService.assignTask(task.stringId) - taskService.finishTask(task.stringId) + taskService.assignTask(new TaskParams(task)) + taskService.finishTask(new TaskParams(task)) return reload(useCase) } diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicEnumerationTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicEnumerationTest.groovy index b952275d990..9775abad999 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicEnumerationTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicEnumerationTest.groovy @@ -67,7 +67,7 @@ class DynamicEnumerationTest { assert aCase != null Task task = taskService.findByCases(new FullPageRequest(), Collections.singletonList(aCase.getStringId())).stream().collect(Collectors.toList()).get(0); - importHelper.assignTask("Autocomplete", aCase.getStringId(), superCreator.getLoggedSuper()) + importHelper.assignTask("Autocomplete", aCase.getStringId(), superCreator.getSuperUser()) def dataSet = new DataSet([ "autocomplete": new EnumerationField(rawValue: new I18nString("Case")) diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/FileFieldTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/FileFieldTest.groovy index 8da382142f0..81be879cb33 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/FileFieldTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/FileFieldTest.groovy @@ -112,7 +112,7 @@ class FileFieldTest { .loggedUser(user.transformToLoggedUser()) .build() Case useCase = workflowService.createCase(createCaseParams).getCase() - importHelper.assignTask(TASK_TITLE, useCase.getStringId(), user.transformToLoggedUser()) + importHelper.assignTask(TASK_TITLE, useCase.getStringId(), user) mockMvc.perform(get("/api/workflow/case/" + useCase.getStringId() + "/file") .param("fieldId", FIELD_ID) @@ -138,7 +138,7 @@ class FileFieldTest { .loggedUser(user.transformToLoggedUser()) .build() Case useCase = workflowService.createCase(createCaseParams).getCase() - importHelper.assignTask(TASK_TITLE, useCase.getStringId(), user.transformToLoggedUser()) + importHelper.assignTask(TASK_TITLE, useCase.getStringId(), user) mockMvc.perform(get("/api/task/" + importHelper.getTaskId(TASK_TITLE, useCase.getStringId()) + "/file") .param("fieldId", FIELD_ID) diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/FileListFieldTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/FileListFieldTest.groovy index ef480bce423..cef902ce08c 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/FileListFieldTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/FileListFieldTest.groovy @@ -12,6 +12,7 @@ import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetServi import com.netgrif.application.engine.startup.ImportHelper import com.netgrif.application.engine.startup.SuperCreator import com.netgrif.application.engine.workflow.domain.Case +import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowService import org.junit.jupiter.api.BeforeEach import org.junit.jupiter.api.Test @@ -25,7 +26,6 @@ import org.springframework.test.context.ActiveProfiles import org.springframework.test.context.junit.jupiter.SpringExtension import org.springframework.test.web.servlet.MockMvc import org.springframework.test.web.servlet.setup.MockMvcBuilders -import org.springframework.util.MultiValueMap import org.springframework.web.context.WebApplicationContext import static org.hamcrest.core.StringContains.containsString @@ -105,8 +105,14 @@ class FileListFieldTest { IUser user = userService.findByEmail(configuration.email, true) assert user != null - Case useCase = workflowService.createCase(net.getStringId(), "Test file from file list download", "black", user.transformToLoggedUser()).getCase() - importHelper.assignTask(TASK_TITLE, useCase.getStringId(), user.transformToLoggedUser()) + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(net) + .title("Test file from file list download") + .color("black") + .loggedUser(user.transformToLoggedUser()) + .build() + Case useCase = workflowService.createCase(createCaseParams).getCase() + importHelper.assignTask(TASK_TITLE, useCase.getStringId(), user) mockMvc.perform(get("/api/workflow/case/" + useCase.getStringId() + "/file/named") .param("fieldId", FIELD_ID) @@ -126,8 +132,14 @@ class FileListFieldTest { IUser user = userService.findByEmail(configuration.email, true) assert user != null - Case useCase = workflowService.createCase(net.getStringId(), "Test file from file list download", "black", user.transformToLoggedUser()).getCase() - importHelper.assignTask(TASK_TITLE, useCase.getStringId(), user.transformToLoggedUser()) + CreateCaseParams createCaseParams = CreateCaseParams.builder() + .petriNet(net) + .title("Test file from file list download") + .color("black") + .loggedUser(user.transformToLoggedUser()) + .build() + Case useCase = workflowService.createCase(createCaseParams).getCase() + importHelper.assignTask(TASK_TITLE, useCase.getStringId(), user) // TODO: release/8.0.0 '/test-file-list.txt' or "test-file.txt" ? mockMvc.perform(get("/api/task/" + importHelper.getTaskId(TASK_TITLE, useCase.getStringId()) + "/file/named") diff --git a/src/test/groovy/com/netgrif/application/engine/workflow/SetDataOnButtonTest.groovy b/src/test/groovy/com/netgrif/application/engine/workflow/SetDataOnButtonTest.groovy index 92bd8e54627..05c69a4c966 100644 --- a/src/test/groovy/com/netgrif/application/engine/workflow/SetDataOnButtonTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/workflow/SetDataOnButtonTest.groovy @@ -13,6 +13,7 @@ import com.netgrif.application.engine.startup.SuperCreator import com.netgrif.application.engine.workflow.domain.Case import com.netgrif.application.engine.workflow.domain.QTask import com.netgrif.application.engine.workflow.domain.Task +import com.netgrif.application.engine.workflow.domain.params.TaskParams 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 @@ -91,8 +92,8 @@ class SetDataOnButtonTest { Task parentTask = taskService.searchOne(QTask.task.caseTitle.eq(PARENT_CASE) & QTask.task.transitionId.eq(TEST_TRANSITION)) assert parentTask != null - taskService.assignTask(parentTask.getStringId()) - taskService.finishTask(parentTask.getStringId()) + taskService.assignTask(new TaskParams(parentTask)) + taskService.finishTask(new TaskParams(parentTask)) childCase = workflowService.findOne(childCase.getStringId()) assert childCase.dataSet.get(TEXT_0_FIELD_ID).rawValue.toString() == OUTPUT_TEXT_0 diff --git a/src/test/groovy/com/netgrif/application/engine/workflow/TaskStateTest.groovy b/src/test/groovy/com/netgrif/application/engine/workflow/TaskStateTest.groovy index 76af0d5c340..6d68e3f7668 100644 --- a/src/test/groovy/com/netgrif/application/engine/workflow/TaskStateTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/workflow/TaskStateTest.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.params.CreateCaseParams +import com.netgrif.application.engine.workflow.domain.params.TaskParams import com.netgrif.application.engine.workflow.service.interfaces.ITaskService import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowService import groovy.transform.CompileStatic @@ -89,12 +90,12 @@ class TaskStateTest { assert t.transitionId in [transitionId, allDataConfiguration.allData.id] ? t.state == ENABLED : t.state == DISABLED } Task task = tasks.find {it.transitionId == transitionId} - taskService.assignTask(task.stringId) + taskService.assignTask(new TaskParams(task)) tasks = taskService.findAllByCase(useCase.stringId) tasks.each { t-> assert t.transitionId in [allDataConfiguration.allData.id] ? t.state == ENABLED : t.state == DISABLED } - taskService.finishTask(task.stringId) + taskService.finishTask(new TaskParams(task)) } } } diff --git a/src/test/groovy/com/netgrif/application/engine/workflow/WorkflowServiceTest.groovy b/src/test/groovy/com/netgrif/application/engine/workflow/WorkflowServiceTest.groovy index 12a9eb79ae1..af14dfe6494 100644 --- a/src/test/groovy/com/netgrif/application/engine/workflow/WorkflowServiceTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/workflow/WorkflowServiceTest.groovy @@ -65,12 +65,12 @@ class WorkflowServiceTest { def testNetWithTriggers = petriNetService.importPetriNet(stream("petriNets/test_with_triggers.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()).getNet() def testNet = petriNetService.importPetriNet(stream("petriNets/test_without_triggers.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()).getNet() - int iterations = 1000 - def paramsWithoutTrigger = CreateCaseParams.builder() + int iterations = 200 + def paramsWithoutTrigger = builder() .petriNet(testNet) .loggedUser(superCreator.getLoggedSuper()) .build() - def paramsWithTrigger = CreateCaseParams.builder() + def paramsWithTrigger = builder() .petriNet(testNetWithTriggers) .loggedUser(superCreator.getLoggedSuper()) .build() @@ -85,13 +85,13 @@ class WorkflowServiceTest { } long totalWithTriggers = 0 -// (0..iterations).each { -// Date startTime = new Date() -// workflowService.createCase(paramsWithTrigger) -// Date endTime = new Date() -// TimeDuration elapsedTimeTransactional = TimeCategory.minus( endTime, startTime ) -// totalWithTriggers += elapsedTimeTransactional.toMilliseconds() -// } + (0..iterations).each { + Date startTime = new Date() + workflowService.createCase(paramsWithTrigger) + Date endTime = new Date() + TimeDuration elapsedTimeTransactional = TimeCategory.minus( endTime, startTime ) + totalWithTriggers += elapsedTimeTransactional.toMilliseconds() + } println("AVG without triggers for 1 create case: " + totalWithoutTriggers / iterations + "ms") println("AVG with triggers for 1 create case: " + totalWithTriggers / iterations + "ms") @@ -124,8 +124,8 @@ class WorkflowServiceTest { .loggedUser(superCreator.getLoggedSuper()) .build() Case aCase = workflowService.createCase(createCaseParams).getCase() - importHelper.assignTask("Manual", aCase.getStringId(), superCreator.getLoggedSuper()) - importHelper.finishTask("Manual", aCase.getStringId(), superCreator.getLoggedSuper()) + importHelper.assignTask("Manual", aCase.getStringId(), superCreator.getSuperUser()) + importHelper.finishTask("Manual", aCase.getStringId(), superCreator.getSuperUser()) assert workflowService.findOne(aCase.stringId).getActivePlaces().containsKey("p3") assert workflowService.findOne(aCase.stringId).getActivePlaces().size() == 1 @@ -142,11 +142,11 @@ class WorkflowServiceTest { .loggedUser(superCreator.getLoggedSuper()) .build() Case aCase = workflowService.createCase(createCaseParams).getCase() - importHelper.assignTask("Manual", aCase.getStringId(), superCreator.getLoggedSuper()) - importHelper.finishTask("Manual", aCase.getStringId(), superCreator.getLoggedSuper()) + importHelper.assignTask("Manual", aCase.getStringId(), superCreator.getSuperUser()) + importHelper.finishTask("Manual", aCase.getStringId(), superCreator.getSuperUser()) - importHelper.assignTask("Manuel", aCase.getStringId(), superCreator.getLoggedSuper()) - importHelper.finishTask("Manuel", aCase.getStringId(), superCreator.getLoggedSuper()) + importHelper.assignTask("Manuel", aCase.getStringId(), superCreator.getSuperUser()) + importHelper.finishTask("Manuel", aCase.getStringId(), superCreator.getSuperUser()) assert workflowService.findOne(aCase.stringId).getActivePlaces().containsKey("p3") assert workflowService.findOne(aCase.stringId).getActivePlaces().size() == 1 diff --git a/src/test/java/com/netgrif/application/engine/rules/service/RuleEngineTest.java b/src/test/java/com/netgrif/application/engine/rules/service/RuleEngineTest.java index 89064ece05d..91593fa1f9b 100644 --- a/src/test/java/com/netgrif/application/engine/rules/service/RuleEngineTest.java +++ b/src/test/java/com/netgrif/application/engine/rules/service/RuleEngineTest.java @@ -19,6 +19,7 @@ import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.caseoutcomes.CreateCaseEventOutcome; import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome; import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams; +import com.netgrif.application.engine.workflow.domain.params.TaskParams; import com.netgrif.application.engine.workflow.service.interfaces.ITaskService; import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowService; import lombok.extern.slf4j.Slf4j; @@ -208,8 +209,8 @@ void testTransitionRules() throws IOException, MissingPetriNetMetaDataException, assert caseOutcome.getCase().getTitle().equals(NEW_CASE_TITLE); Task task = findTask(caseOutcome.getCase(), TRANS_1); - taskService.assignTask(task, superUser.transformToUser()); - taskService.finishTask(task, superUser.transformToUser()); + taskService.assignTask(new TaskParams(task, superUser.transformToUser())); + taskService.finishTask(new TaskParams(task, superUser.transformToUser())); Case newCase = workflowService.findOne(caseOutcome.getCase().getStringId()); assert newCase.getTitle().equals(NEW_CASE_TITLE); assert !newCase.getColor().equals(NEW_CASE_TITLE_2); @@ -219,8 +220,8 @@ void testTransitionRules() throws IOException, MissingPetriNetMetaDataException, assert facts.size() == 1 && facts.get(0) instanceof TestFact && ((TestFact) facts.get(0)).number == 1; Task task2 = findTask(newCase, TRANS_2); - taskService.assignTask(task2, superUser.transformToUser()); - taskService.finishTask(task2, superUser.transformToUser()); + taskService.assignTask(new TaskParams(task2, superUser.transformToUser())); + taskService.finishTask(new TaskParams(task2, superUser.transformToUser())); newCase = workflowService.findOne(newCase.getStringId()); assert newCase.getTitle().equals(NEW_CASE_TITLE_2); @@ -238,7 +239,7 @@ void assignRuleTest() throws IOException, MissingPetriNetMetaDataException, Tran assert caze != null; Task task = findTask(caze, TRANS_1); - taskService.assignTask(task, superUser.transformToUser()); + taskService.assignTask(new TaskParams(task, superUser.transformToUser())); caze = workflowService.findOne(caze.getStringId()); @@ -260,7 +261,7 @@ void testDelegate() throws IOException, MissingPetriNetMetaDataException, Transi Task task = findTask(caze, TRANS_1); IUser user = superUser.transformToUser(); - taskService.assignTask(task, user); + taskService.assignTask(new TaskParams(task, user)); taskService.delegateTask(user.transformToLoggedUser(), user.getStringId(), task.getStringId()); caze = workflowService.findOne(caze.getStringId()); @@ -281,8 +282,8 @@ void testFinish() throws IOException, MissingPetriNetMetaDataException, Transiti Task task = findTask(caze, TRANS_1); IUser user = superUser.transformToUser(); - taskService.assignTask(task, user); - taskService.finishTask(task, user); + taskService.assignTask(new TaskParams(task, user)); + taskService.finishTask(new TaskParams(task, user)); caze = workflowService.findOne(caze.getStringId()); assert caze.getDataSet().get("text_data").getValue().getValue().equals(TEXT_VALUE); @@ -303,8 +304,8 @@ void testCancel() throws IOException, MissingPetriNetMetaDataException, Transiti Task task = findTask(caze, TRANS_1); IUser user = superUser.transformToUser(); - taskService.assignTask(task, user); - taskService.cancelTask(task, user); + taskService.assignTask(new TaskParams(task, user)); + taskService.cancelTask(new TaskParams(task, user)); caze = workflowService.findOne(caze.getStringId()); assert caze.getDataSet().get("text_data").getValue().getValue().equals(TEXT_VALUE); diff --git a/src/test/java/com/netgrif/application/engine/workflow/service/TaskServiceTest.java b/src/test/java/com/netgrif/application/engine/workflow/service/TaskServiceTest.java index 16f2091b6d2..4cb1511a366 100644 --- a/src/test/java/com/netgrif/application/engine/workflow/service/TaskServiceTest.java +++ b/src/test/java/com/netgrif/application/engine/workflow/service/TaskServiceTest.java @@ -21,6 +21,7 @@ import com.netgrif.application.engine.workflow.domain.Task; import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.caseoutcomes.CreateCaseEventOutcome; import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams; +import com.netgrif.application.engine.workflow.domain.params.TaskParams; import com.netgrif.application.engine.workflow.domain.repositories.CaseRepository; import com.netgrif.application.engine.workflow.domain.repositories.TaskRepository; import com.netgrif.application.engine.workflow.service.interfaces.ITaskService; @@ -128,14 +129,14 @@ public void resetArcTest() throws TransitionNotExecutableException, MissingPetri assert task != null; - service.assignTask(user.transformToLoggedUser(), task.getStringId()); + service.assignTask(new TaskParams(task, user)); Case useCase = caseRepository.findById(outcome.getCase().getStringId()).get(); assert useCase.getConsumedTokens().size() == 1; assert useCase.getConsumedTokens().values().contains(5); assert useCase.getActivePlaces().size() == 0; - service.cancelTask(user.transformToLoggedUser(), task.getStringId()); + service.cancelTask(new TaskParams(task, user)); useCase = caseRepository.findById(useCase.getStringId()).get(); assert useCase.getConsumedTokens().size() == 0; diff --git a/src/test/java/com/netgrif/application/engine/workflow/web/VariableArcsTest.java b/src/test/java/com/netgrif/application/engine/workflow/web/VariableArcsTest.java index b8ac57092f8..13ca81d92e2 100644 --- a/src/test/java/com/netgrif/application/engine/workflow/web/VariableArcsTest.java +++ b/src/test/java/com/netgrif/application/engine/workflow/web/VariableArcsTest.java @@ -26,6 +26,7 @@ import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.caseoutcomes.CreateCaseEventOutcome; import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome; import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams; +import com.netgrif.application.engine.workflow.domain.params.TaskParams; 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.TaskReference; @@ -124,7 +125,7 @@ public void before() throws Exception { public void importTest() throws MissingIconKeyException { List<Arc> arcs = this.loaded.getArcs().values().stream().flatMap(List::stream).collect(Collectors.toList()); - assert arcs.size() > 0; + assert !arcs.isEmpty(); CreateCaseParams createCaseParams = CreateCaseParams.builder() .petriNet(this.loaded) .title("VARTEST") @@ -154,11 +155,19 @@ public void finishTasksTest() throws TransitionNotExecutableException { private void assertInhibArcsFinishTask(List<TaskReference> tasks) throws TransitionNotExecutableException { for (TaskReference taskRef : tasks) { Task task = taskService.findOne(taskRef.getStringId()); - taskService.assignTask(task, testUser); + TaskParams taskParams = TaskParams.builder() + .task(task) + .user(testUser) + .build(); + taskService.assignTask(taskParams); finishCase = workflowService.findOne(task.getCaseId()); assert !finishCase.getActivePlaces().containsKey(task.getTitle().getDefaultValue() + "_start") && !finishCase.getActivePlaces().containsKey(task.getTitle().getDefaultValue() + "_res"); - taskService.finishTask(task, testUser); + taskParams = TaskParams.builder() + .task(task) + .user(testUser) + .build(); + taskService.finishTask(taskParams); finishCase = workflowService.findOne(task.getCaseId()); assert !finishCase.getActivePlaces().containsKey(task.getTitle().getDefaultValue() + "_start") && finishCase.getActivePlaces().containsKey(task.getTitle().getDefaultValue() + "_res"); @@ -168,14 +177,21 @@ private void assertInhibArcsFinishTask(List<TaskReference> tasks) throws Transit private void assertReadArcsFinishTask(List<TaskReference> tasks) throws TransitionNotExecutableException { for (TaskReference taskRef : tasks) { Task task = taskService.findOne(taskRef.getStringId()); - int markingBeforeAssign = 0; - markingBeforeAssign = finishCase.getActivePlaces().get(task.getTitle().getDefaultValue() + "_start"); - taskService.assignTask(task, testUser); + int markingBeforeAssign = finishCase.getActivePlaces().get(task.getTitle().getDefaultValue() + "_start"); + TaskParams taskParams = TaskParams.builder() + .task(task) + .user(testUser) + .build(); + taskService.assignTask(taskParams); finishCase = workflowService.findOne(task.getCaseId()); assert markingBeforeAssign == finishCase.getActivePlaces().get(task.getTitle().getDefaultValue() + "_start"); - taskService.finishTask(task, testUser); + taskParams = TaskParams.builder() + .task(task) + .user(testUser) + .build(); + taskService.finishTask(taskParams); finishCase = workflowService.findOne(task.getCaseId()); assert markingBeforeAssign == finishCase.getActivePlaces().get(task.getTitle().getDefaultValue() + "_start") && @@ -187,13 +203,21 @@ private void assertFinishTasks(String arcType, List<TaskReference> tasks) throws List<TaskReference> filteredTasks = tasks.stream().filter(task -> task.getTitle().contains(arcType)).collect(Collectors.toList()); for (TaskReference taskRef : filteredTasks) { Task task = taskService.findOne(taskRef.getStringId()); - taskService.assignTask(task, testUser); + TaskParams taskParams = TaskParams.builder() + .task(task) + .user(testUser) + .build(); + taskService.assignTask(taskParams); finishCase = workflowService.findOne(task.getCaseId()); // TODO: release/8.0.0 assert !finishCase.getActivePlaces().containsKey(task.getTitle().getDefaultValue() + "_start"); - taskService.finishTask(task, testUser); + taskParams = TaskParams.builder() + .task(task) + .user(testUser) + .build(); + taskService.finishTask(taskParams); finishCase = workflowService.findOne(task.getCaseId()); assert !finishCase.getActivePlaces().containsKey(task.getTitle().getDefaultValue() + "_start") && @@ -205,12 +229,20 @@ private void assertOutArcsFinishTasks(List<TaskReference> tasks) throws Transiti List<TaskReference> filteredTasks = tasks.stream().filter(task -> task.getTitle().equals("var_arc_out") || task.getTitle().equals("place_var_arc_out")).collect(Collectors.toList()); for (TaskReference taskRef : filteredTasks) { Task task = taskService.findOne(taskRef.getStringId()); - taskService.assignTask(task, testUser); + TaskParams taskParams = TaskParams.builder() + .task(task) + .user(testUser) + .build(); + taskService.assignTask(taskParams); finishCase = workflowService.findOne(task.getCaseId()); assert !finishCase.getActivePlaces().containsKey(task.getTitle().getDefaultValue() + "_end"); - taskService.finishTask(task, testUser); + taskParams = TaskParams.builder() + .task(task) + .user(testUser) + .build(); + taskService.finishTask(taskParams); finishCase = workflowService.findOne(task.getCaseId()); assert finishCase.getActivePlaces().containsKey(task.getTitle().getDefaultValue() + "_end") && @@ -246,7 +278,11 @@ private void assertCancelTasks(String arcType, List<TaskReference> tasks) throws if (!arcType.equals("inhib")) { tokensBeforeAssign = cancelCase.getActivePlaces().get(task.getTitle().getDefaultValue() + "_start"); } - taskService.assignTask(task, testUser); + TaskParams taskParams = TaskParams.builder() + .task(task) + .user(testUser) + .build(); + taskService.assignTask(taskParams); cancelCase = workflowService.findOne(task.getCaseId()); assert !cancelCase.getActivePlaces().containsKey(task.getTitle().getDefaultValue() + "_res"); if (arcType.equals("read")) { @@ -264,11 +300,23 @@ private void assertCancelTasks(String arcType, List<TaskReference> tasks) throws if (task.getTitle().getDefaultValue().contains("ref")) { QTask qTask = new QTask("task"); Task addTokensTask = taskService.searchOne(qTask.transitionId.eq("add_tokens").and(qTask.caseId.eq(cancelCase.getStringId()))); - taskService.assignTask(testUser.transformToLoggedUser(), addTokensTask.getStringId()); - taskService.finishTask(addTokensTask, testUser); + taskParams = TaskParams.builder() + .task(addTokensTask) + .user(testUser) + .build(); + taskService.assignTask(taskParams); + taskParams = TaskParams.builder() + .task(addTokensTask) + .user(testUser) + .build(); + taskService.finishTask(taskParams); } int tokensAfterCancel = 0; - taskService.cancelTask(task, testUser); + taskParams = TaskParams.builder() + .task(task) + .user(testUser) + .build(); + taskService.cancelTask(taskParams); cancelCase = workflowService.findOne(task.getCaseId()); if (!arcType.equals("inhib")) { tokensAfterCancel = cancelCase.getActivePlaces().get(task.getTitle().getDefaultValue() + "_start"); @@ -289,8 +337,16 @@ private void assertCancelTasks(String arcType, List<TaskReference> tasks) throws if (task.getTitle().getDefaultValue().contains("ref")) { QTask qTask = new QTask("task"); Task removeTokensTask = taskService.searchOne(qTask.transitionId.eq("remove_tokens").and(qTask.caseId.eq(cancelCase.getStringId()))); - taskService.assignTask(testUser.transformToLoggedUser(), removeTokensTask.getStringId()); - taskService.finishTask(removeTokensTask, testUser); + taskParams = TaskParams.builder() + .task(removeTokensTask) + .user(testUser) + .build(); + taskService.assignTask(taskParams); + taskParams = TaskParams.builder() + .task(removeTokensTask) + .user(testUser) + .build(); + taskService.finishTask(taskParams); tasksAfterPlaceRefReset = taskService.findAllByCase(cancelCase.getStringId(), LocaleContextHolder.getLocale()); } } @@ -300,12 +356,20 @@ private void assertOutArcsCancelTasks(List<TaskReference> tasks) throws Transiti List<TaskReference> filteredTasks = tasks.stream().filter(task -> task.getTitle().equals("var_arc_out") || task.getTitle().equals("place_var_arc_out")).collect(Collectors.toList()); for (TaskReference taskRef : filteredTasks) { Task task = taskService.findOne(taskRef.getStringId()); - taskService.assignTask(task, testUser); + TaskParams taskParams = TaskParams.builder() + .task(task) + .user(testUser) + .build(); + taskService.assignTask(taskParams); cancelCase = workflowService.findOne(task.getCaseId()); assert !cancelCase.getActivePlaces().containsKey(task.getTitle().getDefaultValue() + "_end"); - taskService.cancelTask(task, testUser); + taskParams = TaskParams.builder() + .task(task) + .user(testUser) + .build(); + taskService.cancelTask(taskParams); cancelCase = workflowService.findOne(task.getCaseId()); assert !cancelCase.getActivePlaces().containsKey(task.getTitle().getDefaultValue() + "_res"); From 4445d277c5dcdde0ef490e4d677837a329f1ca09 Mon Sep 17 00:00:00 2001 From: chvostek <chvostek@netgrif.com> Date: Tue, 6 Aug 2024 15:11:45 +0200 Subject: [PATCH 26/48] [NAE-1998] Implement transactions for events - little optimization of EventService --- .../engine/workflow/service/EventService.java | 25 +++++++++++-------- 1 file changed, 15 insertions(+), 10 deletions(-) diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/EventService.java b/src/main/java/com/netgrif/application/engine/workflow/service/EventService.java index 9527d320c23..7f92455f938 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/EventService.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/EventService.java @@ -2,6 +2,7 @@ import com.netgrif.application.engine.importer.model.DataEventType; import com.netgrif.application.engine.petrinet.domain.DataRef; +import com.netgrif.application.engine.petrinet.domain.Function; import com.netgrif.application.engine.petrinet.domain.Transition; import com.netgrif.application.engine.petrinet.domain.dataset.Field; import com.netgrif.application.engine.petrinet.domain.dataset.logic.action.Action; @@ -12,6 +13,7 @@ import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.EventOutcome; import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.dataoutcomes.SetDataEventOutcome; import com.netgrif.application.engine.workflow.service.interfaces.IEventService; +import lombok.RequiredArgsConstructor; import lombok.extern.slf4j.Slf4j; import org.springframework.context.annotation.Lazy; import org.springframework.stereotype.Service; @@ -21,14 +23,11 @@ @Slf4j @Lazy @Service +@RequiredArgsConstructor public class EventService implements IEventService { private final ActionRunner actionsRunner; - public EventService(ActionRunner actionsRunner) { - this.actionsRunner = actionsRunner; - } - @Override public List<EventOutcome> runActions(List<Action> actions, Case useCase, Task task, Transition transition, Map<String, String> params) { log.info("[" + useCase.getStringId() + "]: Running actions of transition " + transition.getStringId()); @@ -43,9 +42,11 @@ public List<EventOutcome> runActions(List<Action> actions, Map<String, String> p @Override public List<EventOutcome> runActions(List<Action> actions, Case useCase, Optional<Task> task, Map<String, String> params) { List<EventOutcome> allOutcomes = new ArrayList<>(); + List<Function> functions = useCase == null ? Collections.emptyList() : useCase.getPetriNet().getFunctions(); actions.forEach(action -> { - List<EventOutcome> outcomes = actionsRunner.run(action, useCase, task, null, params, useCase == null ? Collections.emptyList() : useCase.getPetriNet().getFunctions()); - outcomes.stream().filter(SetDataEventOutcome.class::isInstance) + List<EventOutcome> outcomes = actionsRunner.run(action, useCase, task, null, params, functions); + outcomes.stream() + .filter(SetDataEventOutcome.class::isInstance) .forEach(outcome -> { if (((SetDataEventOutcome) outcome).getChangedFields().getFields().isEmpty()) { return; @@ -58,12 +59,15 @@ public List<EventOutcome> runActions(List<Action> actions, Case useCase, Optiona } @Override - public List<EventOutcome> runEventActions(Case useCase, Task task, Field<?> newDataField, List<Action> actions, DataEventType trigger, Map<String, String> params) { + public List<EventOutcome> runEventActions(Case useCase, Task task, Field<?> newDataField, List<Action> actions, + DataEventType trigger, Map<String, String> params) { List<EventOutcome> allOutcomes = new ArrayList<>(); + List<Function> functions = useCase == null ? Collections.emptyList() : useCase.getPetriNet().getFunctions(); + Optional<Task> taskOpt = task == null ? Optional.empty() : Optional.of(task); actions.stream() .filter(a -> a.getSetDataType().isTriggered(newDataField)) .forEach(action -> { - List<EventOutcome> outcomes = actionsRunner.run(action, useCase, task == null ? Optional.empty() : Optional.of(task), newDataField, params, useCase == null ? Collections.emptyList() : useCase.getPetriNet().getFunctions()); + List<EventOutcome> outcomes = actionsRunner.run(action, useCase, taskOpt, newDataField, params, functions); outcomes.stream() .filter(SetDataEventOutcome.class::isInstance) .filter(outcome -> !((SetDataEventOutcome) outcome).getChangedFields().getFields().isEmpty()) @@ -74,7 +78,8 @@ public List<EventOutcome> runEventActions(Case useCase, Task task, Field<?> newD } @Override - public List<EventOutcome> processDataEvents(Field<?> field, DataEventType actionTrigger, EventPhase phase, Case useCase, Task task, Field<?> newDataField, Map<String, String> params) { + public List<EventOutcome> processDataEvents(Field<?> field, DataEventType actionTrigger, EventPhase phase, Case useCase, + Task task, Field<?> newDataField, Map<String, String> params) { LinkedList<Action> fieldActions = new LinkedList<>(); if (field.getEvents() != null && field.getEvents().containsKey(actionTrigger)) { fieldActions.addAll(DataRef.getEventAction(field.getEvents().get(actionTrigger), phase)); @@ -108,7 +113,7 @@ public void runEventActionsOnChanged(Task task, SetDataEventOutcome outcome, Dat .forEach(entry -> { String fieldId = entry.getKey(); Field<?> field = outcome.getCase().getDataSet().get(fieldId); - log.info("[" + outcome.getCase().getStringId() + "] " + outcome.getCase().getTitle() + ": Running actions on changed field " + fieldId); + log.info("[{}] {}: Running actions on changed field {}", outcome.getCase().getStringId(), outcome.getCase().getTitle(), fieldId); // TODO: release/8.0.0 changed fields outcome.addOutcomes(processDataEvents(field, trigger, EventPhase.PRE, outcome.getCase(), outcome.getTask(), null, params)); outcome.addOutcomes(processDataEvents(field, trigger, EventPhase.POST, outcome.getCase(), outcome.getTask(), null, params)); From dc1af89abef08f8b344d1415f26a87d09522fa72 Mon Sep 17 00:00:00 2001 From: chvostek <chvostek@netgrif.com> Date: Tue, 6 Aug 2024 15:52:06 +0200 Subject: [PATCH 27/48] [NAE-1998] Implement transactions for events - optimize DataService.getData --- .../logic/action/ActionDelegate.groovy | 26 +++++- .../engine/startup/ImportHelper.groovy | 3 +- .../workflow/domain/params/GetDataParams.java | 35 +++++++ .../engine/workflow/service/DataService.java | 93 ++++++++++--------- .../engine/workflow/service/TaskService.java | 4 +- .../service/interfaces/IDataService.java | 9 +- .../DynamicValidationPerformanceTest.groovy | 3 +- 7 files changed, 112 insertions(+), 61 deletions(-) create mode 100644 src/main/java/com/netgrif/application/engine/workflow/domain/params/GetDataParams.java diff --git a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy index e633e092327..855f97f0668 100644 --- a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy +++ b/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) { diff --git a/src/main/groovy/com/netgrif/application/engine/startup/ImportHelper.groovy b/src/main/groovy/com/netgrif/application/engine/startup/ImportHelper.groovy index edac7bcb125..6a461b146bc 100644 --- a/src/main/groovy/com/netgrif/application/engine/startup/ImportHelper.groovy +++ b/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() { diff --git a/src/main/java/com/netgrif/application/engine/workflow/domain/params/GetDataParams.java b/src/main/java/com/netgrif/application/engine/workflow/domain/params/GetDataParams.java new file mode 100644 index 00000000000..f5a705d581c --- /dev/null +++ b/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; + } +} diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/DataService.java b/src/main/java/com/netgrif/application/engine/workflow/service/DataService.java index 930880efd0e..2c97f06cd03 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/DataService.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/DataService.java @@ -9,7 +9,6 @@ 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.*; @@ -17,7 +16,6 @@ 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."); } diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/TaskService.java b/src/main/java/com/netgrif/application/engine/workflow/service/TaskService.java index bb8929f3888..e7718b14484 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/TaskService.java +++ b/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()))); diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/interfaces/IDataService.java b/src/main/java/com/netgrif/application/engine/workflow/service/interfaces/IDataService.java index 8236b0e6457..78e444706cc 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/interfaces/IDataService.java +++ b/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); diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicValidationPerformanceTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicValidationPerformanceTest.groovy index 2fcb9cbe694..22dbb821f51 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicValidationPerformanceTest.groovy +++ b/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) { From d5fbc7b4616b131a07bff2613cfbd07edaf900cd Mon Sep 17 00:00:00 2001 From: chvostek <chvostek@netgrif.com> Date: Wed, 7 Aug 2024 10:35:36 +0200 Subject: [PATCH 28/48] [NAE-1998] Implement transactions for events - optimize DataService.setData --- .../logic/action/ActionDelegate.groovy | 28 ++++-- .../startup/DefaultFiltersRunner.groovy | 7 +- .../engine/startup/ImportHelper.groovy | 3 +- .../orgstructure/groups/NextGroupService.java | 3 +- .../workflow/domain/params/SetDataParams.java | 44 +++++++++ .../engine/workflow/service/DataService.java | 90 ++++++++++--------- .../service/MenuImportExportService.java | 5 +- .../service/interfaces/IDataService.java | 17 +--- .../workflow/web/AbstractTaskController.java | 4 +- .../engine/action/FilterApiTest.groovy | 9 +- .../engine/action/MenuItemApiTest.groovy | 3 +- .../auth/TaskAuthorizationServiceTest.groovy | 25 +++--- .../WorkflowAuthorizationServiceTest.groovy | 9 +- .../elastic/DataSearchRequestTest.groovy | 5 +- .../filters/FilterImportExportTest.groovy | 9 +- .../engine/history/HistoryServiceTest.groovy | 4 +- .../engine/importer/UserListTest.groovy | 27 +++--- .../engine/menu/MenuImportExportTest.groovy | 3 +- .../ElasticSearchViewPermissionTest.groovy | 13 +-- .../petrinet/domain/FunctionsTest.groovy | 32 ++++--- .../domain/dataset/ChangeBehaviorTest.groovy | 25 +++--- .../dataset/ChangeCasePropertyTest.groovy | 5 +- .../dataset/DynamicEnumerationTest.groovy | 25 +++--- .../engine/transaction/TransactionTest.groovy | 17 ++-- .../workflow/SetDataOnButtonTest.groovy | 5 +- .../engine/workflow/UserRefsTest.groovy | 6 +- 26 files changed, 253 insertions(+), 170 deletions(-) create mode 100644 src/main/java/com/netgrif/application/engine/workflow/domain/params/SetDataParams.java diff --git a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy index 855f97f0668..fef93d32528 100644 --- a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy +++ b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy @@ -49,6 +49,7 @@ 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.SetDataParams 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 @@ -528,11 +529,11 @@ class ActionDelegate /*TODO: release/8.0.0: implements ActionAPI*/ { } SetDataEventOutcome setData(Field<?> field, Map changes, IUser user = userService.loggedOrSystem) { - SetDataEventOutcome outcome = dataService.setData(useCase, new DataSet([ + SetDataEventOutcome outcome = dataService.setData(new SetDataParams(useCase, new DataSet([ (field.stringId): field.class.newInstance(changes) - ] as Map<String, Field<?>>), user) + ] as Map<String, Field<?>>), user)) this.outcomes.add(outcome) - updateCase() + updateCase(outcome) return outcome } @@ -610,7 +611,8 @@ class ActionDelegate /*TODO: release/8.0.0: implements ActionAPI*/ { private addTaskOutcomes(Task task, DataSet dataSet) { AssignTaskEventOutcome assignOutcome = taskService.assignTask(new TaskParams(task)) this.outcomes.add(assignOutcome) - SetDataEventOutcome setDataOutcome = dataService.setData(assignOutcome.getTask(), dataSet, userService.loggedOrSystem) + SetDataEventOutcome setDataOutcome = dataService.setData(new SetDataParams(assignOutcome.getTask(), dataSet, + userService.loggedOrSystem)) this.outcomes.add(setDataOutcome) this.outcomes.add(taskService.finishTask(new TaskParams(setDataOutcome.getTask()))) } @@ -979,7 +981,7 @@ class ActionDelegate /*TODO: release/8.0.0: implements ActionAPI*/ { // TODO: release/8.0.0 merge check, params x dataset SetDataEventOutcome setData(DataSet dataSet, IUser user = userService.loggedOrSystem) { - return addSetDataOutcomeToOutcomes(dataService.setData(useCase, dataSet, user)) + return addSetDataOutcomeToOutcomes(dataService.setData(new SetDataParams(useCase, dataSet, user))) } SetDataEventOutcome setData(Task task, DataSet dataSet, IUser user = userService.loggedOrSystem, Map<String, String> params = [:]) { @@ -987,7 +989,13 @@ class ActionDelegate /*TODO: release/8.0.0: implements ActionAPI*/ { } SetDataEventOutcome setData(String taskId, DataSet dataSet, IUser user = userService.loggedOrSystem, Map<String, String> params = [:]) { - return addSetDataOutcomeToOutcomes(dataService.setData(taskId, dataSet, user, params)) + SetDataParams setDataParams = SetDataParams.builder() + .taskId(taskId) + .dataSet(dataSet) + .user(user) + .params(params) + .build() + return addSetDataOutcomeToOutcomes(dataService.setData(setDataParams)) } SetDataEventOutcome setData(Transition transition, DataSet dataSet, IUser user = userService.loggedOrSystem, Map<String, String> params = [:]) { @@ -997,7 +1005,13 @@ class ActionDelegate /*TODO: release/8.0.0: implements ActionAPI*/ { SetDataEventOutcome setData(String transitionId, Case useCase, DataSet dataSet, IUser user = userService.loggedOrSystem, Map<String, String> params = [:]) { def predicate = QTask.task.caseId.eq(useCase.stringId) & QTask.task.transitionId.eq(transitionId) def task = taskService.searchOne(predicate) - return addSetDataOutcomeToOutcomes(dataService.setData(task.stringId, dataSet, user, params)) + SetDataParams setDataParams = SetDataParams.builder() + .task(task) + .dataSet(dataSet) + .user(user) + .params(params) + .build() + return addSetDataOutcomeToOutcomes(dataService.setData(setDataParams)) } @Deprecated diff --git a/src/main/groovy/com/netgrif/application/engine/startup/DefaultFiltersRunner.groovy b/src/main/groovy/com/netgrif/application/engine/startup/DefaultFiltersRunner.groovy index 2ebc820c555..cb8dc604008 100644 --- a/src/main/groovy/com/netgrif/application/engine/startup/DefaultFiltersRunner.groovy +++ b/src/main/groovy/com/netgrif/application/engine/startup/DefaultFiltersRunner.groovy @@ -10,6 +10,7 @@ import com.netgrif.application.engine.workflow.domain.QCase import com.netgrif.application.engine.workflow.domain.QTask import com.netgrif.application.engine.workflow.domain.Task import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams +import com.netgrif.application.engine.workflow.domain.params.SetDataParams import com.netgrif.application.engine.workflow.domain.params.TaskParams import com.netgrif.application.engine.workflow.service.interfaces.IDataService import com.netgrif.application.engine.workflow.service.interfaces.ITaskService @@ -291,11 +292,11 @@ class DefaultFiltersRunner extends AbstractOrderedCommandLineRunner { } // TODO: release/8.0.0 join setData to one call - this.dataService.setData(newFilterTask, dataSet, superCreator.getSuperUser()) + this.dataService.setData(new SetDataParams(newFilterTask, dataSet, superCreator.getSuperUser())) if (isImported) { - this.dataService.setData(newFilterTask, new DataSet([ + this.dataService.setData(new SetDataParams(newFilterTask, new DataSet([ (IS_IMPORTED): new NumberField(rawValue: 1) - ] as Map<String, Field<?>>), superCreator.getSuperUser()) + ] as Map<String, Field<?>>), superCreator.getSuperUser())) } I18nString translatedTitle = new I18nString(title) diff --git a/src/main/groovy/com/netgrif/application/engine/startup/ImportHelper.groovy b/src/main/groovy/com/netgrif/application/engine/startup/ImportHelper.groovy index 6a461b146bc..8215b8a1538 100644 --- a/src/main/groovy/com/netgrif/application/engine/startup/ImportHelper.groovy +++ b/src/main/groovy/com/netgrif/application/engine/startup/ImportHelper.groovy @@ -19,6 +19,7 @@ import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.tas 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.SetDataParams 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 @@ -189,7 +190,7 @@ class ImportHelper { } SetDataEventOutcome setTaskData(String taskId, DataSet dataSet) { - dataService.setData(taskId, dataSet, superCreator.getSuperUser()) + dataService.setData(new SetDataParams(taskId, dataSet, superCreator.getSuperUser())) } SetDataEventOutcome setTaskData(String taskTitle, String caseId, DataSet data) { diff --git a/src/main/java/com/netgrif/application/engine/orgstructure/groups/NextGroupService.java b/src/main/java/com/netgrif/application/engine/orgstructure/groups/NextGroupService.java index 63e22d5262c..e5bcd9f37d5 100644 --- a/src/main/java/com/netgrif/application/engine/orgstructure/groups/NextGroupService.java +++ b/src/main/java/com/netgrif/application/engine/orgstructure/groups/NextGroupService.java @@ -21,6 +21,7 @@ import com.netgrif.application.engine.workflow.domain.Task; import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.caseoutcomes.CreateCaseEventOutcome; import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams; +import com.netgrif.application.engine.workflow.domain.params.SetDataParams; import com.netgrif.application.engine.workflow.domain.params.TaskParams; import com.netgrif.application.engine.workflow.service.interfaces.IDataService; import com.netgrif.application.engine.workflow.service.interfaces.ITaskService; @@ -116,7 +117,7 @@ public CreateCaseEventOutcome createGroup(String title, IUser author) { DataSet taskData = getInitialGroupData(author, title, outcome.getCase()); Task initTask = getGroupInitTask(outcome.getCase()); - dataService.setData(initTask.getStringId(), taskData, author); + dataService.setData(new SetDataParams(initTask, taskData, author)); try { taskService.assignTask(new TaskParams(initTask, author)); diff --git a/src/main/java/com/netgrif/application/engine/workflow/domain/params/SetDataParams.java b/src/main/java/com/netgrif/application/engine/workflow/domain/params/SetDataParams.java new file mode 100644 index 00000000000..06e98d0811c --- /dev/null +++ b/src/main/java/com/netgrif/application/engine/workflow/domain/params/SetDataParams.java @@ -0,0 +1,44 @@ +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 com.netgrif.application.engine.workflow.web.responsebodies.DataSet; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; + +import java.util.HashMap; +import java.util.Map; + +@Data +@Builder +@AllArgsConstructor +public class SetDataParams { + + private Task task; + private String taskId; + private Case useCase; + private DataSet dataSet; + private IUser user; + @Builder.Default + private Map<String, String> params = new HashMap<>(); + + public SetDataParams(Task task, DataSet dataSet, IUser user) { + this.task = task; + this.dataSet = dataSet; + this.user = user; + } + + public SetDataParams(String taskId, DataSet dataSet, IUser user) { + this.taskId = taskId; + this.dataSet = dataSet; + this.user = user; + } + + public SetDataParams(Case useCase, DataSet dataSet, IUser user) { + this.useCase = useCase; + this.dataSet = dataSet; + this.user = user; + } +} diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/DataService.java b/src/main/java/com/netgrif/application/engine/workflow/service/DataService.java index 2c97f06cd03..3dab66880d5 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/DataService.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/DataService.java @@ -27,6 +27,7 @@ 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.domain.params.SetDataParams; 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; @@ -149,60 +150,52 @@ private void fillMissingAttributes(GetDataParams getDataParams) throws IllegalAr } } + /** + * todo javadoc + * */ @Override - public SetDataEventOutcome setData(String taskId, DataSet dataSet, IUser user) { - return setData(taskId, dataSet, user, new HashMap<>()); - } - - @Override - public SetDataEventOutcome setData(String taskId, DataSet dataSet, IUser user, Map<String, String> params) { - Task task = taskService.findOne(taskId); - return setData(task, dataSet, user, params); - } - - @Override - public SetDataEventOutcome setData(String taskId, DataSet values, LoggedUser loggedUser) { - return setData(taskId, values, loggedUser, new HashMap<>()); - } - - @Override - public SetDataEventOutcome setData(String taskId, DataSet dataSet, LoggedUser loggedUser, Map<String, String> params) { - IUser user = userService.getUserFromLoggedUser(loggedUser); - return setData(taskId, dataSet, user, params); - } - - @Override - public SetDataEventOutcome setData(Case target, DataSet dataSet, IUser user) { - return setData(target, dataSet, user, new HashMap<>()); - } - - @Override - public SetDataEventOutcome setData(Case target, DataSet dataSet, IUser user, Map<String, String> params) { - Task fake = Task.with().id(new ObjectId()).caseId(target.getStringId()).title(new I18nString("Fake")).transitionId("fake").build(); - return setData(fake, dataSet, user, params); - } + @Transactional + public SetDataEventOutcome setData(SetDataParams setDataParams) { + fillMissingAttributes(setDataParams); - @Override - public SetDataEventOutcome setData(Task task, DataSet dataSet, IUser user) { - return setData(task, dataSet, user, new HashMap<>()); - } + Task task = setDataParams.getTask(); - @Override - public SetDataEventOutcome setData(Task task, DataSet dataSet, IUser user, Map<String, String> params) { log.info("[{}]: Setting data of task {} [{}]", task.getStringId(), task.getTransitionId(), task.getStringId()); if (task.getUserId() != null) { task.setUser(userService.findById(task.getUserId(), false)); } List<EventOutcome> outcomes = new ArrayList<>(); - for (Map.Entry<String, Field<?>> stringFieldEntry : dataSet.getFields().entrySet()) { + for (Map.Entry<String, Field<?>> stringFieldEntry : setDataParams.getDataSet().getFields().entrySet()) { String fieldId = stringFieldEntry.getKey(); Field<?> newDataField = stringFieldEntry.getValue(); - outcomes.add(setDataField(task, fieldId, newDataField, user)); + outcomes.add(setDataField(task, fieldId, newDataField, setDataParams.getUser())); } Case useCase = workflowService.findOne(task.getCaseId()); return new SetDataEventOutcome(useCase, task, outcomes); } + private void fillMissingAttributes(SetDataParams setDataParams) { + if (setDataParams.getTask() == null) { + if (setDataParams.getTaskId() != null) { + Task task = taskService.findOne(setDataParams.getTaskId()); + setDataParams.setTask(task); + } else if (setDataParams.getUseCase() != null) { + Task fakeTask = Task.with() + .id(new ObjectId()) + .caseId(setDataParams.getUseCase().getStringId()) + .title(new I18nString("Fake")) + .transitionId("fake") + .build(); + setDataParams.setTask(fakeTask); + } else { + throw new IllegalArgumentException("Cannot set data without provided task."); + } + } + if (setDataParams.getUser() == null) { + throw new IllegalArgumentException("User must be provided on set data."); + } + } + @Override public SetDataEventOutcome setDataField(Task task, String fieldId, Field<?> newDataField, IUser user) { return setDataField(task, fieldId, newDataField, user, new HashMap<>()); @@ -220,9 +213,14 @@ public SetDataEventOutcome setDataField(Task task, String fieldId, Field<?> newD } Field<?> field = fieldOptional.get(); // PRE - outcome.addOutcomes(resolveDataEvents(field, DataEventType.SET, EventPhase.PRE, useCase, task, newDataField, params)); - useCase = workflowService.findOne(task.getCaseId()); + List<EventOutcome> preSetOutcomes = resolveDataEvents(field, DataEventType.SET, EventPhase.PRE, useCase, task, + newDataField, params); + if (!preSetOutcomes.isEmpty()) { + outcome.addOutcomes(preSetOutcomes); + useCase = workflowService.findOne(task.getCaseId()); + } historyService.save(new SetDataEventLog(task, useCase, EventPhase.PRE, DataSet.of(fieldId, newDataField), user)); + // EXECUTION if (outcome.getMessage() == null) { setOutcomeMessage(task, useCase, outcome, fieldId, field, DataEventType.SET); @@ -234,10 +232,16 @@ public SetDataEventOutcome setDataField(Task task, String fieldId, Field<?> newD useCase = workflowService.save(useCase); outcome.addChangedField(fieldId, newDataField); historyService.save(new SetDataEventLog(task, useCase, EventPhase.EXECUTION, DataSet.of(fieldId, newDataField), user)); + // POST - outcome.addOutcomes(resolveDataEvents(field, DataEventType.SET, EventPhase.POST, useCase, task, newDataField, params)); - useCase = workflowService.findOne(task.getCaseId()); + List<EventOutcome> postSetOutcomes = resolveDataEvents(field, DataEventType.SET, EventPhase.POST, useCase, task, + newDataField, params); + if (!postSetOutcomes.isEmpty()) { + outcome.addOutcomes(resolveDataEvents(field, DataEventType.SET, EventPhase.POST, useCase, task, newDataField, params)); + useCase = workflowService.findOne(task.getCaseId()); + } historyService.save(new SetDataEventLog(task, useCase, EventPhase.POST, DataSet.of(fieldId, newDataField), user)); + useCase = applyFieldConnectedChanges(useCase, field); outcome.setCase(useCase); diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/MenuImportExportService.java b/src/main/java/com/netgrif/application/engine/workflow/service/MenuImportExportService.java index 1a6bb14ffcc..96c35d5cf5b 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/MenuImportExportService.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/MenuImportExportService.java @@ -20,6 +20,7 @@ import com.netgrif.application.engine.workflow.domain.menu.MenuEntry; import com.netgrif.application.engine.workflow.domain.menu.MenuEntryRole; import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams; +import com.netgrif.application.engine.workflow.domain.params.SetDataParams; import com.netgrif.application.engine.workflow.domain.params.TaskParams; import com.netgrif.application.engine.workflow.service.interfaces.*; import com.netgrif.application.engine.workflow.web.responsebodies.DataSet; @@ -150,7 +151,7 @@ public List<String> importMenu(List<Case> menuItemCases, FileFieldValue ffv, Str Case caseToRemove = workflowService.findOne(id); QTask qTask = new QTask("task"); Task task = taskService.searchOne(qTask.transitionId.eq("view").and(qTask.caseId.eq(caseToRemove.getStringId()))); - dataService.setData(task, caseToRemoveData, userService.getLoggedOrSystem()); + dataService.setData(new SetDataParams(task, caseToRemoveData, userService.getLoggedOrSystem())); }); //Import filters @@ -172,7 +173,7 @@ public List<String> importMenu(List<Case> menuItemCases, FileFieldValue ffv, Str // DataField groupImportResultMessage = new DataField(); // groupImportResultMessage.setValue(resultMessage.toString()); // groupData.getFields().put("import_results", groupImportResultMessage); - dataService.setData(task, groupData, userService.getLoggedOrSystem()); + dataService.setData(new SetDataParams(task, groupData, userService.getLoggedOrSystem())); }); importedFilterTaskIds.values().forEach(taskId -> { diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/interfaces/IDataService.java b/src/main/java/com/netgrif/application/engine/workflow/service/interfaces/IDataService.java index 78e444706cc..c3ac066de71 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/interfaces/IDataService.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/interfaces/IDataService.java @@ -12,6 +12,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.params.GetDataParams; +import com.netgrif.application.engine.workflow.domain.params.SetDataParams; import com.netgrif.application.engine.workflow.service.FileFieldInputStream; import com.netgrif.application.engine.workflow.web.responsebodies.DataSet; import org.springframework.data.domain.Page; @@ -28,21 +29,7 @@ public interface IDataService { GetDataEventOutcome getData(GetDataParams getDataParams); - SetDataEventOutcome setData(String taskId, DataSet values, IUser user); - - SetDataEventOutcome setData(String taskId, DataSet values, IUser user, Map<String, String> params); - - SetDataEventOutcome setData(String taskId, DataSet values, LoggedUser loggedUser); - - SetDataEventOutcome setData(String taskId, DataSet values, LoggedUser loggedUser, Map<String, String> params); - - SetDataEventOutcome setData(Case useCase, DataSet dataSet, IUser user); - - SetDataEventOutcome setData(Case useCase, DataSet dataSet, IUser user, Map<String, String> params); - - SetDataEventOutcome setData(Task task, DataSet values, IUser user); - - SetDataEventOutcome setData(Task task, DataSet values, IUser user, Map<String, String> params); + SetDataEventOutcome setData(SetDataParams setDataParams); SetDataEventOutcome setDataField(Task task, String fieldId, Field<?> newDataField, IUser user); diff --git a/src/main/java/com/netgrif/application/engine/workflow/web/AbstractTaskController.java b/src/main/java/com/netgrif/application/engine/workflow/web/AbstractTaskController.java index 7a04ddf509a..2890a6db7bc 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/web/AbstractTaskController.java +++ b/src/main/java/com/netgrif/application/engine/workflow/web/AbstractTaskController.java @@ -11,6 +11,7 @@ import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.dataoutcomes.SetDataEventOutcome; import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.response.EventOutcomeWithMessage; import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.response.EventOutcomeWithMessageResource; +import com.netgrif.application.engine.workflow.domain.params.SetDataParams; import com.netgrif.application.engine.workflow.domain.params.TaskParams; import com.netgrif.application.engine.workflow.service.FileFieldInputStream; import com.netgrif.application.engine.workflow.service.interfaces.IDataService; @@ -213,7 +214,8 @@ public EntityModel<EventOutcomeWithMessage> getData(String taskId, Locale locale public EntityModel<EventOutcomeWithMessage> setData(String taskId, TaskDataSets dataBody, Authentication auth) { try { Map<String, SetDataEventOutcome> outcomes = new HashMap<>(); - dataBody.getBody().forEach((task, dataSet) -> outcomes.put(task, dataService.setData(task, dataSet, (LoggedUser) auth.getPrincipal()))); + dataBody.getBody().forEach((task, dataSet) -> outcomes.put(task, dataService.setData(new SetDataParams(task, + dataSet, ((LoggedUser) auth.getPrincipal()).transformToUser())))); SetDataEventOutcome mainOutcome = taskService.getMainOutcome(outcomes, taskId); return EventOutcomeWithMessageResource.successMessage("Data field values have been successfully set", mainOutcome); } catch (IllegalArgumentWithChangedFieldsException e) { diff --git a/src/test/groovy/com/netgrif/application/engine/action/FilterApiTest.groovy b/src/test/groovy/com/netgrif/application/engine/action/FilterApiTest.groovy index 4e9a86aaf92..8d4d1a937cc 100644 --- a/src/test/groovy/com/netgrif/application/engine/action/FilterApiTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/action/FilterApiTest.groovy @@ -12,6 +12,7 @@ import com.netgrif.application.engine.startup.ImportHelper import com.netgrif.application.engine.startup.SuperCreator import com.netgrif.application.engine.workflow.domain.Case import com.netgrif.application.engine.workflow.domain.QCase +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 @@ -104,7 +105,7 @@ class FilterApiTest { "icon" : new TextField(rawValue: ""), "create_filter_and_menu": new ButtonField(rawValue: 0) ] as Map<String, Field<?>>) - dataService.setData(caze.getTaskStringId("t1"), dataSet, superCreator.getLoggedSuper()) + dataService.setData(new SetDataParams(caze.getTaskStringId("t1"), dataSet, superCreator.getSuperUser())) caze = workflowService.findOne(caze.stringId) Case item = getMenuItem(caze) Case filter = getFilter(caze) @@ -128,7 +129,7 @@ class FilterApiTest { DataSet dataSet = new DataSet([ "delete_filter_and_menu": new ButtonField(rawValue: 0) ] as Map<String, Field<?>>) - dataService.setData(caze.getTaskStringId("t1"), dataSet, superCreator.getLoggedSuper()) + dataService.setData(new SetDataParams(caze.getTaskStringId("t1"), dataSet, superCreator.getSuperUser())) workflowService.findOne(caze.stringId) Case defGroup = nextGroupService.findDefaultGroup() List<String> taskIds = (defGroup.dataSet.get(ActionDelegate.ORG_GROUP_FIELD_FILTER_TASKS).value.value ?: []) as List @@ -150,7 +151,7 @@ class FilterApiTest { DataSet dataSet = new DataSet([ "find_filter": new ButtonField(rawValue: 0) ] as Map<String, Field<?>>) - dataService.setData(caze.getTaskStringId("t1"), dataSet, superCreator.getLoggedSuper()) + dataService.setData(new SetDataParams(caze.getTaskStringId("t1"), dataSet, superCreator.getSuperUser())) caze = workflowService.findOne(caze.stringId) assert caze.dataSet.get("found_filter").rawValue == filter.stringId } @@ -167,7 +168,7 @@ class FilterApiTest { "icon" : new TextField(rawValue: "device_hub"), "create_filter_and_menu": new ButtonField(rawValue: 0) ] as Map<String, Field<?>>) - dataService.setData(caze.getTaskStringId("t1"), dataSet, superCreator.getLoggedSuper()) + dataService.setData(new SetDataParams(caze.getTaskStringId("t1"), dataSet, superCreator.getSuperUser())) caze = workflowService.findOne(caze.stringId) return caze } diff --git a/src/test/groovy/com/netgrif/application/engine/action/MenuItemApiTest.groovy b/src/test/groovy/com/netgrif/application/engine/action/MenuItemApiTest.groovy index 2815aac994b..128f693433c 100644 --- a/src/test/groovy/com/netgrif/application/engine/action/MenuItemApiTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/action/MenuItemApiTest.groovy @@ -18,6 +18,7 @@ import com.netgrif.application.engine.workflow.domain.Case import com.netgrif.application.engine.workflow.domain.QCase import com.netgrif.application.engine.workflow.domain.menu.MenuItemConstants import com.netgrif.application.engine.workflow.domain.params.DeleteCaseParams +import com.netgrif.application.engine.workflow.domain.params.SetDataParams import com.netgrif.application.engine.workflow.domain.params.TaskParams import com.netgrif.application.engine.workflow.service.interfaces.IDataService import com.netgrif.application.engine.workflow.service.interfaces.ITaskService @@ -350,7 +351,7 @@ class MenuItemApiTest { } def setData(Case caze, DataSet dataSet) { - dataService.setData(caze.tasks["t1"].taskStringId, dataSet, superCreator.superUser) + dataService.setData(new SetDataParams(caze.tasks["t1"].taskStringId, dataSet, superCreator.superUser)) return workflowService.findOne(caze.stringId) } } diff --git a/src/test/groovy/com/netgrif/application/engine/auth/TaskAuthorizationServiceTest.groovy b/src/test/groovy/com/netgrif/application/engine/auth/TaskAuthorizationServiceTest.groovy index 2750da0cea6..8a22d0776f7 100644 --- a/src/test/groovy/com/netgrif/application/engine/auth/TaskAuthorizationServiceTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/auth/TaskAuthorizationServiceTest.groovy @@ -20,6 +20,7 @@ import com.netgrif.application.engine.workflow.domain.Case import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome 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.SetDataParams import com.netgrif.application.engine.workflow.domain.params.TaskParams import com.netgrif.application.engine.workflow.service.interfaces.IDataService import com.netgrif.application.engine.workflow.service.interfaces.ITaskAuthorizationService @@ -321,9 +322,9 @@ class TaskAuthorizationServiceTest { .build() Case case_ = workflowService.createCase(createCaseParams).getCase() String taskId = case_.getTaskStringId("1") - case_ = dataService.setData(taskId, new DataSet([ + case_ = dataService.setData(new SetDataParams(taskId, new DataSet([ "assign_pos_ul":new UserListField(rawValue: new UserListFieldValue([dataService.makeUserFieldValue(testUser.stringId)])) - ] as Map<String, Field<?>>), superCreator.getSuperUser()).getCase() + ] as Map<String, Field<?>>), superCreator.getSuperUser())).getCase() workflowService.save(case_) sleep(4000) @@ -344,9 +345,9 @@ class TaskAuthorizationServiceTest { .build() Case case_ = workflowService.createCase(createCaseParams).getCase() String taskId = case_.getTaskStringId("1") - case_ = dataService.setData(taskId, new DataSet([ + case_ = dataService.setData(new SetDataParams(taskId, new DataSet([ "assign_neg_ul": new UserListField(rawValue: new UserListFieldValue([dataService.makeUserFieldValue(testUser.stringId)])) - ] as Map<String, Field<?>>), superCreator.getSuperUser()).getCase() + ] as Map<String, Field<?>>), superCreator.getSuperUser())).getCase() sleep(4000) assert !taskAuthorizationService.canCallAssign(testUser.transformToLoggedUser(), taskId) @@ -365,9 +366,9 @@ class TaskAuthorizationServiceTest { .build() Case case_ = workflowService.createCase(createCaseParams).getCase() String taskId = case_.getTaskStringId("1") - case_ = dataService.setData(taskId, new DataSet([ + case_ = dataService.setData(new SetDataParams(taskId, new DataSet([ "assign_pos_ul": new UserListField(rawValue: new UserListFieldValue([dataService.makeUserFieldValue(testUser.stringId)])) - ] as Map<String, Field<?>>), superCreator.getLoggedSuper()).getCase() + ] as Map<String, Field<?>>), superCreator.getSuperUser())).getCase() sleep(4000) assert taskAuthorizationService.canCallAssign(testUser.transformToLoggedUser(), taskId) @@ -440,9 +441,9 @@ class TaskAuthorizationServiceTest { .build() Case case_ = workflowService.createCase(createCaseParams).getCase() String taskId = case_.getTaskStringId("1") - case_ = dataService.setData(taskId, new DataSet([ + case_ = dataService.setData(new SetDataParams(taskId, new DataSet([ "finish_pos_ul": new UserListField(rawValue: new UserListFieldValue([dataService.makeUserFieldValue(testUser.stringId)])) - ] as Map<String, Field<?>>), superCreator.getSuperUser()).getCase() + ] as Map<String, Field<?>>), superCreator.getSuperUser())).getCase() sleep(4000) TaskParams taskParams = TaskParams.builder() @@ -467,9 +468,9 @@ class TaskAuthorizationServiceTest { .build() Case case_ = workflowService.createCase(createCaseParams).getCase() String taskId = case_.getTaskStringId("1") - case_ = dataService.setData(taskId, new DataSet([ + case_ = dataService.setData(new SetDataParams(taskId, new DataSet([ "finish_neg_ul": new UserListField(rawValue: new UserListFieldValue([dataService.makeUserFieldValue(testUser.stringId)])) - ] as Map<String, Field<?>>), superCreator.getSuperUser()).getCase() + ] as Map<String, Field<?>>), superCreator.getSuperUser())).getCase() sleep(4000) TaskParams taskParams = TaskParams.builder() @@ -496,9 +497,9 @@ class TaskAuthorizationServiceTest { .build() Case case_ = workflowService.createCase(createCaseParams).getCase() String taskId = case_.getTaskStringId("1") - case_ = dataService.setData(taskId, new DataSet([ + case_ = dataService.setData(new SetDataParams(taskId, new DataSet([ "finish_pos_ul": new UserListField(rawValue: new UserListFieldValue([dataService.makeUserFieldValue(testUser.stringId)])) - ] as Map<String, Field<?>>), superCreator.getSuperUser()).getCase() + ] as Map<String, Field<?>>), superCreator.getSuperUser())).getCase() sleep(4000) TaskParams taskParams = TaskParams.builder() diff --git a/src/test/groovy/com/netgrif/application/engine/auth/WorkflowAuthorizationServiceTest.groovy b/src/test/groovy/com/netgrif/application/engine/auth/WorkflowAuthorizationServiceTest.groovy index 57b4e3d6420..08a5a369e82 100644 --- a/src/test/groovy/com/netgrif/application/engine/auth/WorkflowAuthorizationServiceTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/auth/WorkflowAuthorizationServiceTest.groovy @@ -18,6 +18,7 @@ import com.netgrif.application.engine.startup.SuperCreator import com.netgrif.application.engine.workflow.domain.Case import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams +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.IWorkflowAuthorizationService import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowService @@ -220,9 +221,9 @@ class WorkflowAuthorizationServiceTest { .build() Case case_ = workflowService.createCase(createCaseParams).getCase() String taskId = case_.getTaskStringId("1") - case_ = dataService.setData(taskId, new DataSet([ + case_ = dataService.setData(new SetDataParams(taskId, new DataSet([ "pos_user_list": new UserListField(rawValue: new UserListFieldValue(userValues: [dataService.makeUserFieldValue(testUser.stringId)])), - ] as Map<String, Field<?>>), superCreator.getSuperUser()).getCase() + ] as Map<String, Field<?>>), superCreator.getSuperUser())).getCase() workflowService.save(case_) assert workflowAuthorizationService.canCallDelete(testUser.transformToLoggedUser(), case_.getStringId()) @@ -247,10 +248,10 @@ class WorkflowAuthorizationServiceTest { .build() Case case_ = workflowService.createCase(createCaseParams).getCase() String taskId = case_.getTaskStringId("1") - case_ = dataService.setData(taskId, new DataSet([ + case_ = dataService.setData(new SetDataParams(taskId, new DataSet([ "pos_user_list": new UserListField(rawValue: new UserListFieldValue(userValues: [dataService.makeUserFieldValue(testUser.stringId)])), "neg_user_list": new UserListField(rawValue: new UserListFieldValue(userValues: [dataService.makeUserFieldValue(testUser.stringId)])) - ] as Map<String, Field<?>>), superCreator.getSuperUser()).getCase() + ] as Map<String, Field<?>>), superCreator.getSuperUser())).getCase() assert !workflowAuthorizationService.canCallDelete(testUser.transformToLoggedUser(), case_.getStringId()) diff --git a/src/test/groovy/com/netgrif/application/engine/elastic/DataSearchRequestTest.groovy b/src/test/groovy/com/netgrif/application/engine/elastic/DataSearchRequestTest.groovy index 95fac47c82c..35b0292cc49 100644 --- a/src/test/groovy/com/netgrif/application/engine/elastic/DataSearchRequestTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/elastic/DataSearchRequestTest.groovy @@ -24,6 +24,7 @@ import com.netgrif.application.engine.startup.SuperCreator import com.netgrif.application.engine.workflow.domain.Case import com.netgrif.application.engine.workflow.domain.QTask import com.netgrif.application.engine.workflow.domain.Task +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.ITaskService import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowService @@ -142,9 +143,9 @@ class DataSearchRequestTest { Task actionTrigger = taskService.searchOne(QTask.task.caseId.eq(_case.stringId).and(QTask.task.transitionId.eq("2"))); assert actionTrigger != null - dataService.setData(actionTrigger, new DataSet([ + dataService.setData(new SetDataParams(actionTrigger, new DataSet([ "testActionTrigger": new TextField(rawValue: "random value") - ] as Map<String, Field<?>>), superCreator.getSuperUser()) + ] as Map<String, Field<?>>), superCreator.getSuperUser())) 10.times { _case = importHelper.createCase("wrong${it}", net.getNet()) diff --git a/src/test/groovy/com/netgrif/application/engine/filters/FilterImportExportTest.groovy b/src/test/groovy/com/netgrif/application/engine/filters/FilterImportExportTest.groovy index fb7eb5cd27d..15c29ee90cf 100644 --- a/src/test/groovy/com/netgrif/application/engine/filters/FilterImportExportTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/filters/FilterImportExportTest.groovy @@ -17,6 +17,7 @@ import com.netgrif.application.engine.startup.FilterRunner import com.netgrif.application.engine.startup.ImportHelper import com.netgrif.application.engine.workflow.domain.* import com.netgrif.application.engine.workflow.domain.filter.FilterImportExportList +import com.netgrif.application.engine.workflow.domain.params.SetDataParams import com.netgrif.application.engine.workflow.domain.params.TaskParams import com.netgrif.application.engine.workflow.service.UserFilterSearchService import com.netgrif.application.engine.workflow.service.interfaces.IDataService @@ -149,15 +150,15 @@ class FilterImportExportTest { validateFilterXML(new FileInputStream(exportedFiltersField.getPath())) importedTasksIds.forEach({ taskId -> Task filterTask = this.taskService.findOne(taskId) - this.dataService.setData(filterTask, new DataSet([ + this.dataService.setData(new SetDataParams(filterTask, new DataSet([ (VISIBILITY_FIELD): new EnumerationMapField(rawValue: FILTER_VISIBILITY_PRIVATE), (NEW_TITLE_FIELD) : new TextField(rawValue: this.workflowService.findOne(filterTask.caseId).title + " new") - ] as Map<String, Field<?>>)) + ] as Map<String, Field<?>>), dummyUser)) }) Task importTask = this.taskService.searchOne(QTask.task.caseId.eq(importCase.stringId).and(QTask.task.transitionId.eq("importFilter"))) - this.dataService.setData(importTask, new DataSet([ + this.dataService.setData(new SetDataParams(importTask, new DataSet([ (IMPORTED_FILTERS_FIELD): new TaskField(rawValue: importedTasksIds) - ] as Map<String, Field<?>>)) + ] as Map<String, Field<?>>), dummyUser)) this.taskService.finishTask(new TaskParams(importTask, dummyUser)) Thread.sleep(1000) filterCases = this.userFilterSearchService.autocompleteFindFilters("") diff --git a/src/test/groovy/com/netgrif/application/engine/history/HistoryServiceTest.groovy b/src/test/groovy/com/netgrif/application/engine/history/HistoryServiceTest.groovy index db78a4d92c7..9b2a6a312e7 100644 --- a/src/test/groovy/com/netgrif/application/engine/history/HistoryServiceTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/history/HistoryServiceTest.groovy @@ -11,6 +11,7 @@ import com.netgrif.application.engine.startup.SuperCreator import com.netgrif.application.engine.workflow.domain.Case import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams +import com.netgrif.application.engine.workflow.domain.params.SetDataParams import com.netgrif.application.engine.workflow.domain.params.TaskParams import com.netgrif.application.engine.workflow.service.interfaces.IDataService import com.netgrif.application.engine.workflow.service.interfaces.ITaskService @@ -112,7 +113,8 @@ class HistoryServiceTest { int count = historyService.findAllSetDataEventLogsByCaseId(caze.getStringId()).size() assert count == 0 String task = caze.tasks.values().find { it.transitionId == "1" }.taskStringId - dataService.setData(task, DataSet.of("number", new NumberField(rawValue: 110101116103114105102)), userService.loggedOrSystem) + dataService.setData(new SetDataParams(task, DataSet.of("number", new NumberField(rawValue: 110101116103114105102)), + userService.loggedOrSystem)) Thread.sleep(1000) // HistoryService::save is @Async assert historyService.findAllSetDataEventLogsByCaseId(caze.getStringId()).size() == count + 3 // 3 PRE EXECUTION POST } diff --git a/src/test/groovy/com/netgrif/application/engine/importer/UserListTest.groovy b/src/test/groovy/com/netgrif/application/engine/importer/UserListTest.groovy index 134a7d2e9e7..c1a4cd7c9ee 100644 --- a/src/test/groovy/com/netgrif/application/engine/importer/UserListTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/importer/UserListTest.groovy @@ -14,6 +14,7 @@ import com.netgrif.application.engine.workflow.domain.Case import com.netgrif.application.engine.workflow.domain.QCase 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.SetDataParams import com.netgrif.application.engine.workflow.domain.repositories.CaseRepository import com.netgrif.application.engine.workflow.service.interfaces.IDataService import com.netgrif.application.engine.workflow.service.interfaces.ITaskService @@ -36,22 +37,22 @@ import java.util.stream.Collectors class UserListTest { @Autowired - private TestHelper testHelper; + private TestHelper testHelper @Autowired - private IPetriNetService petriNetService; + private IPetriNetService petriNetService @Autowired - private SuperCreator superCreator; + private SuperCreator superCreator @Autowired - private CaseRepository caseRepository; + private CaseRepository caseRepository @Autowired - private IDataService dataService; + private IDataService dataService @Autowired - private ITaskService taskService; + private ITaskService taskService @BeforeEach void before() { @@ -60,19 +61,19 @@ class UserListTest { @Test void testUserList() throws MissingPetriNetMetaDataException, IOException { - ImportPetriNetEventOutcome net = petriNetService.importPetriNet(new FileInputStream("src/test/resources/user_list.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()); + ImportPetriNetEventOutcome net = petriNetService.importPetriNet(new FileInputStream("src/test/resources/user_list.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()) - assert net.getNet() != null; - Optional<Case> caseOpt = caseRepository.findOne(QCase.case$.title.eq("User List")); + assert net.getNet() != null + Optional<Case> caseOpt = caseRepository.findOne(QCase.case$.title.eq("User List")) - assert caseOpt.isPresent(); - assert caseOpt.get().getDataSet().get("text").getRawValue() == "Its working..."; + assert caseOpt.isPresent() + assert caseOpt.get().getDataSet().get("text").getRawValue() == "Its working..." Task task = taskService.findByCases(new FullPageRequest(), Collections.singletonList(caseOpt.get().getStringId())).stream().collect(Collectors.toList()).get(0) - dataService.setData(task.stringId, new DataSet([ + dataService.setData(new SetDataParams(task.stringId, new DataSet([ "users_1": new UserListField(rawValue: new UserListFieldValue(new UserFieldValue(superCreator.getSuperUser()))) - ] as Map<String, Field<?>>), superCreator.getLoggedSuper()) + ] as Map<String, Field<?>>), superCreator.getSuperUser())) assert taskService.findById(task.stringId).users.get(superCreator.getSuperUser().getStringId()) assert caseRepository.findById(caseOpt.get().stringId).get().users.get(superCreator.getSuperUser().getStringId()) diff --git a/src/test/groovy/com/netgrif/application/engine/menu/MenuImportExportTest.groovy b/src/test/groovy/com/netgrif/application/engine/menu/MenuImportExportTest.groovy index 83364068e72..dea75379724 100644 --- a/src/test/groovy/com/netgrif/application/engine/menu/MenuImportExportTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/menu/MenuImportExportTest.groovy @@ -16,6 +16,7 @@ import com.netgrif.application.engine.workflow.domain.QTask import com.netgrif.application.engine.workflow.domain.Task import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.dataoutcomes.SetDataEventOutcome import com.netgrif.application.engine.workflow.domain.menu.MenuAndFilters +import com.netgrif.application.engine.workflow.domain.params.SetDataParams import com.netgrif.application.engine.workflow.domain.repositories.CaseRepository import com.netgrif.application.engine.workflow.service.UserFilterSearchService import com.netgrif.application.engine.workflow.service.interfaces.IDataService @@ -207,7 +208,7 @@ class MenuImportExportTest { private SetDataEventOutcome setData(task, Map<String, Map<String, Object>> values) { - return dataService.setData(task, ImportHelper.populateDataset(values)) + return dataService.setData(new SetDataParams(task, ImportHelper.populateDataset(values), superCreator.getSuperUser())) } diff --git a/src/test/groovy/com/netgrif/application/engine/permissions/ElasticSearchViewPermissionTest.groovy b/src/test/groovy/com/netgrif/application/engine/permissions/ElasticSearchViewPermissionTest.groovy index 93355dc93dc..941fc740126 100644 --- a/src/test/groovy/com/netgrif/application/engine/permissions/ElasticSearchViewPermissionTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/permissions/ElasticSearchViewPermissionTest.groovy @@ -23,6 +23,7 @@ import com.netgrif.application.engine.workflow.domain.Case import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome 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.SetDataParams 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 @@ -203,9 +204,9 @@ class ElasticSearchViewPermissionTest { .build() Case case_ = workflowService.createCase(createCaseParams).getCase() String taskId = case_.getTaskStringId("1") - dataService.setData(taskId, new DataSet([ + dataService.setData(new SetDataParams(taskId, new DataSet([ "view_ul_pos": new UserListField(rawValue: new UserListFieldValue([dataService.makeUserFieldValue(testUser.stringId)])) - ] as Map<String, Field<?>>), superCreator.getSuperUser()) + ] as Map<String, Field<?>>), superCreator.getSuperUser())) case_ = workflowService.findOne(case_.stringId) sleep(4000) @@ -230,9 +231,9 @@ class ElasticSearchViewPermissionTest { .build() Case case_ = workflowService.createCase(createCaseParams).getCase() String taskId = case_.getTaskStringId("1") - dataService.setData(taskId, new DataSet([ + dataService.setData(new SetDataParams(taskId, new DataSet([ "view_ul_neg": new UserListField(rawValue: new UserListFieldValue([dataService.makeUserFieldValue(testUser.stringId)])) - ] as Map<String, Field<?>>), superCreator.getSuperUser()) + ] as Map<String, Field<?>>), superCreator.getSuperUser())) case_ = workflowService.findOne(case_.stringId) sleep(4000) @@ -259,9 +260,9 @@ class ElasticSearchViewPermissionTest { ProcessRole negViewRole = this.net.getRoles().values().find(v -> v.getImportId() == "view_neg_role") userService.addRole(testUser, negViewRole.getStringId()) String taskId = case_.getTaskStringId("1") - dataService.setData(taskId, new DataSet([ + dataService.setData(new SetDataParams(taskId, new DataSet([ "view_ul_pos": new UserListField(rawValue: new UserListFieldValue([dataService.makeUserFieldValue(testUser.stringId)])) - ] as Map<String, Field<?>>), superCreator.getSuperUser()) + ] as Map<String, Field<?>>), superCreator.getSuperUser())) case_ = workflowService.findOne(case_.stringId) sleep(4000) diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/FunctionsTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/FunctionsTest.groovy index 52d4463af3f..9fb1dd457f4 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/FunctionsTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/FunctionsTest.groovy @@ -8,6 +8,7 @@ import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetServi import com.netgrif.application.engine.startup.SuperCreator import com.netgrif.application.engine.workflow.domain.Case import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams +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.ITaskService import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowService @@ -103,7 +104,8 @@ class FunctionsTest { .loggedUser(userService.getLoggedOrSystem().transformToLoggedUser()) .build() Case aCase = workflowService.createCase(createCaseParams).getCase() - dataService.setData(aCase.getTaskStringId("1"), new DataSet(["createUser": new BooleanField(rawValue: true)] as Map<String, Field<?>>), superCreator.getLoggedSuper()) + dataService.setData(new SetDataParams(aCase.getTaskStringId("1"), + new DataSet(["createUser": new BooleanField(rawValue: true)] as Map<String, Field<?>>), superCreator.getSuperUser())) IUser user = userService.findByEmail("test@test.com", true) assert user @@ -127,7 +129,9 @@ class FunctionsTest { .loggedUser(userService.getLoggedOrSystem().transformToLoggedUser()) .build() Case aCase = workflowService.createCase(createCaseParams).getCase() - dataService.setData(aCase.getTaskStringId("1"), new DataSet((["enum": new EnumerationField(rawValue: new I18nString("ano"))] as Map<String, Field<?>>)), superCreator.getLoggedSuper()) + dataService.setData(new SetDataParams(aCase.getTaskStringId("1"), + new DataSet((["enum": new EnumerationField(rawValue: new I18nString("ano"))] as Map<String, Field<?>>)), + superCreator.getSuperUser())) aCase = workflowService.findOne(aCase.getStringId()) NumberField field = aCase.getDataSet().get("number") as NumberField @@ -161,7 +165,8 @@ class FunctionsTest { .loggedUser(userService.getLoggedOrSystem().transformToLoggedUser()) .build() Case aCase = workflowService.createCase(createCaseParams).getCase() - dataService.setData(aCase.getTaskStringId("1"), new DataSet((["number": new NumberField(rawValue: 20d)] as Map<String, Field<?>>)), superCreator.getLoggedSuper()) + dataService.setData(new SetDataParams(aCase.getTaskStringId("1"), + new DataSet((["number": new NumberField(rawValue: 20d)] as Map<String, Field<?>>)), superCreator.getSuperUser())) }) } @@ -185,12 +190,14 @@ class FunctionsTest { .loggedUser(userService.getLoggedOrSystem().transformToLoggedUser()) .build() Case aCase = workflowService.createCase(createCaseParams).getCase() - dataService.setData(aCase.getTaskStringId("1"), new DataSet((["text": new TextField(rawValue: "20")] as Map<String, Field<?>>)), superCreator.getLoggedSuper()) + dataService.setData(new SetDataParams(aCase.getTaskStringId("1"), + new DataSet((["text": new TextField(rawValue: "20")] as Map<String, Field<?>>)), superCreator.getSuperUser())) functionTestNet = petriNetService.importPetriNet(functionTestNetResourceV2.inputStream, VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser()).getNet() assert functionTestNet - dataService.setData(aCase.getTaskStringId("1"), new DataSet((["text": new TextField(rawValue: "20")] as Map<String, Field<?>>)), superCreator.getLoggedSuper()) + dataService.setData(new SetDataParams(aCase.getTaskStringId("1"), + new DataSet((["text": new TextField(rawValue: "20")] as Map<String, Field<?>>)), superCreator.getSuperUser())) }) } @@ -207,7 +214,8 @@ class FunctionsTest { .loggedUser(userService.getLoggedOrSystem().transformToLoggedUser()) .build() Case aCase = workflowService.createCase(createCaseParams).getCase() - dataService.setData(aCase.getTaskStringId("1"), new DataSet((["number3": new NumberField(rawValue: 20d)] as Map<String, Field<?>>)), superCreator.getLoggedSuper()) + dataService.setData(new SetDataParams(aCase.getTaskStringId("1"), + new DataSet((["number3": new NumberField(rawValue: 20d)] as Map<String, Field<?>>)), superCreator.getSuperUser())) }) } @@ -226,7 +234,8 @@ class FunctionsTest { .loggedUser(userService.getLoggedOrSystem().transformToLoggedUser()) .build() Case aCase = workflowService.createCase(createCaseParams).getCase() - dataService.setData(aCase.getTaskStringId("1"), new DataSet((["number": new NumberField(rawValue: 20d)] as Map<String, Field<?>>)), superCreator.getLoggedSuper()) + dataService.setData(new SetDataParams(aCase.getTaskStringId("1"), + new DataSet((["number": new NumberField(rawValue: 20d)] as Map<String, Field<?>>)), superCreator.getSuperUser())) aCase = workflowService.findOne(aCase.getStringId()) assert aCase.getDataSet().get("number2").rawValue == 20 + 20 @@ -234,7 +243,8 @@ class FunctionsTest { functionResNet = petriNetService.importPetriNet(functionResNetResourceV2.inputStream, VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser()).getNet() assert functionResNet - dataService.setData(aCase.getTaskStringId("1"), new DataSet((["number": new NumberField(rawValue: 20d)] as Map<String, Field<?>>)), superCreator.getLoggedSuper()) + dataService.setData(new SetDataParams(aCase.getTaskStringId("1"), + new DataSet((["number": new NumberField(rawValue: 20d)] as Map<String, Field<?>>)), superCreator.getSuperUser())) aCase = workflowService.findOne(aCase.getStringId()) assert aCase.getDataSet().get("number2").rawValue == 20 * 20 @@ -259,7 +269,8 @@ class FunctionsTest { .loggedUser(userService.getLoggedOrSystem().transformToLoggedUser()) .build() Case aCase = workflowService.createCase(createCaseParams).getCase() - dataService.setData(aCase.getTaskStringId("0"), new DataSet((["updateOtherField": new BooleanField(rawValue: true)] as Map<String, Field<?>>)), superCreator.getLoggedSuper()) + dataService.setData(new SetDataParams(aCase.getTaskStringId("0"), + new DataSet((["updateOtherField": new BooleanField(rawValue: true)] as Map<String, Field<?>>)), superCreator.getSuperUser())) aCase = workflowService.findOne(aCase.stringId) assert aCase.getDataSet().get("toBeUpdated").rawValue == 1.0 @@ -294,7 +305,8 @@ class FunctionsTest { .loggedUser(userService.getLoggedOrSystem().transformToLoggedUser()) .build() Case aCase = workflowService.createCase(createCaseParams).getCase() - dataService.setData(aCase.getTaskStringId("1"), new DataSet((["number": new NumberField(rawValue: 20d)] as Map<String, Field<?>>)), superCreator.getLoggedSuper()) + dataService.setData(new SetDataParams(aCase.getTaskStringId("1"), + new DataSet((["number": new NumberField(rawValue: 20d)] as Map<String, Field<?>>)), superCreator.getSuperUser())) aCase = workflowService.findOne(aCase.getStringId()) NumberField numberField2 = aCase.dataSet.get("number2") as NumberField TextField textField = aCase.dataSet.get("text") as TextField diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/ChangeBehaviorTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/ChangeBehaviorTest.groovy index 019e46c1bde..4c1f9dce296 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/ChangeBehaviorTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/ChangeBehaviorTest.groovy @@ -12,6 +12,7 @@ import com.netgrif.application.engine.startup.SuperCreator import com.netgrif.application.engine.workflow.domain.Case import com.netgrif.application.engine.workflow.domain.QTask import com.netgrif.application.engine.workflow.domain.Task +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.ITaskService import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowService @@ -87,9 +88,9 @@ class ChangeBehaviorTest { Task mainTask = taskService.searchOne(QTask.task.transitionId.eq(MAIN_TRANSITION) & QTask.task.caseId.eq(testCase.stringId)) assert mainTask - dataService.setData(mainTask.stringId, new DataSet([ + dataService.setData(new SetDataParams(mainTask.stringId, new DataSet([ "boolean_0": new BooleanField(rawValue: true) - ] as Map<String, Field<?>>), superCreator.getLoggedSuper()) + ] as Map<String, Field<?>>), superCreator.getSuperUser())) testCase = workflowService.findOne(testCase.getStringId()) assert testCase.dataSet.get(BOOLEAN_0_FIELD_ID).rawValue == true @@ -110,9 +111,9 @@ class ChangeBehaviorTest { Task otherTask2 = taskService.searchOne(QTask.task.transitionId.eq(TEST_TRANSITION_2) & QTask.task.caseId.eq(testCase.stringId)) assert otherTask2 - dataService.setData(mainTask.stringId, new DataSet([ + dataService.setData(new SetDataParams(mainTask.stringId, new DataSet([ "boolean_1": new BooleanField(rawValue: true) - ] as Map<String, Field<?>>), superCreator.getLoggedSuper()) + ] as Map<String, Field<?>>), superCreator.getSuperUser())) testCase = workflowService.findOne(testCase.getStringId()) assert testCase.dataSet.get(BOOLEAN_1_FIELD_ID).rawValue == true @@ -136,9 +137,9 @@ class ChangeBehaviorTest { Task otherTask = taskService.searchOne(QTask.task.transitionId.eq(TEST_TRANSITION_1) & QTask.task.caseId.eq(testCase.stringId)) assert otherTask - dataService.setData(mainTask.stringId, new DataSet([ + dataService.setData(new SetDataParams(mainTask.stringId, new DataSet([ "boolean_2": new BooleanField(rawValue: true) - ] as Map<String, Field<?>>), superCreator.getLoggedSuper()) + ] as Map<String, Field<?>>), superCreator.getSuperUser())) testCase = workflowService.findOne(testCase.getStringId()) assert testCase.dataSet.get(BOOLEAN_2_FIELD_ID).rawValue == true @@ -157,9 +158,9 @@ class ChangeBehaviorTest { Task otherTask = taskService.searchOne(QTask.task.transitionId.eq(TEST_TRANSITION_1) & QTask.task.caseId.eq(testCase.stringId)) assert otherTask - dataService.setData(mainTask.stringId, new DataSet([ + dataService.setData(new SetDataParams(mainTask.stringId, new DataSet([ "boolean_3": new BooleanField(rawValue: true) - ] as Map<String, Field<?>>), superCreator.getLoggedSuper()) + ] as Map<String, Field<?>>), superCreator.getSuperUser())) testCase = workflowService.findOne(testCase.getStringId()) assert testCase.dataSet.get(BOOLEAN_3_FIELD_ID).rawValue == true @@ -178,18 +179,18 @@ class ChangeBehaviorTest { Task mainTask = taskService.searchOne(QTask.task.transitionId.eq(MAIN_TRANSITION) & QTask.task.caseId.eq(testCase.stringId)) assert mainTask - dataService.setData(mainTask.stringId, new DataSet([ + dataService.setData(new SetDataParams(mainTask.stringId, new DataSet([ "boolean_0": new BooleanField(rawValue: true) - ] as Map<String, Field<?>>), superCreator.getLoggedSuper()) + ] as Map<String, Field<?>>), superCreator.getSuperUser())) testCase = workflowService.findOne(testCase.getStringId()) assert testCase.dataSet.get(BOOLEAN_0_FIELD_ID).rawValue == true assert testCase.dataSet.get(TEXT_0_FIELD_ID).behaviors.get(MAIN_TRANSITION).behavior == EDITABLE assert testCase.dataSet.get(TEXT_0_FIELD_ID).behaviors.get(MAIN_TRANSITION).required == true - dataService.setData(mainTask.stringId, new DataSet([ + dataService.setData(new SetDataParams(mainTask.stringId, new DataSet([ "boolean_0": new BooleanField(rawValue: false) - ] as Map<String, Field<?>>), superCreator.getLoggedSuper()) + ] as Map<String, Field<?>>), superCreator.getSuperUser())) testCase = workflowService.findOne(testCase.getStringId()) assert testCase.dataSet.get(BOOLEAN_0_FIELD_ID).rawValue == false diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/ChangeCasePropertyTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/ChangeCasePropertyTest.groovy index 499673f5e8e..8c1eb5b302f 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/ChangeCasePropertyTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/ChangeCasePropertyTest.groovy @@ -10,6 +10,7 @@ import com.netgrif.application.engine.startup.SuperCreator import com.netgrif.application.engine.workflow.domain.Case import com.netgrif.application.engine.workflow.domain.QTask import com.netgrif.application.engine.workflow.domain.Task +import com.netgrif.application.engine.workflow.domain.params.SetDataParams import com.netgrif.application.engine.workflow.domain.params.TaskParams import com.netgrif.application.engine.workflow.service.interfaces.IDataService import com.netgrif.application.engine.workflow.service.interfaces.ITaskService @@ -95,9 +96,9 @@ class ChangeCasePropertyTest { assert testCaseTask taskService.assignTask(new TaskParams(testCaseTask)) - dataService.setData(testCaseTask.stringId, new DataSet([ + dataService.setData(new SetDataParams(testCaseTask.stringId, new DataSet([ "bln": new BooleanField(rawValue: true) - ] as Map<String, Field<?>>), superCreator.getSuperUser()) + ] as Map<String, Field<?>>), superCreator.getSuperUser())) taskService.finishTask(new TaskParams(testCaseTask)) testCase = workflowService.findOne(testCase.getStringId()) diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicEnumerationTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicEnumerationTest.groovy index 9775abad999..c5a5ed909e7 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicEnumerationTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicEnumerationTest.groovy @@ -9,6 +9,7 @@ import com.netgrif.application.engine.startup.SuperCreator import com.netgrif.application.engine.utils.FullPageRequest 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.SetDataParams import com.netgrif.application.engine.workflow.domain.repositories.CaseRepository import com.netgrif.application.engine.workflow.service.interfaces.IDataService import com.netgrif.application.engine.workflow.service.interfaces.ITaskService @@ -31,48 +32,48 @@ import java.util.stream.Collectors class DynamicEnumerationTest { @Autowired - private TestHelper testHelper; + private TestHelper testHelper @Autowired private ImportHelper importHelper @Autowired - private IPetriNetService petriNetService; + private IPetriNetService petriNetService @Autowired - private SuperCreator superCreator; + private SuperCreator superCreator @Autowired - private IDataService dataService; + private IDataService dataService @Autowired - private ITaskService taskService; + private ITaskService taskService @Autowired - private CaseRepository caseRepository; + private CaseRepository caseRepository @BeforeEach - public void before() { - testHelper.truncateDbs(); + void before() { + testHelper.truncateDbs() } @Test void testDynamicEnum() { - ImportPetriNetEventOutcome optNet = petriNetService.importPetriNet(new FileInputStream("src/test/resources/test_autocomplete_dynamic.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()); + ImportPetriNetEventOutcome optNet = petriNetService.importPetriNet(new FileInputStream("src/test/resources/test_autocomplete_dynamic.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()) - assert optNet.getNet() != null; + assert optNet.getNet() != null def net = optNet.getNet() def aCase = importHelper.createCase("Case", net) assert aCase != null - Task task = taskService.findByCases(new FullPageRequest(), Collections.singletonList(aCase.getStringId())).stream().collect(Collectors.toList()).get(0); + Task task = taskService.findByCases(new FullPageRequest(), Collections.singletonList(aCase.getStringId())).stream().collect(Collectors.toList()).get(0) importHelper.assignTask("Autocomplete", aCase.getStringId(), superCreator.getSuperUser()) def dataSet = new DataSet([ "autocomplete": new EnumerationField(rawValue: new I18nString("Case")) ] as Map<String, Field<?>>) - dataService.setData(task.stringId, dataSet, superCreator.getSuperUser()) + dataService.setData(new SetDataParams(task.stringId, dataSet, superCreator.getSuperUser())) def caseOpt = caseRepository.findById(aCase.stringId) assert caseOpt.isPresent() diff --git a/src/test/groovy/com/netgrif/application/engine/transaction/TransactionTest.groovy b/src/test/groovy/com/netgrif/application/engine/transaction/TransactionTest.groovy index 5c8d7e51c0c..ca90d351dcc 100644 --- a/src/test/groovy/com/netgrif/application/engine/transaction/TransactionTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/transaction/TransactionTest.groovy @@ -18,6 +18,7 @@ import com.netgrif.application.engine.workflow.domain.Case import com.netgrif.application.engine.workflow.domain.QCase import com.netgrif.application.engine.workflow.domain.QTask import com.netgrif.application.engine.workflow.domain.Task +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.ITaskService import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowService @@ -81,8 +82,8 @@ class TransactionTest { @Test void testBasicTransaction() { Case useCase = importHelper.createCase("test", testNet) - useCase = dataService.setData(useCase, new DataSet(["testBasicTransaction": new ButtonField(rawValue: 1)] - as Map<String, Field<?>>), superCreator.getSuperUser()).case + useCase = dataService.setData(new SetDataParams(useCase, new DataSet(["testBasicTransaction": new ButtonField(rawValue: 1)] + as Map<String, Field<?>>), superCreator.getSuperUser())).case assert findAllByIdentifier("transaction_test").size() == 4 @@ -351,8 +352,8 @@ class TransactionTest { long totalTransactionalDuration = 0 (0..iterations).each { Date startTime = new Date() - dataService.setData(useCase, new DataSet(["testCreateCaseInTransactionPerformance": new ButtonField(rawValue: 1)] - as Map<String, Field<?>>), superCreator.getSuperUser()).getCase() + dataService.setData(new SetDataParams(useCase, new DataSet(["testCreateCaseInTransactionPerformance": new ButtonField(rawValue: 1)] + as Map<String, Field<?>>), superCreator.getSuperUser())).getCase() Date endTime = new Date() TimeDuration elapsedTimeTransactional = TimeCategory.minus( endTime, startTime ) totalTransactionalDuration += elapsedTimeTransactional.toMilliseconds() @@ -361,8 +362,8 @@ class TransactionTest { long totalNonTransactionalDuration = 0 (0..iterations).each { Date startTime = new Date() - dataService.setData(useCase, new DataSet(["testCreateCasePerformance": new ButtonField(rawValue: 1)] - as Map<String, Field<?>>), superCreator.getSuperUser()).getCase() + dataService.setData(new SetDataParams(useCase, new DataSet(["testCreateCasePerformance": new ButtonField(rawValue: 1)] + as Map<String, Field<?>>), superCreator.getSuperUser())).getCase() Date endTime = new Date() TimeDuration elapsedTimeTransactional = TimeCategory.minus( endTime, startTime ) totalNonTransactionalDuration += elapsedTimeTransactional.toMilliseconds() @@ -374,8 +375,8 @@ class TransactionTest { private Case createTestCaseAndSetButton(String title, String buttonFieldId) { Case useCase = importHelper.createCase(title, testNet) - return dataService.setData(useCase, new DataSet([(buttonFieldId): new ButtonField(rawValue: 1)] - as Map<String, Field<?>>), superCreator.getSuperUser()).getCase() + return dataService.setData(new SetDataParams(useCase, new DataSet([(buttonFieldId): new ButtonField(rawValue: 1)] + as Map<String, Field<?>>), superCreator.getSuperUser())).getCase() } private Case findCaseByTitle(String title) { diff --git a/src/test/groovy/com/netgrif/application/engine/workflow/SetDataOnButtonTest.groovy b/src/test/groovy/com/netgrif/application/engine/workflow/SetDataOnButtonTest.groovy index 05c69a4c966..9f4b00fae0d 100644 --- a/src/test/groovy/com/netgrif/application/engine/workflow/SetDataOnButtonTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/workflow/SetDataOnButtonTest.groovy @@ -13,6 +13,7 @@ import com.netgrif.application.engine.startup.SuperCreator import com.netgrif.application.engine.workflow.domain.Case import com.netgrif.application.engine.workflow.domain.QTask import com.netgrif.application.engine.workflow.domain.Task +import com.netgrif.application.engine.workflow.domain.params.SetDataParams import com.netgrif.application.engine.workflow.domain.params.TaskParams import com.netgrif.application.engine.workflow.service.interfaces.IDataService import com.netgrif.application.engine.workflow.service.interfaces.ITaskService @@ -107,11 +108,11 @@ class SetDataOnButtonTest { Task testCaseTask = taskService.searchOne(QTask.task.caseTitle.eq(PARENT_CASE) & QTask.task.transitionId.eq(TEST_TRANSITION)) assert testCaseTask != null - dataService.setData(testCaseTask.stringId, new DataSet([ + dataService.setData(new SetDataParams(testCaseTask.stringId, new DataSet([ "button_0": new ButtonField(rawValue: 42), "button_1": new ButtonField(rawValue: 42), "button_2": new ButtonField(rawValue: 42) - ] as Map<String, Field<?>>), superCreator.getLoggedSuper()) + ] as Map<String, Field<?>>), superCreator.getSuperUser())) testCase = workflowService.findOne(testCase.getStringId()) diff --git a/src/test/groovy/com/netgrif/application/engine/workflow/UserRefsTest.groovy b/src/test/groovy/com/netgrif/application/engine/workflow/UserRefsTest.groovy index 035abd14f5c..d5996e75fec 100644 --- a/src/test/groovy/com/netgrif/application/engine/workflow/UserRefsTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/workflow/UserRefsTest.groovy @@ -12,7 +12,7 @@ import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetServi import com.netgrif.application.engine.startup.ImportHelper import com.netgrif.application.engine.startup.SuperCreator import com.netgrif.application.engine.workflow.domain.Case -import com.netgrif.application.engine.workflow.domain.TaskPair +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 @@ -79,9 +79,9 @@ class UserRefsTest { def _case = importHelper.createCase("$it" as String, net) String id = userService.findByEmail(userEmails[it % 2], true).getStringId() String taskId = _case.getTaskStringId("t1") - dataService.setData(taskId, new DataSet([ + dataService.setData(new SetDataParams(taskId, new DataSet([ "user_list_1": new UserListField(rawValue: new UserListFieldValue([dataService.makeUserFieldValue(id)])) - ] as Map<String, Field<?>>), superCreator.getLoggedSuper()).getCase() + ] as Map<String, Field<?>>), superCreator.getSuperUser())).getCase() userIds.add(id) } } From ad45169e18b6d9e00a56fc5444f4d9b3a5b6d96e Mon Sep 17 00:00:00 2001 From: chvostek <chvostek@netgrif.com> Date: Wed, 7 Aug 2024 10:59:48 +0200 Subject: [PATCH 29/48] [NAE-1998] Implement transactions for events - implement and use ActionDelegate.deleteCase --- .../domain/dataset/logic/action/ActionDelegate.groovy | 11 +++++++++++ .../petriNets/engine-processes/import_filters.xml | 4 ++-- .../engine-processes/preference_filter_item.xml | 2 +- .../petriNets/engine-processes/preference_item.xml | 2 +- .../petriNets/transaction/transaction_test.xml | 6 +++--- 5 files changed, 18 insertions(+), 7 deletions(-) diff --git a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy index fef93d32528..8f672b9bb93 100644 --- a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy +++ b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy @@ -40,6 +40,7 @@ import com.netgrif.application.engine.workflow.domain.* import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.EventOutcome import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.caseoutcomes.CaseEventOutcome import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.caseoutcomes.CreateCaseEventOutcome +import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.caseoutcomes.DeleteCaseEventOutcome import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.dataoutcomes.GetDataEventOutcome import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.dataoutcomes.SetDataEventOutcome import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.taskoutcomes.AssignTaskEventOutcome @@ -833,6 +834,16 @@ class ActionDelegate /*TODO: release/8.0.0: implements ActionAPI*/ { return outcome.getCase() } + Case deleteCase(Case useCase) { + DeleteCaseEventOutcome outcome = workflowService.deleteCase(new DeleteCaseParams(useCase)) + return outcome.case + } + + Case deleteCase(String caseId) { + DeleteCaseEventOutcome outcome = workflowService.deleteCase(new DeleteCaseParams(caseId)) + return outcome.case + } + Task assignTask(String transitionId, Case aCase = useCase, IUser user = userService.loggedOrSystem, Map<String, String> params = [:]) { String taskId = getTaskId(transitionId, aCase) TaskParams taskParams = TaskParams.builder() diff --git a/src/main/resources/petriNets/engine-processes/import_filters.xml b/src/main/resources/petriNets/engine-processes/import_filters.xml index ebb3a505d97..34029835e88 100644 --- a/src/main/resources/petriNets/engine-processes/import_filters.xml +++ b/src/main/resources/petriNets/engine-processes/import_filters.xml @@ -22,7 +22,7 @@ importedFilters: f.imported_filters; taskService.findAllById(importedFilters.value).forEach({filterTask -> - workflowService.deleteCase(filterTask.caseId) + deleteCase(filterTask.caseId) }) change importedFilters value { return [] } </action> @@ -148,7 +148,7 @@ importedFilters: f.imported_filters; taskService.findAllById(importedFilters.value).forEach({filterTask -> - workflowService.deleteCase(filterTask.caseId) + deleteCase(filterTask.caseId) }) change importedFilters value { [] } </action> diff --git a/src/main/resources/petriNets/engine-processes/preference_filter_item.xml b/src/main/resources/petriNets/engine-processes/preference_filter_item.xml index 19e478ba7bd..2af10fcbea8 100644 --- a/src/main/resources/petriNets/engine-processes/preference_filter_item.xml +++ b/src/main/resources/petriNets/engine-processes/preference_filter_item.xml @@ -116,7 +116,7 @@ ]) setDataWithPropagation(parentTask, dataSet) async.run { - workflowService.deleteCase(useCase.stringId) + deleteCase(useCase) } <!--@formatter:on--> </action> diff --git a/src/main/resources/petriNets/engine-processes/preference_item.xml b/src/main/resources/petriNets/engine-processes/preference_item.xml index bd83d21b85d..adca329eec2 100644 --- a/src/main/resources/petriNets/engine-processes/preference_item.xml +++ b/src/main/resources/petriNets/engine-processes/preference_item.xml @@ -61,7 +61,7 @@ def childCases = workflowService.findAllById(childCaseIds) async.run { childCases.each { - workflowService.deleteCase(it) + deleteCase(it) } } } diff --git a/src/test/resources/petriNets/transaction/transaction_test.xml b/src/test/resources/petriNets/transaction/transaction_test.xml index 78f5bb69fee..320e48ec05a 100644 --- a/src/test/resources/petriNets/transaction/transaction_test.xml +++ b/src/test/resources/petriNets/transaction/transaction_test.xml @@ -56,7 +56,7 @@ def myTransaction = transaction( event: { - workflowService.deleteCase(findCase({it.title.eq("toBeRemoved")})) + deleteCase(findCase({it.title.eq("toBeRemoved")})) createCase("transaction_test", "onButton") change text_without_action value { "xxx" } // not runtime exception on purpose @@ -146,7 +146,7 @@ com.netgrif.application.engine.petrinet.domain.VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser()) def toBeRemovedCase = createCase("transaction_test_secondary", "toBeRemoved") assignTask("t1", toBeRemovedCase) - workflowService.deleteCase(toBeRemovedCase.stringId) + deleteCase(toBeRemovedCase) createCase("transaction_test", "onButton") throw new RuntimeException("error") @@ -178,7 +178,7 @@ com.netgrif.application.engine.petrinet.domain.VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser()) def toBeRemovedCase = createCase("transaction_test_secondary", "toBeRemoved") assignTask("t1", toBeRemovedCase) - workflowService.deleteCase(toBeRemovedCase.stringId) + deleteCase(toBeRemovedCase) createCase("transaction_test", "onButton") }, From b94743236845fdb74a9cceeb439c12bbb2c89a94 Mon Sep 17 00:00:00 2001 From: chvostek <chvostek@netgrif.com> Date: Wed, 7 Aug 2024 16:47:57 +0200 Subject: [PATCH 30/48] [NAE-1998] Implement transactions for events - optimize PetriNetService.importPetriNet - fix some warnings --- .../engine/migration/ActionMigration.groovy | 10 +- .../engine/startup/ImportHelper.groovy | 3 +- .../engine/importer/service/Importer.java | 6 +- .../domain/params/ImportPetriNetParams.java | 37 +++++++ .../petrinet/service/PetriNetService.java | 101 +++++++++--------- .../service/interfaces/IPetriNetService.java | 17 +-- .../petrinet/web/PetriNetController.java | 13 ++- .../engine/action/AssignActionTest.groovy | 11 +- .../engine/action/AssignRemoveTest.groovy | 4 +- .../engine/action/RemoveActionTest.groovy | 4 +- .../auth/AuthenticationControllerTest.groovy | 4 +- .../engine/auth/SecurityContextTest.groovy | 17 +-- .../auth/TaskAuthorizationServiceTest.groovy | 7 +- .../WorkflowAuthorizationServiceTest.groovy | 7 +- .../elastic/DataSearchRequestTest.groovy | 8 +- .../engine/elastic/ElasticSearchTest.groovy | 12 ++- .../engine/elastic/ElasticTaskTest.groovy | 4 +- .../engine/elastic/ReindexTest.groovy | 4 +- .../engine/history/HistoryServiceTest.groovy | 4 +- .../importer/AllDataTransitionTest.groovy | 6 +- .../PredefinedRolesPermissionsTest.groovy | 14 +-- .../engine/importer/UserListTest.groovy | 4 +- .../engine/insurance/EncryptionTest.groovy | 6 +- .../engine/insurance/mvc/InsuranceTest.groovy | 6 +- .../ipc/AssignCancelFinishWithCaseTest.groovy | 8 +- .../application/engine/ipc/CaseApiTest.groovy | 7 +- .../application/engine/ipc/TaskApiTest.groovy | 24 +++-- .../ElasticSearchViewPermissionTest.groovy | 7 +- .../petrinet/domain/ActionRefTest.groovy | 6 +- .../petrinet/domain/ArcOrderTest.groovy | 6 +- .../petrinet/domain/ArcReferenceTest.groovy | 2 +- .../engine/petrinet/domain/EventTest.groovy | 4 +- .../petrinet/domain/FunctionsTest.groovy | 52 ++++++--- .../petrinet/domain/ImporterTest.groovy | 27 +++-- .../petrinet/domain/PetriNetTest.groovy | 15 ++- .../domain/dataset/CaseFieldTest.groovy | 13 ++- .../domain/dataset/ChangeBehaviorTest.groovy | 5 +- .../dataset/ChangeCasePropertyTest.groovy | 4 +- .../dataset/ChangeFieldValueInitTest.groovy | 4 +- .../domain/dataset/ChoiceFieldTest.groovy | 8 +- .../domain/dataset/DynamicCaseNameTest.groovy | 4 +- .../domain/dataset/DynamicChoicesTest.groovy | 20 ++-- .../dataset/DynamicDefaultValueTest.groovy | 4 +- .../dataset/DynamicEnumerationTest.groovy | 4 +- .../DynamicValidationPerformanceTest.groovy | 7 +- .../dataset/DynamicValidationTest.groovy | 2 +- .../domain/dataset/FileFieldTest.groovy | 8 +- .../domain/dataset/FileListFieldTest.groovy | 4 +- .../domain/dataset/MapFieldTest.groovy | 13 ++- .../domain/roles/ProcessRoleTest.groovy | 8 +- .../service/CachePetriNetServiceTest.groovy | 6 +- .../service/PetriNetServiceTest.groovy | 16 ++- .../web/PetriNetControllerTest.groovy | 4 +- .../engine/transaction/TransactionTest.groovy | 6 +- .../engine/workflow/DataServiceTest.groovy | 23 ++-- .../engine/workflow/NewInitTest.groovy | 4 +- .../workflow/SetDataOnButtonTest.groovy | 4 +- .../engine/workflow/TaskRefInitTest.groovy | 7 +- .../workflow/TaskRefPropagationTest.groovy | 7 +- .../engine/workflow/UserRefsTest.groovy | 4 +- .../workflow/WorkflowServiceTest.groovy | 19 ++-- ...NetgrifLdapAuthenticationProviderTest.java | 21 ++-- .../ConstructorAndDestructorTest.java | 5 +- .../engine/importer/ImporterTest.java | 18 ++-- .../service/ProcessRoleServiceTest.java | 16 ++- .../engine/rules/service/RuleEngineTest.java | 13 ++- .../RuleEvaluationScheduleServiceTest.java | 4 +- .../workflow/service/TaskServiceTest.java | 19 ++-- .../engine/workflow/web/VariableArcsTest.java | 4 +- .../transaction/transaction_test.xml | 6 +- 70 files changed, 498 insertions(+), 283 deletions(-) create mode 100644 src/main/java/com/netgrif/application/engine/petrinet/domain/params/ImportPetriNetParams.java diff --git a/src/main/groovy/com/netgrif/application/engine/migration/ActionMigration.groovy b/src/main/groovy/com/netgrif/application/engine/migration/ActionMigration.groovy index fc8c34870ee..ea2c95a34fe 100644 --- a/src/main/groovy/com/netgrif/application/engine/migration/ActionMigration.groovy +++ b/src/main/groovy/com/netgrif/application/engine/migration/ActionMigration.groovy @@ -3,6 +3,7 @@ package com.netgrif.application.engine.migration import com.netgrif.application.engine.auth.service.interfaces.IUserService import com.netgrif.application.engine.petrinet.domain.PetriNet import com.netgrif.application.engine.petrinet.domain.VersionType +import com.netgrif.application.engine.petrinet.domain.params.ImportPetriNetParams import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome import groovy.util.logging.Slf4j @@ -20,11 +21,12 @@ class ActionMigration { private IPetriNetService petriNetService @Autowired - private IUserService userService; + private IUserService userService void migrateActions(String petriNetPath) { InputStream netStream = new ClassPathResource(petriNetPath).inputStream - ImportPetriNetEventOutcome newPetriNet = petriNetService.importPetriNet(netStream, VersionType.MAJOR, userService.loggedOrSystem.transformToLoggedUser()) + ImportPetriNetEventOutcome newPetriNet = petriNetService.importPetriNet(new ImportPetriNetParams(netStream, + VersionType.MAJOR, userService.loggedOrSystem.transformToLoggedUser())) List<PetriNet> oldPetriNets if(newPetriNet.getNet() != null) { @@ -50,7 +52,7 @@ class ActionMigration { } } - 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 @@ -58,7 +60,7 @@ class ActionMigration { } } - 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) { diff --git a/src/main/groovy/com/netgrif/application/engine/startup/ImportHelper.groovy b/src/main/groovy/com/netgrif/application/engine/startup/ImportHelper.groovy index 8215b8a1538..79e9495d055 100644 --- a/src/main/groovy/com/netgrif/application/engine/startup/ImportHelper.groovy +++ b/src/main/groovy/com/netgrif/application/engine/startup/ImportHelper.groovy @@ -7,6 +7,7 @@ import com.netgrif.application.engine.orgstructure.groups.interfaces.INextGroupS 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.params.ImportPetriNetParams import com.netgrif.application.engine.petrinet.domain.repositories.PetriNetRepository import com.netgrif.application.engine.petrinet.domain.roles.ProcessRole import com.netgrif.application.engine.petrinet.service.ProcessRoleService @@ -98,7 +99,7 @@ class ImportHelper { Optional<PetriNet> createNet(String fileName, VersionType release = VersionType.MAJOR, LoggedUser author = userService.getSystem().transformToLoggedUser(), String uriNodeId = uriService.getRoot().stringId) { InputStream netStream = new ClassPathResource("petriNets/$fileName" as String).inputStream - PetriNet petriNet = petriNetService.importPetriNet(netStream, release, author, uriNodeId).getNet() + PetriNet petriNet = petriNetService.importPetriNet(new ImportPetriNetParams(netStream, release, author, uriNodeId)).getNet() log.info("Imported '${petriNet?.title?.defaultValue}' ['${petriNet?.identifier}', ${petriNet?.stringId}]") return Optional.of(petriNet) } diff --git a/src/main/java/com/netgrif/application/engine/importer/service/Importer.java b/src/main/java/com/netgrif/application/engine/importer/service/Importer.java index 3edff43175f..eef9032a52d 100644 --- a/src/main/java/com/netgrif/application/engine/importer/service/Importer.java +++ b/src/main/java/com/netgrif/application/engine/importer/service/Importer.java @@ -725,7 +725,7 @@ protected void addDataWithDefaultGroup(Transition transition, DataRef dataRef) t protected void addDataGroup(Transition transition, com.netgrif.application.engine.importer.model.DataGroup importDataGroup, int index) throws MissingIconKeyException { DataGroup dataGroup = new DataGroup(); - if (importDataGroup.getId() != null && importDataGroup.getId().length() > 0) { + if (importDataGroup.getId() != null && !importDataGroup.getId().isEmpty()) { dataGroup.setImportId(importDataGroup.getId()); } else { dataGroup.setImportId(transition.getImportId() + "_dg_" + index); @@ -1321,9 +1321,7 @@ protected void setMetaData() throws MissingPetriNetMetaDataException { protected Map<String, String> buildTagsMap(List<Tag> tagsList) { Map<String, String> tags = new HashMap<>(); if (tagsList != null) { - tagsList.forEach(tag -> { - tags.put(tag.getKey(), tag.getValue()); - }); + tagsList.forEach(tag -> tags.put(tag.getKey(), tag.getValue())); } return tags; } diff --git a/src/main/java/com/netgrif/application/engine/petrinet/domain/params/ImportPetriNetParams.java b/src/main/java/com/netgrif/application/engine/petrinet/domain/params/ImportPetriNetParams.java new file mode 100644 index 00000000000..178564e1900 --- /dev/null +++ b/src/main/java/com/netgrif/application/engine/petrinet/domain/params/ImportPetriNetParams.java @@ -0,0 +1,37 @@ +package com.netgrif.application.engine.petrinet.domain.params; + +import com.netgrif.application.engine.auth.domain.LoggedUser; +import com.netgrif.application.engine.petrinet.domain.VersionType; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; + +import java.io.InputStream; +import java.util.HashMap; +import java.util.Map; + +@Data +@AllArgsConstructor +@Builder(builderMethodName = "with") +public class ImportPetriNetParams { + + private InputStream xmlFile; + private String uriNodeId; + private VersionType releaseType; + private LoggedUser author; + @Builder.Default + private Map<String, String> params = new HashMap<>(); + + public ImportPetriNetParams(InputStream xmlFile, VersionType releaseType, LoggedUser author, String uriNodeId) { + this.xmlFile = xmlFile; + this.releaseType = releaseType; + this.author = author; + this.uriNodeId = uriNodeId; + } + + public ImportPetriNetParams(InputStream xmlFile, VersionType releaseType, LoggedUser author) { + this.xmlFile = xmlFile; + this.releaseType = releaseType; + this.author = author; + } +} diff --git a/src/main/java/com/netgrif/application/engine/petrinet/service/PetriNetService.java b/src/main/java/com/netgrif/application/engine/petrinet/service/PetriNetService.java index 999f06be2b3..6991d1858e4 100644 --- a/src/main/java/com/netgrif/application/engine/petrinet/service/PetriNetService.java +++ b/src/main/java/com/netgrif/application/engine/petrinet/service/PetriNetService.java @@ -18,10 +18,10 @@ import com.netgrif.application.engine.petrinet.domain.PetriNet; import com.netgrif.application.engine.petrinet.domain.PetriNetSearch; import com.netgrif.application.engine.petrinet.domain.Transition; -import com.netgrif.application.engine.petrinet.domain.VersionType; import com.netgrif.application.engine.petrinet.domain.dataset.logic.action.Action; import com.netgrif.application.engine.petrinet.domain.dataset.logic.action.ActionRunner; import com.netgrif.application.engine.petrinet.domain.events.EventPhase; +import com.netgrif.application.engine.petrinet.domain.params.ImportPetriNetParams; import com.netgrif.application.engine.petrinet.domain.repositories.PetriNetRepository; import com.netgrif.application.engine.petrinet.domain.throwable.MissingPetriNetMetaDataException; import com.netgrif.application.engine.petrinet.domain.version.Version; @@ -60,7 +60,6 @@ import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.IOException; -import java.io.InputStream; import java.nio.file.Path; import java.util.*; import java.util.stream.Collectors; @@ -180,70 +179,72 @@ public PetriNet clone(ObjectId petriNetId) { return self.get(petriNetId).clone(); } + /** + * todo javadoc + * */ @Override - @Deprecated - public ImportPetriNetEventOutcome importPetriNet(InputStream xmlFile, String releaseType, LoggedUser author) throws IOException, MissingPetriNetMetaDataException, MissingIconKeyException { - return importPetriNet(xmlFile, VersionType.valueOf(releaseType.trim().toUpperCase()), author, uriService.getRoot().getStringId()); - } - - @Override - @Deprecated - public ImportPetriNetEventOutcome importPetriNet(InputStream xmlFile, String releaseType, LoggedUser author, String uriNodeId) throws IOException, MissingPetriNetMetaDataException, MissingIconKeyException { - return importPetriNet(xmlFile, VersionType.valueOf(releaseType.trim().toUpperCase()), author, uriNodeId); - } - - @Override - public ImportPetriNetEventOutcome importPetriNet(InputStream xmlFile, VersionType releaseType, LoggedUser author) throws IOException, MissingPetriNetMetaDataException, MissingIconKeyException { - return importPetriNet(xmlFile, releaseType, author, uriService.getRoot().getStringId()); - } - - @Override - public ImportPetriNetEventOutcome importPetriNet(InputStream xmlFile, VersionType releaseType, LoggedUser author, Map<String, String> params) throws IOException, MissingPetriNetMetaDataException, MissingIconKeyException { - return importPetriNet(xmlFile, releaseType, author, uriService.getRoot().getStringId(), params); - } - - @Override - public ImportPetriNetEventOutcome importPetriNet(InputStream xmlFile, VersionType releaseType, LoggedUser author, String uriNodeId) throws IOException, MissingPetriNetMetaDataException, MissingIconKeyException { - return importPetriNet(xmlFile, releaseType, author, uriNodeId, new HashMap<>()); - } + @Transactional + public ImportPetriNetEventOutcome importPetriNet(ImportPetriNetParams importPetriNetParams) throws IOException, + MissingPetriNetMetaDataException, MissingIconKeyException { + fillMissingAttributes(importPetriNetParams); - @Override - public ImportPetriNetEventOutcome importPetriNet(InputStream xmlFile, VersionType releaseType, LoggedUser author, String uriNodeId, Map<String, String> params) throws IOException, MissingPetriNetMetaDataException, MissingIconKeyException { ImportPetriNetEventOutcome outcome = new ImportPetriNetEventOutcome(); ByteArrayOutputStream xmlCopy = new ByteArrayOutputStream(); - IOUtils.copy(xmlFile, xmlCopy); + IOUtils.copy(importPetriNetParams.getXmlFile(), xmlCopy); Optional<PetriNet> imported = getImporter().importPetriNet(new ByteArrayInputStream(xmlCopy.toByteArray())); if (imported.isEmpty()) { return outcome; } PetriNet net = imported.get(); - net.setUriNodeId(uriNodeId); + net.setUriNodeId(importPetriNetParams.getUriNodeId()); - // TODO: release/8.0.0 fix cacheable - PetriNet existingNet = getNewestVersionByIdentifier(net.getIdentifier()); + PetriNet existingNet = self.getNewestVersionByIdentifier(net.getIdentifier()); if (existingNet != null) { net.setVersion(existingNet.getVersion()); - net.incrementVersion(releaseType); + net.incrementVersion(importPetriNetParams.getReleaseType()); } processRoleService.saveAll(net.getRoles().values()); - net.setAuthor(author.transformToAuthor()); + net.setAuthor(importPetriNetParams.getAuthor().transformToAuthor()); functionCacheService.cachePetriNetFunctions(net); Path savedPath = getImporter().saveNetFile(net, new ByteArrayInputStream(xmlCopy.toByteArray())); xmlCopy.close(); - log.info("Petri net {} ({} v{}) imported successfully and saved in a folder: {}", net.getTitle(), net.getInitials(), net.getVersion(), savedPath.toString()); + log.info("Petri net {} ({} v{}) imported successfully and saved in a folder: {}", net.getTitle(), net.getInitials(), + net.getVersion(), savedPath.toString()); + + outcome.setOutcomes(eventService.runActions(net.getPreUploadActions(), null, Optional.empty(), importPetriNetParams.getParams())); + boolean wasSaved = evaluateRules(net, EventPhase.PRE); - outcome.setOutcomes(eventService.runActions(net.getPreUploadActions(), null, Optional.empty(), params)); - evaluateRules(net, EventPhase.PRE); historyService.save(new ImportPetriNetEventLog(null, EventPhase.PRE, net.getObjectId())); - save(net); - outcome.setOutcomes(eventService.runActions(net.getPostUploadActions(), null, Optional.empty(), params)); + + if (!wasSaved) { + save(net); + } + + outcome.setOutcomes(eventService.runActions(net.getPostUploadActions(), null, Optional.empty(), importPetriNetParams.getParams())); evaluateRules(net, EventPhase.POST); + historyService.save(new ImportPetriNetEventLog(null, EventPhase.POST, net.getObjectId())); + addMessageToOutcome(net, ProcessEventType.UPLOAD, outcome); outcome.setNet(imported.get()); return outcome; } + private void fillMissingAttributes(ImportPetriNetParams importPetriNetParams) throws IllegalArgumentException { + if (importPetriNetParams.getXmlFile() == null) { + throw new IllegalArgumentException("No Petriflow source file provided."); + } + if (importPetriNetParams.getAuthor() == null) { + throw new IllegalArgumentException("No author of PetriNet provided."); + } + if (importPetriNetParams.getReleaseType() == null) { + throw new IllegalArgumentException("Version type is null."); + } + if (importPetriNetParams.getUriNodeId() == null) { + importPetriNetParams.setUriNodeId(uriService.getRoot().getStringId()); + } + } + private ImportPetriNetEventOutcome addMessageToOutcome(PetriNet net, ProcessEventType type, ImportPetriNetEventOutcome outcome) { if (net.getProcessEvents().containsKey(type)) { outcome.setMessage(net.getProcessEvents().get(type).getMessage()); @@ -251,11 +252,16 @@ private ImportPetriNetEventOutcome addMessageToOutcome(PetriNet net, ProcessEven return outcome; } - protected void evaluateRules(PetriNet net, EventPhase phase) { + /** + * @return true if the net was saved + * */ + private boolean evaluateRules(PetriNet net, EventPhase phase) { int rulesExecuted = ruleEngine.evaluateRules(net, new NetImportedFact(net.getStringId(), phase)); if (rulesExecuted > 0) { save(net); + return true; } + return false; } @Override @@ -348,9 +354,7 @@ public PetriNetImportReference getNetFromCase(String caseId) { PetriNetImportReference pn = new PetriNetImportReference(); useCase.getPetriNet().getTransitions().forEach((key, value) -> pn.getTransitions().add(new TransitionImportReference(value))); useCase.getPetriNet().getPlaces().forEach((key, value) -> pn.getPlaces().add(new PlaceImportReference(value))); - useCase.getPetriNet().getArcs().forEach((key, arcs) -> { - arcs.forEach(arc -> pn.getArcs().add(new ArcImportReference(arc))); - }); + useCase.getPetriNet().getArcs().forEach((key, arcs) -> arcs.forEach(arc -> pn.getArcs().add(new ArcImportReference(arc)))); pn.getAssignedTasks().addAll(historyService.findAllAssignTaskEventLogsByCaseId(caseId) .stream().map(TaskEventLog::getTransitionId).filter(Objects::nonNull).distinct().collect(Collectors.toList())); pn.getFinishedTasks().addAll(historyService.findAllFinishTaskEventLogsByCaseId(caseId) @@ -521,7 +525,7 @@ private void addValueCriteria(Query query, Query queryTotal, Criteria criteria) @Transactional public void deletePetriNet(String processId, LoggedUser loggedUser) { Optional<PetriNet> petriNetOptional = repository.findById(processId); - if (!petriNetOptional.isPresent()) { + if (petriNetOptional.isEmpty()) { throw new IllegalArgumentException("Could not find process with id [" + processId + "]"); } @@ -540,7 +544,8 @@ public void deletePetriNet(String processId, LoggedUser loggedUser) { } - log.info("[{}]: User [{}] is deleting Petri net {} version {}", processId, userService.getLoggedOrSystem().getStringId(), petriNet.getIdentifier(), petriNet.getVersion().toString()); + log.info("[{}]: User [{}] is deleting Petri net {} version {}", processId, userService.getLoggedOrSystem().getStringId(), + petriNet.getIdentifier(), petriNet.getVersion().toString()); this.repository.deleteById(petriNet.getObjectId()); this.evictCache(petriNet); // net functions must be removed from cache after it was deleted from repository @@ -557,9 +562,7 @@ private Criteria getProcessRolesCriteria(LoggedUser user) { public void runActions(List<Action> actions, PetriNet petriNet) { log.info("Running actions of net [{}]", petriNet.getStringId()); - actions.forEach(action -> { - actionsRunner.run(action, null, new HashMap<>(), petriNet.getFunctions()); - }); + actions.forEach(action -> actionsRunner.run(action, null, new HashMap<>(), petriNet.getFunctions())); } protected <T> T requireNonNull(T obj, Object... item) { diff --git a/src/main/java/com/netgrif/application/engine/petrinet/service/interfaces/IPetriNetService.java b/src/main/java/com/netgrif/application/engine/petrinet/service/interfaces/IPetriNetService.java index 1e2ca55b692..825c7fc9ce7 100644 --- a/src/main/java/com/netgrif/application/engine/petrinet/service/interfaces/IPetriNetService.java +++ b/src/main/java/com/netgrif/application/engine/petrinet/service/interfaces/IPetriNetService.java @@ -5,9 +5,9 @@ import com.netgrif.application.engine.petrinet.domain.PetriNet; import com.netgrif.application.engine.petrinet.domain.PetriNetSearch; import com.netgrif.application.engine.petrinet.domain.Transition; -import com.netgrif.application.engine.petrinet.domain.VersionType; import com.netgrif.application.engine.petrinet.domain.dataset.Field; import com.netgrif.application.engine.petrinet.domain.dataset.logic.action.Action; +import com.netgrif.application.engine.petrinet.domain.params.ImportPetriNetParams; import com.netgrif.application.engine.petrinet.domain.throwable.MissingPetriNetMetaDataException; import com.netgrif.application.engine.petrinet.domain.version.Version; import com.netgrif.application.engine.petrinet.web.responsebodies.DataFieldReference; @@ -21,7 +21,6 @@ import org.springframework.data.domain.Pageable; import java.io.IOException; -import java.io.InputStream; import java.util.*; public interface IPetriNetService { @@ -44,19 +43,7 @@ static DataFieldReference transformToReference(PetriNet net, Transition transiti PetriNet clone(ObjectId petriNetId); - @Deprecated - ImportPetriNetEventOutcome importPetriNet(InputStream xmlFile, String releaseType, LoggedUser user) throws IOException, MissingPetriNetMetaDataException, MissingIconKeyException; - - @Deprecated - ImportPetriNetEventOutcome importPetriNet(InputStream xmlFile, String releaseType, LoggedUser user, String uriNodeId) throws IOException, MissingPetriNetMetaDataException, MissingIconKeyException; - - ImportPetriNetEventOutcome importPetriNet(InputStream xmlFile, VersionType releaseType, LoggedUser user) throws IOException, MissingPetriNetMetaDataException, MissingIconKeyException; - - ImportPetriNetEventOutcome importPetriNet(InputStream xmlFile, VersionType releaseType, LoggedUser user, Map<String, String> params) throws IOException, MissingPetriNetMetaDataException, MissingIconKeyException; - - ImportPetriNetEventOutcome importPetriNet(InputStream xmlFile, VersionType releaseType, LoggedUser user, String uriNodeId) throws IOException, MissingPetriNetMetaDataException, MissingIconKeyException; - - ImportPetriNetEventOutcome importPetriNet(InputStream xmlFile, VersionType releaseType, LoggedUser user, String uriNodeId, Map<String, String> params) throws IOException, MissingPetriNetMetaDataException, MissingIconKeyException; + ImportPetriNetEventOutcome importPetriNet(ImportPetriNetParams importPetriNetParams) throws IOException, MissingPetriNetMetaDataException, MissingIconKeyException; Optional<PetriNet> save(PetriNet petriNet); diff --git a/src/main/java/com/netgrif/application/engine/petrinet/web/PetriNetController.java b/src/main/java/com/netgrif/application/engine/petrinet/web/PetriNetController.java index 80116c2cd5c..f8862d6ee96 100644 --- a/src/main/java/com/netgrif/application/engine/petrinet/web/PetriNetController.java +++ b/src/main/java/com/netgrif/application/engine/petrinet/web/PetriNetController.java @@ -7,12 +7,12 @@ import com.netgrif.application.engine.petrinet.domain.PetriNet; import com.netgrif.application.engine.petrinet.domain.PetriNetSearch; import com.netgrif.application.engine.petrinet.domain.VersionType; +import com.netgrif.application.engine.petrinet.domain.params.ImportPetriNetParams; import com.netgrif.application.engine.petrinet.domain.throwable.MissingPetriNetMetaDataException; import com.netgrif.application.engine.petrinet.domain.version.StringToVersionConverter; import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService; import com.netgrif.application.engine.petrinet.service.interfaces.IProcessRoleService; import com.netgrif.application.engine.petrinet.web.responsebodies.*; -import com.netgrif.application.engine.workflow.domain.FileStorageConfiguration; import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome; import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.response.EventOutcomeWithMessage; import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.response.EventOutcomeWithMessageResource; @@ -62,9 +62,6 @@ @Tag(name = "PetriNet") public class PetriNetController { - @Autowired - private FileStorageConfiguration fileStorageConfiguration; - @Autowired private IPetriNetService service; @@ -94,7 +91,13 @@ public EntityModel<EventOutcomeWithMessage> importPetriNet( Authentication auth, Locale locale) throws MissingPetriNetMetaDataException, MissingIconKeyException { try { VersionType release = releaseType == null ? VersionType.MAJOR : VersionType.valueOf(releaseType.trim().toUpperCase()); - ImportPetriNetEventOutcome importPetriNetOutcome = service.importPetriNet(multipartFile.getInputStream(), release, (LoggedUser) auth.getPrincipal(), uriNodeId); + ImportPetriNetParams importPetriNetParams = ImportPetriNetParams.with() + .xmlFile(multipartFile.getInputStream()) + .releaseType(release) + .author((LoggedUser) auth.getPrincipal()) + .uriNodeId(uriNodeId) + .build(); + ImportPetriNetEventOutcome importPetriNetOutcome = service.importPetriNet(importPetriNetParams); return EventOutcomeWithMessageResource.successMessage("Petri net " + multipartFile.getOriginalFilename() + " imported successfully", importPetriNetOutcome); } catch (IOException e) { log.error("Importing Petri net failed: ", e); diff --git a/src/test/groovy/com/netgrif/application/engine/action/AssignActionTest.groovy b/src/test/groovy/com/netgrif/application/engine/action/AssignActionTest.groovy index f67f8f90585..d4cbe9f23e8 100644 --- a/src/test/groovy/com/netgrif/application/engine/action/AssignActionTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/action/AssignActionTest.groovy @@ -8,6 +8,7 @@ import com.netgrif.application.engine.auth.domain.repositories.UserRepository import com.netgrif.application.engine.importer.service.Importer import com.netgrif.application.engine.petrinet.domain.PetriNet import com.netgrif.application.engine.petrinet.domain.VersionType +import com.netgrif.application.engine.petrinet.domain.params.ImportPetriNetParams import com.netgrif.application.engine.petrinet.domain.roles.ProcessRole import com.netgrif.application.engine.petrinet.domain.roles.ProcessRoleRepository import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService @@ -25,7 +26,6 @@ import org.springframework.hateoas.MediaTypes import org.springframework.http.MediaType import org.springframework.mock.web.MockHttpServletRequest import org.springframework.security.authentication.UsernamePasswordAuthenticationToken -import org.springframework.security.core.Authentication import org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors import org.springframework.security.web.authentication.WebAuthenticationDetails import org.springframework.test.context.ActiveProfiles @@ -36,7 +36,6 @@ import org.springframework.test.web.servlet.result.MockMvcResultMatchers import org.springframework.test.web.servlet.setup.MockMvcBuilders import org.springframework.web.context.WebApplicationContext -import static org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors.authentication import static org.springframework.security.test.web.servlet.setup.SecurityMockMvcConfigurers.springSecurity @ExtendWith(SpringExtension.class) @@ -103,10 +102,12 @@ class AssignActionTest { } private void createMainAndSecondaryNet() { - def mainNet = petriNetService.importPetriNet(new FileInputStream("src/test/resources/assignRoleMainNet_test_.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()) + def mainNet = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/assignRoleMainNet_test_.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())) assert mainNet.getNet() != null - def secondaryNet = petriNetService.importPetriNet(new FileInputStream("src/test/resources/assignRoleSecondaryNet_test.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()) + def secondaryNet = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/assignRoleSecondaryNet_test.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())) assert secondaryNet.getNet() != null this.mainNet = mainNet.getNet() @@ -118,7 +119,7 @@ class AssignActionTest { User user = userRepository.findByEmail(USER_EMAIL) authentication = new UsernamePasswordAuthenticationToken(USER_EMAIL, USER_PASSWORD) - authentication.setDetails(new WebAuthenticationDetails(new MockHttpServletRequest())); + authentication.setDetails(new WebAuthenticationDetails(new MockHttpServletRequest())) String roleIdInMainNet = mainNet.getRoles().find { it.value.name.defaultValue == "admin_main" }.key diff --git a/src/test/groovy/com/netgrif/application/engine/action/AssignRemoveTest.groovy b/src/test/groovy/com/netgrif/application/engine/action/AssignRemoveTest.groovy index 3400ae4841e..54e84ec5feb 100644 --- a/src/test/groovy/com/netgrif/application/engine/action/AssignRemoveTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/action/AssignRemoveTest.groovy @@ -3,6 +3,7 @@ package com.netgrif.application.engine.action import com.netgrif.application.engine.TestHelper import com.netgrif.application.engine.auth.service.interfaces.IUserService import com.netgrif.application.engine.petrinet.domain.VersionType +import com.netgrif.application.engine.petrinet.domain.params.ImportPetriNetParams import com.netgrif.application.engine.petrinet.domain.throwable.MissingPetriNetMetaDataException import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService import com.netgrif.application.engine.startup.ImportHelper @@ -67,7 +68,8 @@ class AssignRemoveTest { @Test @Disabled("Create functions or update test") void testAssignAndRemoveRole() throws MissingPetriNetMetaDataException, IOException { - ImportPetriNetEventOutcome netOptional = petriNetService.importPetriNet(new FileInputStream("src/test/resources/petriNets/role_assign_remove_test.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()) + ImportPetriNetEventOutcome netOptional = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/petriNets/role_assign_remove_test.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())) assert netOptional.getNet() != null def net = netOptional.getNet() diff --git a/src/test/groovy/com/netgrif/application/engine/action/RemoveActionTest.groovy b/src/test/groovy/com/netgrif/application/engine/action/RemoveActionTest.groovy index bba521ce353..742bb72b49d 100644 --- a/src/test/groovy/com/netgrif/application/engine/action/RemoveActionTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/action/RemoveActionTest.groovy @@ -9,6 +9,7 @@ import com.netgrif.application.engine.configuration.properties.SuperAdminConfigu import com.netgrif.application.engine.importer.service.Importer import com.netgrif.application.engine.petrinet.domain.PetriNet import com.netgrif.application.engine.petrinet.domain.VersionType +import com.netgrif.application.engine.petrinet.domain.params.ImportPetriNetParams import com.netgrif.application.engine.petrinet.domain.roles.ProcessRole import com.netgrif.application.engine.petrinet.domain.roles.ProcessRoleRepository import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService @@ -97,7 +98,8 @@ class RemoveActionTest { .apply(springSecurity()) .build() - def net = petriNetService.importPetriNet(new FileInputStream("src/test/resources/removeRole_test.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()) + def net = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/removeRole_test.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())) assert net.getNet() != null this.petriNet = net.getNet() diff --git a/src/test/groovy/com/netgrif/application/engine/auth/AuthenticationControllerTest.groovy b/src/test/groovy/com/netgrif/application/engine/auth/AuthenticationControllerTest.groovy index 0cd0d03ca7c..7662d7e2403 100644 --- a/src/test/groovy/com/netgrif/application/engine/auth/AuthenticationControllerTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/auth/AuthenticationControllerTest.groovy @@ -13,6 +13,7 @@ import com.netgrif.application.engine.auth.web.requestbodies.RegistrationRequest import com.netgrif.application.engine.importer.service.Importer import com.netgrif.application.engine.mail.EmailType import com.netgrif.application.engine.petrinet.domain.VersionType +import com.netgrif.application.engine.petrinet.domain.params.ImportPetriNetParams import com.netgrif.application.engine.petrinet.domain.roles.ProcessRole import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService import com.netgrif.application.engine.startup.ImportHelper @@ -84,7 +85,8 @@ class AuthenticationControllerTest { smtpServer = new GreenMail(new ServerSetup(2525, null, "smtp")) smtpServer.start() - def net = petriNetService.importPetriNet(new FileInputStream("src/test/resources/insurance_portal_demo_test.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()) + def net = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/insurance_portal_demo_test.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())) assert net.getNet() != null if (authorityRepository.count() == 0) importHelper.createAuthority(Authority.user) diff --git a/src/test/groovy/com/netgrif/application/engine/auth/SecurityContextTest.groovy b/src/test/groovy/com/netgrif/application/engine/auth/SecurityContextTest.groovy index 9755a9e9196..1504f5b49b7 100644 --- a/src/test/groovy/com/netgrif/application/engine/auth/SecurityContextTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/auth/SecurityContextTest.groovy @@ -9,23 +9,23 @@ import com.netgrif.application.engine.auth.service.interfaces.IUserService import com.netgrif.application.engine.petrinet.domain.PetriNet import com.netgrif.application.engine.petrinet.domain.VersionType import com.netgrif.application.engine.petrinet.domain.dataset.logic.action.ActionDelegate +import com.netgrif.application.engine.petrinet.domain.params.ImportPetriNetParams import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService import com.netgrif.application.engine.petrinet.service.interfaces.IProcessRoleService import com.netgrif.application.engine.security.service.ISecurityContextService -import com.netgrif.application.engine.startup.ImportHelper import com.netgrif.application.engine.startup.SuperCreator import groovy.transform.CompileStatic import org.junit.jupiter.api.BeforeEach -import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.Test import org.junit.jupiter.api.extension.ExtendWith -import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Autowired import org.springframework.boot.test.context.SpringBootTest import org.springframework.security.authentication.UsernamePasswordAuthenticationToken -import org.springframework.security.core.context.SecurityContextHolder; -import org.springframework.test.context.ActiveProfiles; +import org.springframework.security.core.context.SecurityContextHolder +import org.springframework.test.context.ActiveProfiles import org.springframework.test.context.junit.jupiter.SpringExtension -import java.util.stream.Collectors; +import java.util.stream.Collectors @ExtendWith(SpringExtension.class) @ActiveProfiles(["test"]) @@ -68,7 +68,8 @@ class SecurityContextTest { user = userService.save(new User('test@email.com', 'password', 'Test', 'User')) assert user != null - net = petriNetService.importPetriNet(new FileInputStream("src/test/resources/all_data.xml"), VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser()).getNet() + net = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/all_data.xml"), VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser())).getNet() assert net != null } @@ -76,7 +77,7 @@ class SecurityContextTest { void addRole() { Set<String> roleIds = net.getRoles().keySet() - UsernamePasswordAuthenticationToken token = new UsernamePasswordAuthenticationToken(user.transformToLoggedUser(), user.transformToLoggedUser().getPassword(), user.transformToLoggedUser().getAuthorities()); + UsernamePasswordAuthenticationToken token = new UsernamePasswordAuthenticationToken(user.transformToLoggedUser(), user.transformToLoggedUser().getPassword(), user.transformToLoggedUser().getAuthorities()) SecurityContextHolder.getContext().setAuthentication(token) // situation 1 diff --git a/src/test/groovy/com/netgrif/application/engine/auth/TaskAuthorizationServiceTest.groovy b/src/test/groovy/com/netgrif/application/engine/auth/TaskAuthorizationServiceTest.groovy index 8a22d0776f7..e6648de109b 100644 --- a/src/test/groovy/com/netgrif/application/engine/auth/TaskAuthorizationServiceTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/auth/TaskAuthorizationServiceTest.groovy @@ -12,6 +12,7 @@ import com.netgrif.application.engine.petrinet.domain.VersionType import com.netgrif.application.engine.petrinet.domain.dataset.Field import com.netgrif.application.engine.petrinet.domain.dataset.UserListField import com.netgrif.application.engine.petrinet.domain.dataset.UserListFieldValue +import com.netgrif.application.engine.petrinet.domain.params.ImportPetriNetParams import com.netgrif.application.engine.petrinet.domain.roles.ProcessRole import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService import com.netgrif.application.engine.startup.ImportHelper @@ -115,11 +116,13 @@ class TaskAuthorizationServiceTest { @BeforeEach void init() { testHelper.truncateDbs() - ImportPetriNetEventOutcome net = petriNetService.importPetriNet(new FileInputStream("src/test/resources/task_authorization_service_test.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()) + ImportPetriNetEventOutcome net = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/task_authorization_service_test.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())) assert net.getNet() != null this.net = net.getNet() - ImportPetriNetEventOutcome netWithUserRefs = petriNetService.importPetriNet(new FileInputStream("src/test/resources/task_authorization_service_test_with_userRefs.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()) + ImportPetriNetEventOutcome netWithUserRefs = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/task_authorization_service_test_with_userRefs.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())) assert netWithUserRefs.getNet() != null this.netWithUserRefs = netWithUserRefs.getNet() diff --git a/src/test/groovy/com/netgrif/application/engine/auth/WorkflowAuthorizationServiceTest.groovy b/src/test/groovy/com/netgrif/application/engine/auth/WorkflowAuthorizationServiceTest.groovy index 08a5a369e82..26eed34d6a9 100644 --- a/src/test/groovy/com/netgrif/application/engine/auth/WorkflowAuthorizationServiceTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/auth/WorkflowAuthorizationServiceTest.groovy @@ -11,6 +11,7 @@ import com.netgrif.application.engine.petrinet.domain.VersionType import com.netgrif.application.engine.petrinet.domain.dataset.Field import com.netgrif.application.engine.petrinet.domain.dataset.UserListField import com.netgrif.application.engine.petrinet.domain.dataset.UserListFieldValue +import com.netgrif.application.engine.petrinet.domain.params.ImportPetriNetParams import com.netgrif.application.engine.petrinet.domain.roles.ProcessRole import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService import com.netgrif.application.engine.startup.ImportHelper @@ -94,11 +95,13 @@ class WorkflowAuthorizationServiceTest { @BeforeEach void init() { testHelper.truncateDbs() - ImportPetriNetEventOutcome net = petriNetService.importPetriNet(new FileInputStream("src/test/resources/workflow_authorization_service_test.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()) + ImportPetriNetEventOutcome net = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/workflow_authorization_service_test.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())) assert net.getNet() != null this.net = net.getNet() - ImportPetriNetEventOutcome netWithUserRefs = petriNetService.importPetriNet(new FileInputStream("src/test/resources/workflow_authorization_service_test_with_userRefs.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()) + ImportPetriNetEventOutcome netWithUserRefs = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/workflow_authorization_service_test_with_userRefs.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())) assert netWithUserRefs.getNet() != null this.netWithUserRefs = netWithUserRefs.getNet() diff --git a/src/test/groovy/com/netgrif/application/engine/elastic/DataSearchRequestTest.groovy b/src/test/groovy/com/netgrif/application/engine/elastic/DataSearchRequestTest.groovy index 35b0292cc49..a7cdfb60af8 100644 --- a/src/test/groovy/com/netgrif/application/engine/elastic/DataSearchRequestTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/elastic/DataSearchRequestTest.groovy @@ -18,6 +18,7 @@ import com.netgrif.application.engine.petrinet.domain.dataset.I18nField import com.netgrif.application.engine.petrinet.domain.dataset.TextField import com.netgrif.application.engine.petrinet.domain.dataset.UserFieldValue import com.netgrif.application.engine.petrinet.domain.dataset.UserListFieldValue +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 @@ -109,7 +110,8 @@ class DataSearchRequestTest { repository.deleteAll() - def net = petriNetService.importPetriNet(new FileInputStream("src/test/resources/all_data.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()) + def net = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/all_data.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())) assert net.getNet() != null def users = userService.findAll(true) @@ -122,7 +124,7 @@ class DataSearchRequestTest { testUser2.processRoles = [] testUser2.authorities = [] - LocalDate date = LocalDate.of(2020, 7, 25); + LocalDate date = LocalDate.of(2020, 7, 25) Case _case = importHelper.createCase("correct", net.getNet()) _case.dataSet.get("number").rawValue = 7.0 as Double _case.dataSet.get("boolean").rawValue = true @@ -141,7 +143,7 @@ class DataSearchRequestTest { (_case.dataSet.get("i18n_divider") as I18nField).rawValue.defaultValue = "Modified i18n divider value" workflowService.save(_case) - Task actionTrigger = taskService.searchOne(QTask.task.caseId.eq(_case.stringId).and(QTask.task.transitionId.eq("2"))); + Task actionTrigger = taskService.searchOne(QTask.task.caseId.eq(_case.stringId).and(QTask.task.transitionId.eq("2"))) assert actionTrigger != null dataService.setData(new SetDataParams(actionTrigger, new DataSet([ "testActionTrigger": new TextField(rawValue: "random value") diff --git a/src/test/groovy/com/netgrif/application/engine/elastic/ElasticSearchTest.groovy b/src/test/groovy/com/netgrif/application/engine/elastic/ElasticSearchTest.groovy index 719f75665cc..f7e42930762 100644 --- a/src/test/groovy/com/netgrif/application/engine/elastic/ElasticSearchTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/elastic/ElasticSearchTest.groovy @@ -1,13 +1,14 @@ package com.netgrif.application.engine.elastic -import com.netgrif.application.engine.TestHelper import com.netgrif.application.engine.ApplicationEngine +import com.netgrif.application.engine.TestHelper import com.netgrif.application.engine.auth.domain.Authority import com.netgrif.application.engine.auth.domain.User import com.netgrif.application.engine.auth.domain.UserState import com.netgrif.application.engine.elastic.domain.ElasticCaseRepository import com.netgrif.application.engine.petrinet.domain.VersionType import com.netgrif.application.engine.petrinet.domain.dataset.EnumerationField +import com.netgrif.application.engine.petrinet.domain.params.ImportPetriNetParams import com.netgrif.application.engine.petrinet.domain.roles.ProcessRole import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService import com.netgrif.application.engine.startup.ImportHelper @@ -17,7 +18,6 @@ import groovy.json.JsonOutput import groovy.json.JsonSlurper import groovy.util.logging.Slf4j import org.junit.jupiter.api.BeforeEach -import org.junit.jupiter.api.Disabled import org.junit.jupiter.api.Test import org.junit.jupiter.api.extension.ExtendWith import org.springframework.beans.factory.annotation.Autowired @@ -102,8 +102,10 @@ class ElasticSearchTest { .apply(springSecurity()) .build() - def net = petriNetService.importPetriNet(new FileInputStream("src/test/resources/all_data.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()).getNet() - def net2 = petriNetService.importPetriNet(new FileInputStream("src/test/resources/all_data.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()).getNet() + def net = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/all_data.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())).getNet() + def net2 = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/all_data.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())).getNet() assert net assert net2 @@ -115,7 +117,7 @@ class ElasticSearchTest { [auths.get("user")] as Authority[], [net.roles.values().find { it.importId == "process_role" }] as ProcessRole[]) auth = new UsernamePasswordAuthenticationToken(USER_EMAIL, USER_PASSW) - auth.setDetails(new WebAuthenticationDetails(new MockHttpServletRequest())); + auth.setDetails(new WebAuthenticationDetails(new MockHttpServletRequest())) CASE_NUMBER.times { def _case = importHelper.createCaseAsSuper("$it" as String, it % 2 == 0 ? net : net2) diff --git a/src/test/groovy/com/netgrif/application/engine/elastic/ElasticTaskTest.groovy b/src/test/groovy/com/netgrif/application/engine/elastic/ElasticTaskTest.groovy index 06ee0a5ec05..808bd708877 100644 --- a/src/test/groovy/com/netgrif/application/engine/elastic/ElasticTaskTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/elastic/ElasticTaskTest.groovy @@ -7,6 +7,7 @@ import com.netgrif.application.engine.elastic.domain.ElasticTaskRepository import com.netgrif.application.engine.elastic.service.ReindexingTask import com.netgrif.application.engine.elastic.service.interfaces.IElasticTaskService import com.netgrif.application.engine.petrinet.domain.VersionType +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 @@ -78,7 +79,8 @@ class ElasticTaskTest { @Test void taskReindexTest() { - def optional = petriNetService.importPetriNet(new FileInputStream("src/test/resources/all_data.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()) + def optional = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/all_data.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())) assert optional.getNet() != null def net = optional.getNet() diff --git a/src/test/groovy/com/netgrif/application/engine/elastic/ReindexTest.groovy b/src/test/groovy/com/netgrif/application/engine/elastic/ReindexTest.groovy index bc9659e9429..6e3ce61a4f0 100644 --- a/src/test/groovy/com/netgrif/application/engine/elastic/ReindexTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/elastic/ReindexTest.groovy @@ -5,6 +5,7 @@ import com.netgrif.application.engine.elastic.service.ReindexingTask import com.netgrif.application.engine.elastic.service.interfaces.IElasticCaseService import com.netgrif.application.engine.elastic.web.requestbodies.CaseSearchRequest import com.netgrif.application.engine.petrinet.domain.VersionType +import com.netgrif.application.engine.petrinet.domain.params.ImportPetriNetParams import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService import com.netgrif.application.engine.startup.SuperCreator import com.netgrif.application.engine.workflow.domain.Case @@ -51,7 +52,8 @@ class ReindexTest { @Test void reindexTest() { - ImportPetriNetEventOutcome net = petriNetService.importPetriNet(new FileInputStream("src/test/resources/all_data.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()) + ImportPetriNetEventOutcome net = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/all_data.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())) assert net.getNet() != null int countTread = Thread.activeCount() List<Thread> threads = [] diff --git a/src/test/groovy/com/netgrif/application/engine/history/HistoryServiceTest.groovy b/src/test/groovy/com/netgrif/application/engine/history/HistoryServiceTest.groovy index 9b2a6a312e7..d69beee2719 100644 --- a/src/test/groovy/com/netgrif/application/engine/history/HistoryServiceTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/history/HistoryServiceTest.groovy @@ -6,6 +6,7 @@ import com.netgrif.application.engine.history.service.IHistoryService import com.netgrif.application.engine.petrinet.domain.PetriNet import com.netgrif.application.engine.petrinet.domain.VersionType import com.netgrif.application.engine.petrinet.domain.dataset.NumberField +import com.netgrif.application.engine.petrinet.domain.params.ImportPetriNetParams import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService import com.netgrif.application.engine.startup.SuperCreator import com.netgrif.application.engine.workflow.domain.Case @@ -59,7 +60,8 @@ class HistoryServiceTest { @BeforeEach void init() { testHelper.truncateDbs() - ImportPetriNetEventOutcome net = petriNetService.importPetriNet(new FileInputStream("src/test/resources/all_data.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()) + ImportPetriNetEventOutcome net = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/all_data.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())) assert net.getNet() != null this.net = net.getNet() diff --git a/src/test/groovy/com/netgrif/application/engine/importer/AllDataTransitionTest.groovy b/src/test/groovy/com/netgrif/application/engine/importer/AllDataTransitionTest.groovy index ffa72a05ddf..63fc0c00b12 100644 --- a/src/test/groovy/com/netgrif/application/engine/importer/AllDataTransitionTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/importer/AllDataTransitionTest.groovy @@ -5,6 +5,7 @@ import com.netgrif.application.engine.importer.service.AllDataConfiguration import com.netgrif.application.engine.petrinet.domain.PetriNet import com.netgrif.application.engine.petrinet.domain.Transition import com.netgrif.application.engine.petrinet.domain.VersionType +import com.netgrif.application.engine.petrinet.domain.params.ImportPetriNetParams import com.netgrif.application.engine.petrinet.domain.throwable.MissingPetriNetMetaDataException import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService import com.netgrif.application.engine.startup.SuperCreator @@ -48,8 +49,9 @@ class AllDataTransitionTest { @Test void testAllData() throws MissingPetriNetMetaDataException, IOException { - ImportPetriNetEventOutcome outcome = petriNetService.importPetriNet(resourceFile.inputStream, VersionType.MAJOR, superCreator.getLoggedSuper()); - assert outcome.getNet() != null; + ImportPetriNetEventOutcome outcome = petriNetService.importPetriNet(new ImportPetriNetParams( + resourceFile.inputStream, VersionType.MAJOR, superCreator.getLoggedSuper())) + assert outcome.getNet() != null PetriNet net = outcome.getNet() assert net.transitions.size() == 3 diff --git a/src/test/groovy/com/netgrif/application/engine/importer/PredefinedRolesPermissionsTest.groovy b/src/test/groovy/com/netgrif/application/engine/importer/PredefinedRolesPermissionsTest.groovy index 0eb67b14216..108ce121a15 100644 --- a/src/test/groovy/com/netgrif/application/engine/importer/PredefinedRolesPermissionsTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/importer/PredefinedRolesPermissionsTest.groovy @@ -5,6 +5,7 @@ import com.netgrif.application.engine.importer.service.AllDataConfiguration import com.netgrif.application.engine.importer.service.RoleFactory import com.netgrif.application.engine.petrinet.domain.PetriNet import com.netgrif.application.engine.petrinet.domain.VersionType +import com.netgrif.application.engine.petrinet.domain.params.ImportPetriNetParams import com.netgrif.application.engine.petrinet.domain.roles.ProcessRolePermission import com.netgrif.application.engine.petrinet.domain.roles.RolePermission import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService @@ -115,7 +116,7 @@ class PredefinedRolesPermissionsTest { private String ANONYMOUS_ROLE_ID @BeforeEach - public void before() { + void before() { testHelper.truncateDbs() assert processRoleService.defaultRole() != null DEFAULT_ROLE_ID = processRoleService.defaultRole().stringId @@ -228,7 +229,7 @@ class PredefinedRolesPermissionsTest { void reservedDefaultRole() { assertThrows(IllegalArgumentException.class, () -> { importAndCreate(reservedDefaultRoleNet) - }); + }) } @Test() @@ -357,7 +358,7 @@ class PredefinedRolesPermissionsTest { void reservedAnonymousRole() { assertThrows(IllegalArgumentException.class, () -> { importAndCreate(reservedAnonymousRoleNet) - }); + }) } @Test() @@ -427,8 +428,8 @@ class PredefinedRolesPermissionsTest { NetCaseTask instances = importAndCreate(model) String netRoleId = instances.net.getRoles().keySet().find({ it -> it != DEFAULT_ROLE_ID && it != ANONYMOUS_ROLE_ID }) - Map<String, Map<ProcessRolePermission, Boolean>> processPerms = transformProcessRolePermissionMap(processPermissions, netRoleId); - Map<String, Map<RolePermission, Boolean>> taskPerms = transformRolePermissionMap(taskPermissions, netRoleId); + Map<String, Map<ProcessRolePermission, Boolean>> processPerms = transformProcessRolePermissionMap(processPermissions, netRoleId) + Map<String, Map<RolePermission, Boolean>> taskPerms = transformRolePermissionMap(taskPermissions, netRoleId) def negativeProcessView = processPerms.findAll { it -> it.value.containsKey(ProcessRolePermission.VIEW) && !it.value.get(ProcessRolePermission.VIEW) }.collect { it -> it.key } def negativeTaskView = taskPerms.findAll { it -> it.value.containsKey(RolePermission.VIEW) && !it.value.get(RolePermission.VIEW) }.collect { it -> it.key } @@ -451,7 +452,8 @@ class PredefinedRolesPermissionsTest { } private NetCaseTask importAndCreate(Resource model) { - ImportPetriNetEventOutcome importOutcome = petriNetService.importPetriNet(model.inputStream, VersionType.MAJOR, superCreator.loggedSuper) + ImportPetriNetEventOutcome importOutcome = petriNetService.importPetriNet(new ImportPetriNetParams( + model.inputStream, VersionType.MAJOR, superCreator.loggedSuper)) assert importOutcome.getNet() != null diff --git a/src/test/groovy/com/netgrif/application/engine/importer/UserListTest.groovy b/src/test/groovy/com/netgrif/application/engine/importer/UserListTest.groovy index c1a4cd7c9ee..9fdfcc9dd1f 100644 --- a/src/test/groovy/com/netgrif/application/engine/importer/UserListTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/importer/UserListTest.groovy @@ -6,6 +6,7 @@ import com.netgrif.application.engine.petrinet.domain.dataset.Field import com.netgrif.application.engine.petrinet.domain.dataset.UserFieldValue import com.netgrif.application.engine.petrinet.domain.dataset.UserListField import com.netgrif.application.engine.petrinet.domain.dataset.UserListFieldValue +import com.netgrif.application.engine.petrinet.domain.params.ImportPetriNetParams import com.netgrif.application.engine.petrinet.domain.throwable.MissingPetriNetMetaDataException import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService import com.netgrif.application.engine.startup.SuperCreator @@ -61,7 +62,8 @@ class UserListTest { @Test void testUserList() throws MissingPetriNetMetaDataException, IOException { - ImportPetriNetEventOutcome net = petriNetService.importPetriNet(new FileInputStream("src/test/resources/user_list.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()) + ImportPetriNetEventOutcome net = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/user_list.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())) assert net.getNet() != null Optional<Case> caseOpt = caseRepository.findOne(QCase.case$.title.eq("User List")) diff --git a/src/test/groovy/com/netgrif/application/engine/insurance/EncryptionTest.groovy b/src/test/groovy/com/netgrif/application/engine/insurance/EncryptionTest.groovy index 2f3ab5f4a38..c416d86a4cc 100644 --- a/src/test/groovy/com/netgrif/application/engine/insurance/EncryptionTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/insurance/EncryptionTest.groovy @@ -6,6 +6,7 @@ import com.netgrif.application.engine.auth.service.interfaces.IAuthorityService import com.netgrif.application.engine.configuration.properties.SuperAdminConfiguration import com.netgrif.application.engine.importer.service.Importer import com.netgrif.application.engine.petrinet.domain.VersionType +import com.netgrif.application.engine.petrinet.domain.params.ImportPetriNetParams import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService import com.netgrif.application.engine.startup.SuperCreator import com.netgrif.application.engine.workflow.domain.Case @@ -33,7 +34,7 @@ class EncryptionTest { private CaseRepository caseRepository @Autowired - private IWorkflowService workflowService; + private IWorkflowService workflowService @Autowired private Importer importer @@ -83,7 +84,8 @@ class EncryptionTest { } private String createCase() { - ImportPetriNetEventOutcome net = petriNetService.importPetriNet(new FileInputStream("src/test/resources/mapping_test.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()) + ImportPetriNetEventOutcome net = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/mapping_test.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())) assert net.getNet() != null CreateCaseParams createCaseParams = CreateCaseParams.builder() .petriNet(net.getNet()) diff --git a/src/test/groovy/com/netgrif/application/engine/insurance/mvc/InsuranceTest.groovy b/src/test/groovy/com/netgrif/application/engine/insurance/mvc/InsuranceTest.groovy index 347192c3f79..480d6630c93 100644 --- a/src/test/groovy/com/netgrif/application/engine/insurance/mvc/InsuranceTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/insurance/mvc/InsuranceTest.groovy @@ -12,6 +12,7 @@ import com.netgrif.application.engine.importer.service.Importer import com.netgrif.application.engine.petrinet.domain.I18nString import com.netgrif.application.engine.petrinet.domain.VersionType import com.netgrif.application.engine.petrinet.domain.dataset.* +import com.netgrif.application.engine.petrinet.domain.params.ImportPetriNetParams import com.netgrif.application.engine.petrinet.domain.roles.ProcessRole import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService import com.netgrif.application.engine.petrinet.service.interfaces.IProcessRoleService @@ -134,7 +135,8 @@ class InsuranceTest { .apply(springSecurity()) .build() - def net = petriNetService.importPetriNet(new FileInputStream("src/test/resources/insurance_portal_demo_test.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()) + def net = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/insurance_portal_demo_test.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())) assert net.getNet() != null netId = net.getNet().getStringId() @@ -148,7 +150,7 @@ class InsuranceTest { processRoleService.assignRolesToUser(userService.findByEmail(USER_EMAIL, false).stringId, roles.findAll { it.importId in ["1", "2"] }.collect { it.stringId } as Set, userService.getLoggedOrSystem().transformToLoggedUser()) auth = new UsernamePasswordAuthenticationToken(USER_EMAIL, "password") - auth.setDetails(new WebAuthenticationDetails(new MockHttpServletRequest())); + auth.setDetails(new WebAuthenticationDetails(new MockHttpServletRequest())) objectWriter = objectMapper.writer().withDefaultPrettyPrinter() } diff --git a/src/test/groovy/com/netgrif/application/engine/ipc/AssignCancelFinishWithCaseTest.groovy b/src/test/groovy/com/netgrif/application/engine/ipc/AssignCancelFinishWithCaseTest.groovy index 00152437996..81753892e46 100644 --- a/src/test/groovy/com/netgrif/application/engine/ipc/AssignCancelFinishWithCaseTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/ipc/AssignCancelFinishWithCaseTest.groovy @@ -3,6 +3,7 @@ package com.netgrif.application.engine.ipc import com.netgrif.application.engine.TestHelper import com.netgrif.application.engine.importer.service.Importer import com.netgrif.application.engine.petrinet.domain.VersionType +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 @@ -34,10 +35,10 @@ class AssignCancelFinishWithCaseTest { private TestHelper testHelper @Autowired - private IPetriNetService petriNetService; + private IPetriNetService petriNetService @Autowired - private SuperCreator superCreator; + private SuperCreator superCreator private boolean initialised = false @@ -57,7 +58,8 @@ class AssignCancelFinishWithCaseTest { @Test void testAssignCancelFinish() { - def testNet = petriNetService.importPetriNet(stream(ASSIGN_CANCEL_FINISH_NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper()) + def testNet = petriNetService.importPetriNet(new ImportPetriNetParams( + stream(ASSIGN_CANCEL_FINISH_NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper())) assert testNet.getNet() != null diff --git a/src/test/groovy/com/netgrif/application/engine/ipc/CaseApiTest.groovy b/src/test/groovy/com/netgrif/application/engine/ipc/CaseApiTest.groovy index 34fe9810b7a..91e47527a19 100644 --- a/src/test/groovy/com/netgrif/application/engine/ipc/CaseApiTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/ipc/CaseApiTest.groovy @@ -3,6 +3,7 @@ package com.netgrif.application.engine.ipc import com.netgrif.application.engine.TestHelper import com.netgrif.application.engine.importer.service.Importer import com.netgrif.application.engine.petrinet.domain.VersionType +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 @@ -55,7 +56,8 @@ class CaseApiTest { @Test void testCreate() { - testNet = petriNetService.importPetriNet(stream(CREATE_NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper()) + testNet = petriNetService.importPetriNet(new ImportPetriNetParams( + stream(CREATE_NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper())) assert testNet.getNet() != null @@ -72,7 +74,8 @@ class CaseApiTest { void testSearch() { testHelper.truncateDbs() - testNet = petriNetService.importPetriNet(stream(SEARCH_NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper()) + testNet = petriNetService.importPetriNet(new ImportPetriNetParams( + stream(SEARCH_NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper())) assert testNet.getNet() != null diff --git a/src/test/groovy/com/netgrif/application/engine/ipc/TaskApiTest.groovy b/src/test/groovy/com/netgrif/application/engine/ipc/TaskApiTest.groovy index f2714cc937f..69b4c0255c9 100644 --- a/src/test/groovy/com/netgrif/application/engine/ipc/TaskApiTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/ipc/TaskApiTest.groovy @@ -10,6 +10,7 @@ import com.netgrif.application.engine.petrinet.domain.VersionType import com.netgrif.application.engine.petrinet.domain.dataset.Field import com.netgrif.application.engine.petrinet.domain.dataset.NumberField import com.netgrif.application.engine.petrinet.domain.dataset.TextField +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 @@ -57,7 +58,7 @@ class TaskApiTest { private TestHelper testHelper @Autowired - private SuperCreator superCreator; + private SuperCreator superCreator private def stream = { String name -> return TaskApiTest.getClassLoader().getResourceAsStream(name) @@ -77,7 +78,8 @@ class TaskApiTest { @Test @Disabled("GroovyRuntime Could not find matching constructor") void testTaskSearch() { - def netOptional = petriNetService.importPetriNet(stream(TASK_SEARCH_NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper()) + def netOptional = petriNetService.importPetriNet(new ImportPetriNetParams( + stream(TASK_SEARCH_NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper())) assert netOptional.getNet() != null @@ -108,7 +110,8 @@ class TaskApiTest { @Test @Disabled() void testTaskEventActions() { - def netOptional = petriNetService.importPetriNet(stream(TASK_EVENTS_NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper()) + def netOptional = petriNetService.importPetriNet(new ImportPetriNetParams( + stream(TASK_EVENTS_NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper())) assert netOptional.getNet() != null @@ -141,8 +144,10 @@ class TaskApiTest { @Test @Disabled("spusta 2 krat") void testTaskExecution() { - def limitsNetOptional = petriNetService.importPetriNet(stream(LIMITS_NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper()) - def leasingNetOptional = petriNetService.importPetriNet(stream(LEASING_NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper()) + def limitsNetOptional = petriNetService.importPetriNet(new ImportPetriNetParams( + stream(LIMITS_NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper())) + def leasingNetOptional = petriNetService.importPetriNet(new ImportPetriNetParams( + stream(LEASING_NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper())) assert limitsNetOptional.getNet() != null assert leasingNetOptional.getNet() != null @@ -216,7 +221,8 @@ class TaskApiTest { @Test void testTaskBulkActions() { - def netOptional = petriNetService.importPetriNet(stream(TASK_BULK_NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper()) + def netOptional = petriNetService.importPetriNet(new ImportPetriNetParams( + stream(TASK_BULK_NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper())) assert netOptional.getNet() != null PetriNet net = netOptional.getNet() @@ -241,7 +247,8 @@ class TaskApiTest { @Test void testGetData() { - def netOptional = petriNetService.importPetriNet(stream(TASK_GETTER_NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper()) + def netOptional = petriNetService.importPetriNet(new ImportPetriNetParams( + stream(TASK_GETTER_NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper())) assert netOptional.getNet() != null PetriNet net = netOptional.getNet() @@ -270,7 +277,8 @@ class TaskApiTest { @Test void testSetData() { - def netOptional = petriNetService.importPetriNet(stream(TASK_SETTER_NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper()) + def netOptional = petriNetService.importPetriNet(new ImportPetriNetParams( + stream(TASK_SETTER_NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper())) assert netOptional.getNet() != null PetriNet net = netOptional.getNet() diff --git a/src/test/groovy/com/netgrif/application/engine/permissions/ElasticSearchViewPermissionTest.groovy b/src/test/groovy/com/netgrif/application/engine/permissions/ElasticSearchViewPermissionTest.groovy index 941fc740126..b214b8dba52 100644 --- a/src/test/groovy/com/netgrif/application/engine/permissions/ElasticSearchViewPermissionTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/permissions/ElasticSearchViewPermissionTest.groovy @@ -15,6 +15,7 @@ import com.netgrif.application.engine.petrinet.domain.VersionType import com.netgrif.application.engine.petrinet.domain.dataset.Field import com.netgrif.application.engine.petrinet.domain.dataset.UserListField import com.netgrif.application.engine.petrinet.domain.dataset.UserListFieldValue +import com.netgrif.application.engine.petrinet.domain.params.ImportPetriNetParams import com.netgrif.application.engine.petrinet.domain.roles.ProcessRole import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService import com.netgrif.application.engine.startup.ImportHelper @@ -87,11 +88,13 @@ class ElasticSearchViewPermissionTest { @BeforeEach void inti() { testHelper.truncateDbs() - ImportPetriNetEventOutcome net = petriNetService.importPetriNet(new FileInputStream("src/test/resources/view_permission_test.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()) + ImportPetriNetEventOutcome net = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/view_permission_test.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())) assert net.getNet() != null this.net = net.getNet() - ImportPetriNetEventOutcome netWithUserRefs = petriNetService.importPetriNet(new FileInputStream("src/test/resources/view_permission_with_userRefs_test.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()) + ImportPetriNetEventOutcome netWithUserRefs = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/view_permission_with_userRefs_test.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())) assert netWithUserRefs.getNet() != null this.netWithUserRefs = netWithUserRefs.getNet() diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/ActionRefTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/ActionRefTest.groovy index 274811c005e..6f87a264dcd 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/ActionRefTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/ActionRefTest.groovy @@ -2,6 +2,7 @@ package com.netgrif.application.engine.petrinet.domain import com.netgrif.application.engine.TestHelper import com.netgrif.application.engine.auth.domain.repositories.UserRepository +import com.netgrif.application.engine.petrinet.domain.params.ImportPetriNetParams import com.netgrif.application.engine.petrinet.domain.repositories.PetriNetRepository import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService import com.netgrif.application.engine.startup.SuperCreator @@ -40,7 +41,7 @@ class ActionRefTest { private SuperCreator superCreator @Autowired - private IPetriNetService petriNetService; + private IPetriNetService petriNetService @Autowired private UserRepository userRepository @@ -57,7 +58,8 @@ class ActionRefTest { @Disabled("TODO: deprecated action ref") void testEventImport() { - PetriNet net = petriNetService.importPetriNet(new FileInputStream(NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper()).getNet() + PetriNet net = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream(NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper())).getNet() assert net.dataSet.get("text_1").events.size() == 8 assert net.transitions.get("task").dataSet.get("text_1").events.size() == 8 diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/ArcOrderTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/ArcOrderTest.groovy index 87eabc8fb30..dcdc8db3806 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/ArcOrderTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/ArcOrderTest.groovy @@ -4,6 +4,7 @@ import com.netgrif.application.engine.TestHelper import com.netgrif.application.engine.importer.service.Importer import com.netgrif.application.engine.petrinet.domain.arcs.ArcOrderComparator import com.netgrif.application.engine.petrinet.domain.arcs.ResetArc +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 @@ -30,7 +31,7 @@ class ArcOrderTest { private ImportHelper helper @Autowired - private IPetriNetService petriNetService; + private IPetriNetService petriNetService @Autowired private SuperCreator superCreator @@ -50,7 +51,8 @@ class ArcOrderTest { @Test void testOrder() { - def net = petriNetService.importPetriNet(stream(NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper()).getNet() + def net = petriNetService.importPetriNet(new ImportPetriNetParams( + stream(NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper())).getNet() def arcs = net.getArcsOfTransition(NET_TASK) def sorted = arcs.sort { a1, a2 -> ArcOrderComparator.getInstance().compare(a1, a2) } diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/ArcReferenceTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/ArcReferenceTest.groovy index 039547d2014..ea9f7423c90 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/ArcReferenceTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/ArcReferenceTest.groovy @@ -49,6 +49,6 @@ class ArcReferenceTest { void testInvalidReference() { assertThrows(IllegalArgumentException.class, () -> { importer.importPetriNet(stream(NET_INVALID_FILE)).get() - }); + }) } } \ No newline at end of file diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/EventTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/EventTest.groovy index f11a1de7217..436cfdcde8e 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/EventTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/EventTest.groovy @@ -4,6 +4,7 @@ import com.netgrif.application.engine.TestHelper import com.netgrif.application.engine.auth.domain.repositories.UserRepository import com.netgrif.application.engine.importer.service.Importer import com.netgrif.application.engine.ipc.TaskApiTest +import com.netgrif.application.engine.petrinet.domain.params.ImportPetriNetParams import com.netgrif.application.engine.petrinet.domain.repositories.PetriNetRepository import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService import com.netgrif.application.engine.startup.DefaultRoleRunner @@ -86,7 +87,8 @@ class EventTest { void testEventImport() { testHelper.truncateDbs() - PetriNet net = petriNetService.importPetriNet(stream(EVENT_NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper()).getNet() + PetriNet net = petriNetService.importPetriNet(new ImportPetriNetParams( + stream(EVENT_NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper())).getNet() instance = helper.createCase(EVENT_NET_CASE, net) outcome = helper.assignTaskToSuper(EVENT_NET_TASK, instance.stringId) diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/FunctionsTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/FunctionsTest.groovy index 9fb1dd457f4..bea0d8baae0 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/FunctionsTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/FunctionsTest.groovy @@ -4,6 +4,7 @@ import com.netgrif.application.engine.TestHelper import com.netgrif.application.engine.auth.domain.IUser import com.netgrif.application.engine.auth.service.interfaces.IUserService import com.netgrif.application.engine.petrinet.domain.dataset.* +import com.netgrif.application.engine.petrinet.domain.params.ImportPetriNetParams import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService import com.netgrif.application.engine.startup.SuperCreator import com.netgrif.application.engine.workflow.domain.Case @@ -91,8 +92,10 @@ class FunctionsTest { void testNamespaceFunction() { assert userService.findByEmail("test@test.com", true) == null - def functionResNet = petriNetService.importPetriNet(functionResNetResource.inputStream, VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser()).getNet() - def functionTestNet = petriNetService.importPetriNet(functionTestNetResource.inputStream, VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser()).getNet() + def functionResNet = petriNetService.importPetriNet(new ImportPetriNetParams( + functionResNetResource.inputStream, VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser())).getNet() + def functionTestNet = petriNetService.importPetriNet(new ImportPetriNetParams( + functionTestNetResource.inputStream, VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser())).getNet() assert functionResNet assert functionTestNet @@ -117,8 +120,10 @@ class FunctionsTest { @Test void testProcessFunctions() { - def functionResNet = petriNetService.importPetriNet(functionResNetResource.inputStream, VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser()).getNet() - def functionTestNet = petriNetService.importPetriNet(functionTestNetResource.inputStream, VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser()).getNet() + def functionResNet = petriNetService.importPetriNet(new ImportPetriNetParams( + functionResNetResource.inputStream, VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser())).getNet() + def functionTestNet = petriNetService.importPetriNet(new ImportPetriNetParams( + functionTestNetResource.inputStream, VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser())).getNet() assert functionResNet assert functionTestNet @@ -145,7 +150,8 @@ class FunctionsTest { @Test void testNamespaceFunctionException() { assertThrows(NullPointerException.class, () -> { - def functionResNet = petriNetService.importPetriNet(functionResNetResource.inputStream, VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser()).getNet() + def functionResNet = petriNetService.importPetriNet(new ImportPetriNetParams( + functionResNetResource.inputStream, VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser())).getNet() assert functionResNet def nets = petriNetService.getByIdentifier(FUNCTION_RES_IDENTIFIER) @@ -155,7 +161,8 @@ class FunctionsTest { } } - def functionTestNet = petriNetService.importPetriNet(functionTestNetResource.inputStream, VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser()).getNet() + def functionTestNet = petriNetService.importPetriNet(new ImportPetriNetParams( + functionTestNetResource.inputStream, VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser())).getNet() assert functionTestNet CreateCaseParams createCaseParams = CreateCaseParams.builder() @@ -180,7 +187,8 @@ class FunctionsTest { } } - def functionTestNet = petriNetService.importPetriNet(functionTestNetResource.inputStream, VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser()).getNet() + def functionTestNet = petriNetService.importPetriNet(new ImportPetriNetParams( + functionTestNetResource.inputStream, VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser())).getNet() assert functionTestNet CreateCaseParams createCaseParams = CreateCaseParams.builder() @@ -193,7 +201,8 @@ class FunctionsTest { dataService.setData(new SetDataParams(aCase.getTaskStringId("1"), new DataSet((["text": new TextField(rawValue: "20")] as Map<String, Field<?>>)), superCreator.getSuperUser())) - functionTestNet = petriNetService.importPetriNet(functionTestNetResourceV2.inputStream, VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser()).getNet() + functionTestNet = petriNetService.importPetriNet(new ImportPetriNetParams( + functionTestNetResourceV2.inputStream, VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser())).getNet() assert functionTestNet dataService.setData(new SetDataParams(aCase.getTaskStringId("1"), @@ -204,7 +213,8 @@ class FunctionsTest { @Test void testProcessFunctionException() { assertThrows(MissingMethodException.class, () -> { - def functionTestNet = petriNetService.importPetriNet(functionTestNetResource.inputStream, VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser()).getNet() + def functionTestNet = petriNetService.importPetriNet(new ImportPetriNetParams( + functionTestNetResource.inputStream, VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser())).getNet() assert functionTestNet CreateCaseParams createCaseParams = CreateCaseParams.builder() @@ -221,8 +231,10 @@ class FunctionsTest { @Test void testNewVersionOfNamespaceFunction() { - def functionResNet = petriNetService.importPetriNet(functionResNetResource.inputStream, VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser()).getNet() - def functionTestNet = petriNetService.importPetriNet(functionTestNetResource.inputStream, VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser()).getNet() + def functionResNet = petriNetService.importPetriNet(new ImportPetriNetParams( + functionResNetResource.inputStream, VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser())).getNet() + def functionTestNet = petriNetService.importPetriNet(new ImportPetriNetParams( + functionTestNetResource.inputStream, VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser())).getNet() assert functionResNet assert functionTestNet @@ -240,7 +252,8 @@ class FunctionsTest { assert aCase.getDataSet().get("number2").rawValue == 20 + 20 - functionResNet = petriNetService.importPetriNet(functionResNetResourceV2.inputStream, VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser()).getNet() + functionResNet = petriNetService.importPetriNet(new ImportPetriNetParams( + functionResNetResourceV2.inputStream, VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser())).getNet() assert functionResNet dataService.setData(new SetDataParams(aCase.getTaskStringId("1"), @@ -253,14 +266,17 @@ class FunctionsTest { @Test void testNamespaceMethodOverloadingFail() { assertThrows(IllegalArgumentException.class, () -> { - petriNetService.importPetriNet(functionOverloadingFailNetResource.inputStream, VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser()) + petriNetService.importPetriNet(new ImportPetriNetParams( + functionOverloadingFailNetResource.inputStream, VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser())) }) } @Test void testNamespaceUseCaseUpdate() { - def functionResV2Net = petriNetService.importPetriNet(functionResNetResourceV2.inputStream, VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser()).getNet() - def functionTestV2Net = petriNetService.importPetriNet(functionTestNetResourceV2.inputStream, VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser()).getNet() + def functionResV2Net = petriNetService.importPetriNet(new ImportPetriNetParams( + functionResNetResourceV2.inputStream, VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser())).getNet() + def functionTestV2Net = petriNetService.importPetriNet(new ImportPetriNetParams( + functionTestNetResourceV2.inputStream, VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser())).getNet() CreateCaseParams createCaseParams = CreateCaseParams.builder() .petriNet(functionTestV2Net) @@ -285,7 +301,8 @@ class FunctionsTest { @Test void testProcessMethodOverloadingFail() { assertThrows(IllegalArgumentException.class, () -> { - petriNetService.importPetriNet(functionOverloadingFailNetResourceV2.inputStream, VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser()) + petriNetService.importPetriNet(new ImportPetriNetParams( + functionOverloadingFailNetResourceV2.inputStream, VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser())) }) } @@ -295,7 +312,8 @@ class FunctionsTest { } private void testMethodOverloading(Resource resource) { - def petriNet = petriNetService.importPetriNet(resource.inputStream, VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser()).getNet() + def petriNet = petriNetService.importPetriNet(new ImportPetriNetParams( + resource.inputStream, VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser())).getNet() assert petriNet CreateCaseParams createCaseParams = CreateCaseParams.builder() diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/ImporterTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/ImporterTest.groovy index 5673b6bc5af..aa5441a8338 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/ImporterTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/ImporterTest.groovy @@ -5,6 +5,7 @@ import com.netgrif.application.engine.importer.service.Importer import com.netgrif.application.engine.petrinet.domain.dataset.ChoiceField import com.netgrif.application.engine.petrinet.domain.dataset.MultichoiceField import com.netgrif.application.engine.petrinet.domain.dataset.logic.FieldBehavior +import com.netgrif.application.engine.petrinet.domain.params.ImportPetriNetParams import com.netgrif.application.engine.petrinet.domain.roles.ProcessRoleRepository import com.netgrif.application.engine.petrinet.domain.throwable.MissingPetriNetMetaDataException import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService @@ -87,11 +88,11 @@ class ImporterTest { @Test void importTest() { long beforeImportNet = processRoleRepository.count() - def netOptional = petriNetService.importPetriNet( + def netOptional = petriNetService.importPetriNet(new ImportPetriNetParams( firstVersionResource.inputStream, VersionType.MAJOR, superCreator.loggedSuper - ) + )) assert netOptional.getNet() != null assert processRoleRepository.count() == beforeImportNet + 2 long statusImportRole = processRoleRepository.count() @@ -173,11 +174,11 @@ class ImporterTest { } assert net.places.size() == 0 - def netOptional2 = petriNetService.importPetriNet( + def netOptional2 = petriNetService.importPetriNet(new ImportPetriNetParams( secondVersionResource.inputStream, VersionType.MAJOR, superCreator.loggedSuper - ) + )) assert processRoleRepository.count() == statusImportRole + 1 assert netOptional2.getNet() != null @@ -291,7 +292,8 @@ class ImporterTest { @Test void thisKeywordInDataEventsTest() { - PetriNet net = petriNetService.importPetriNet(new ClassPathResource("/this_kw_test.xml").getInputStream(), VersionType.MAJOR, superCreator.getLoggedSuper()).getNet() + PetriNet net = petriNetService.importPetriNet(new ImportPetriNetParams( + new ClassPathResource("/this_kw_test.xml").getInputStream(), VersionType.MAJOR, superCreator.getLoggedSuper())).getNet() assert net != null CreateCaseParams createCaseParams = CreateCaseParams.builder() @@ -309,7 +311,8 @@ class ImporterTest { @Test void initialBehaviorTest() { - PetriNet net = petriNetService.importPetriNet(new ClassPathResource("/initial_behavior.xml").getInputStream(), VersionType.MAJOR, superCreator.getLoggedSuper()).getNet() + PetriNet net = petriNetService.importPetriNet(new ImportPetriNetParams( + new ClassPathResource("/initial_behavior.xml").getInputStream(), VersionType.MAJOR, superCreator.getLoggedSuper())).getNet() assert net CreateCaseParams createCaseParams = CreateCaseParams.builder() @@ -345,7 +348,8 @@ class ImporterTest { @Test void enumerationMultichoiceOptionsTest() throws IOException, MissingPetriNetMetaDataException { - PetriNet net = petriNetService.importPetriNet(new ClassPathResource("/enumeration_multichoice_options.xml").getInputStream(), VersionType.MAJOR, superCreator.getLoggedSuper()).getNet() + PetriNet net = petriNetService.importPetriNet(new ImportPetriNetParams( + new ClassPathResource("/enumeration_multichoice_options.xml").getInputStream(), VersionType.MAJOR, superCreator.getLoggedSuper())).getNet() assert net != null @@ -366,10 +370,10 @@ class ImporterTest { @Test void testDataGroupImportWithoutId() { - def netOutcome = petriNetService.importPetriNet( + def netOutcome = petriNetService.importPetriNet(new ImportPetriNetParams( new FileInputStream("src/test/resources/datagroup_no_id_test.xml"), VersionType.MAJOR, - superCreator.loggedSuper) + superCreator.loggedSuper)) assert netOutcome.getNet() != null @@ -381,7 +385,8 @@ class ImporterTest { @Test void createTransitionNoLabel() { - PetriNet net = petriNetService.importPetriNet(new FileInputStream("src/test/resources/importTest/NoLabel.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()).getNet() + PetriNet net = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/importTest/NoLabel.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())).getNet() assert net PetriNet importNet = petriNetService.findByImportId(net.getImportId()).get() assert importNet @@ -390,7 +395,7 @@ class ImporterTest { assert importNet.getTransition("layout").getTitle().defaultValue == "" } - private boolean equalSet(Set<I18nString> first, Set<I18nString> second) { + private static boolean equalSet(Set<I18nString> first, Set<I18nString> second) { return first.every { second.any { that -> it.defaultValue == that.defaultValue } } diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/PetriNetTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/PetriNetTest.groovy index 7ffc62b6f05..359f96b5fe0 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/PetriNetTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/PetriNetTest.groovy @@ -6,6 +6,7 @@ import com.netgrif.application.engine.petrinet.domain.arcs.Arc import com.netgrif.application.engine.petrinet.domain.arcs.InhibitorArc import com.netgrif.application.engine.petrinet.domain.arcs.ReadArc import com.netgrif.application.engine.petrinet.domain.arcs.ResetArc +import com.netgrif.application.engine.petrinet.domain.params.ImportPetriNetParams import com.netgrif.application.engine.petrinet.domain.roles.ProcessRoleRepository import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService import com.netgrif.application.engine.petrinet.web.responsebodies.PetriNetReference @@ -55,9 +56,10 @@ class PetriNetTest { @Test void testClone() { - int beforeImportNet = processRoleRepository.count() + long beforeImportNet = processRoleRepository.count() - def netOptional = petriNetService.importPetriNet(netResource.inputStream, VersionType.MAJOR, superCreator.loggedSuper) + def netOptional = petriNetService.importPetriNet(new ImportPetriNetParams( + netResource.inputStream, VersionType.MAJOR, superCreator.loggedSuper)) assert netOptional.getNet() != null @@ -78,15 +80,18 @@ class PetriNetTest { @Test void testVersioning() { - def outcome1 = petriNetService.importPetriNet(netResource.inputStream, VersionType.MAJOR, superCreator.loggedSuper) + def outcome1 = petriNetService.importPetriNet(new ImportPetriNetParams( + netResource.inputStream, VersionType.MAJOR, superCreator.loggedSuper)) PetriNet net1 = outcome1.getNet() assert net1 - def outcome2 = petriNetService.importPetriNet(netResource.inputStream, VersionType.MAJOR, superCreator.loggedSuper) + def outcome2 = petriNetService.importPetriNet(new ImportPetriNetParams( + netResource.inputStream, VersionType.MAJOR, superCreator.loggedSuper)) PetriNet net2 = outcome2.getNet() assert net2 - def outcome3 = petriNetService.importPetriNet(netResource2.inputStream, VersionType.MAJOR, superCreator.loggedSuper) + def outcome3 = petriNetService.importPetriNet(new ImportPetriNetParams( + netResource2.inputStream, VersionType.MAJOR, superCreator.loggedSuper)) PetriNet net3 = outcome3.getNet() assert net3 diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/CaseFieldTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/CaseFieldTest.groovy index fa117c8474d..494056599c8 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/CaseFieldTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/CaseFieldTest.groovy @@ -3,6 +3,7 @@ package com.netgrif.application.engine.petrinet.domain.dataset import com.netgrif.application.engine.TestHelper import com.netgrif.application.engine.ipc.TaskApiTest import com.netgrif.application.engine.petrinet.domain.VersionType +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 @@ -63,7 +64,8 @@ class CaseFieldTest { @Test void testAllowedNets() { - def testNet = petriNetService.importPetriNet(stream(ALLOWED_NETS_NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper()) + def testNet = petriNetService.importPetriNet(new ImportPetriNetParams( + stream(ALLOWED_NETS_NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper())) assert testNet.getNet() != null Case aCase = importHelper.createCase("Case 1", testNet.getNet()) @@ -113,7 +115,8 @@ class CaseFieldTest { @Test void testImmediateAllowedNets() { - def testNet = petriNetService.importPetriNet(stream(ALLOWED_NETS_NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper()) + def testNet = petriNetService.importPetriNet(new ImportPetriNetParams( + stream(ALLOWED_NETS_NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper())) assert testNet.getNet() != null Case aCase = importHelper.createCase("Case 1", testNet.getNet()) @@ -160,10 +163,12 @@ class CaseFieldTest { @Test @Disabled("Please fix this test") void testChangeValueAction() { - def notAllowedNet = petriNetService.importPetriNet(stream(ALLOWED_NETS_NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper()) + def notAllowedNet = petriNetService.importPetriNet(new ImportPetriNetParams( + stream(ALLOWED_NETS_NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper())) assert notAllowedNet.getNet() != null - def testNet = petriNetService.importPetriNet(stream(CHANGE_VALUE_NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper()) + def testNet = petriNetService.importPetriNet(new ImportPetriNetParams( + stream(CHANGE_VALUE_NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper())) assert testNet.getNet() != null Case aCase = importHelper.createCase("Case 1", testNet.getNet()) diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/ChangeBehaviorTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/ChangeBehaviorTest.groovy index 4c1f9dce296..fe416f79505 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/ChangeBehaviorTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/ChangeBehaviorTest.groovy @@ -5,7 +5,7 @@ import com.netgrif.application.engine.TestHelper import com.netgrif.application.engine.auth.service.interfaces.IUserService import com.netgrif.application.engine.petrinet.domain.PetriNet import com.netgrif.application.engine.petrinet.domain.VersionType -import com.netgrif.application.engine.petrinet.domain.dataset.logic.FieldBehavior +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 @@ -77,7 +77,8 @@ class ChangeBehaviorTest { @BeforeEach void initNet() { testHelper.truncateDbs() - net = petriNetService.importPetriNet(new FileInputStream(RESOURCE_PATH), VersionType.MAJOR, userService.loggedOrSystem.transformToLoggedUser()).getNet() + net = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream(RESOURCE_PATH), VersionType.MAJOR, userService.loggedOrSystem.transformToLoggedUser())).getNet() assert net != null } diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/ChangeCasePropertyTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/ChangeCasePropertyTest.groovy index 8c1eb5b302f..46cff4f2743 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/ChangeCasePropertyTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/ChangeCasePropertyTest.groovy @@ -4,6 +4,7 @@ import com.netgrif.application.engine.TestHelper import com.netgrif.application.engine.auth.service.interfaces.IUserService import com.netgrif.application.engine.petrinet.domain.PetriNet import com.netgrif.application.engine.petrinet.domain.VersionType +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 @@ -63,7 +64,8 @@ class ChangeCasePropertyTest { @BeforeEach void initNet() { testHelper.truncateDbs() - net = petriNetService.importPetriNet(new FileInputStream(RESOURCE_PATH), VersionType.MAJOR, userService.loggedOrSystem.transformToLoggedUser()).getNet() + net = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream(RESOURCE_PATH), VersionType.MAJOR, userService.loggedOrSystem.transformToLoggedUser())).getNet() assert net != null } diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/ChangeFieldValueInitTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/ChangeFieldValueInitTest.groovy index b0649a38dac..10f5efc0544 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/ChangeFieldValueInitTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/ChangeFieldValueInitTest.groovy @@ -2,6 +2,7 @@ package com.netgrif.application.engine.petrinet.domain.dataset import com.netgrif.application.engine.TestHelper import com.netgrif.application.engine.petrinet.domain.VersionType +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 @@ -50,7 +51,8 @@ class ChangeFieldValueInitTest { @Test void testInitValues() { - ImportPetriNetEventOutcome optNet = petriNetService.importPetriNet(new FileInputStream("src/test/resources/petriNets/change_field_value_init.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()) + ImportPetriNetEventOutcome optNet = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/petriNets/change_field_value_init.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())) Case useCase = importHelper.createCase("test", optNet.getNet()) assert useCase.dataSet.get("text_static").rawValue == "TEST VALUE" diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/ChoiceFieldTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/ChoiceFieldTest.groovy index 1027972f9f7..352ecba1667 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/ChoiceFieldTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/ChoiceFieldTest.groovy @@ -6,6 +6,7 @@ import com.netgrif.application.engine.ipc.TaskApiTest import com.netgrif.application.engine.petrinet.domain.DataRef import com.netgrif.application.engine.petrinet.domain.I18nString import com.netgrif.application.engine.petrinet.domain.VersionType +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 @@ -41,10 +42,10 @@ class ChoiceFieldTest { private TestHelper testHelper @Autowired - private IPetriNetService petriNetService; + private IPetriNetService petriNetService @Autowired - private SuperCreator superCreator; + private SuperCreator superCreator private Closure<InputStream> stream = { String name -> return TaskApiTest.getClassLoader().getResourceAsStream(name) @@ -57,7 +58,8 @@ class ChoiceFieldTest { @Test void testChoices() { - def netOptional = petriNetService.importPetriNet(stream(LIMITS_NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper()) + def netOptional = petriNetService.importPetriNet(new ImportPetriNetParams( + stream(LIMITS_NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper())) assert netOptional.getNet() != null def net = netOptional.getNet() diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicCaseNameTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicCaseNameTest.groovy index 08f0a1dfce5..335441548d7 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicCaseNameTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicCaseNameTest.groovy @@ -2,6 +2,7 @@ package com.netgrif.application.engine.petrinet.domain.dataset import com.netgrif.application.engine.TestHelper import com.netgrif.application.engine.petrinet.domain.VersionType +import com.netgrif.application.engine.petrinet.domain.params.ImportPetriNetParams import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService import com.netgrif.application.engine.startup.SuperCreator import com.netgrif.application.engine.workflow.domain.Case @@ -40,7 +41,8 @@ class DynamicCaseNameTest { @Test void testInitValues() { - ImportPetriNetEventOutcome optNet = petriNetService.importPetriNet(new FileInputStream("src/test/resources/petriNets/dynamic_case_name_test.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()) + ImportPetriNetEventOutcome optNet = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/petriNets/dynamic_case_name_test.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())) CreateCaseParams createCaseParams = CreateCaseParams.builder() .petriNet(optNet.getNet()) .title(null) diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicChoicesTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicChoicesTest.groovy index cf831cef8ae..841b55a9e4e 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicChoicesTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicChoicesTest.groovy @@ -2,6 +2,7 @@ package com.netgrif.application.engine.petrinet.domain.dataset import com.netgrif.application.engine.TestHelper import com.netgrif.application.engine.petrinet.domain.VersionType +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 @@ -23,36 +24,37 @@ import org.springframework.test.context.junit.jupiter.SpringExtension class DynamicChoicesTest { @Autowired - private TestHelper testHelper; + private TestHelper testHelper @Autowired private ImportHelper importHelper @Autowired - private IPetriNetService petriNetService; + private IPetriNetService petriNetService @Autowired - private SuperCreator superCreator; + private SuperCreator superCreator @Autowired - private IDataService dataService; + private IDataService dataService @Autowired - private ITaskService taskService; + private ITaskService taskService @Autowired - private CaseRepository caseRepository; + private CaseRepository caseRepository @BeforeEach void before() { - testHelper.truncateDbs(); + testHelper.truncateDbs() } @Test void testDynamicEnum() { - ImportPetriNetEventOutcome optNet = petriNetService.importPetriNet(new FileInputStream("src/test/resources/petriNets/dynamic_choices.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()); + ImportPetriNetEventOutcome optNet = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/petriNets/dynamic_choices.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())) - assert optNet.getNet() != null; + assert optNet.getNet() != null def net = optNet.getNet() def aCase = importHelper.createCase("Case", net) diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicDefaultValueTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicDefaultValueTest.groovy index b3ee44fe972..998d0cdeaac 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicDefaultValueTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicDefaultValueTest.groovy @@ -2,6 +2,7 @@ package com.netgrif.application.engine.petrinet.domain.dataset import com.netgrif.application.engine.TestHelper import com.netgrif.application.engine.petrinet.domain.VersionType +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 @@ -41,7 +42,8 @@ class DynamicDefaultValueTest { @Test void testInitValues() { - ImportPetriNetEventOutcome optNet = petriNetService.importPetriNet(new FileInputStream("src/test/resources/petriNets/dynamic_init.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()); + ImportPetriNetEventOutcome optNet = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/petriNets/dynamic_init.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())) Case useCase = importHelper.createCase("test", optNet.getNet()) assert useCase.dataSet.get("text").rawValue == superCreator.superUser.name diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicEnumerationTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicEnumerationTest.groovy index c5a5ed909e7..9fa665c65b1 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicEnumerationTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicEnumerationTest.groovy @@ -3,6 +3,7 @@ package com.netgrif.application.engine.petrinet.domain.dataset import com.netgrif.application.engine.TestHelper import com.netgrif.application.engine.petrinet.domain.I18nString import com.netgrif.application.engine.petrinet.domain.VersionType +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 @@ -59,7 +60,8 @@ class DynamicEnumerationTest { @Test void testDynamicEnum() { - ImportPetriNetEventOutcome optNet = petriNetService.importPetriNet(new FileInputStream("src/test/resources/test_autocomplete_dynamic.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()) + ImportPetriNetEventOutcome optNet = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/test_autocomplete_dynamic.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())) assert optNet.getNet() != null def net = optNet.getNet() diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicValidationPerformanceTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicValidationPerformanceTest.groovy index 22dbb821f51..40729a6fe1f 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicValidationPerformanceTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicValidationPerformanceTest.groovy @@ -2,6 +2,7 @@ package com.netgrif.application.engine.petrinet.domain.dataset import com.netgrif.application.engine.TestHelper import com.netgrif.application.engine.petrinet.domain.VersionType +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 @@ -62,8 +63,10 @@ class DynamicValidationPerformanceTest { @Test void testValidations() { // TODO: release/8.0.0 Object f.text_valid_switch does not exists - ImportPetriNetEventOutcome optNet1 = petriNetService.importPetriNet(new FileInputStream("src/test/resources/petriNets/dynamic_validations_performance_test.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()) - ImportPetriNetEventOutcome optNet2 = petriNetService.importPetriNet(new FileInputStream("src/test/resources/petriNets/dynamic_validations_performance_test_comparison.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()) + ImportPetriNetEventOutcome optNet1 = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/petriNets/dynamic_validations_performance_test.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())) + ImportPetriNetEventOutcome optNet2 = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/petriNets/dynamic_validations_performance_test_comparison.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())) def aCase1 = importHelper.createCase("Case 1", optNet1.getNet()) def aCase2 = importHelper.createCase("Case 2", optNet2.getNet()) diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicValidationTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicValidationTest.groovy index 570b1afa2aa..6fc924a7313 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicValidationTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicValidationTest.groovy @@ -42,7 +42,7 @@ class DynamicValidationTest { @BeforeEach void before() { - testHelper.truncateDbs(); + testHelper.truncateDbs() } // @Test diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/FileFieldTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/FileFieldTest.groovy index 81be879cb33..dfdf90579bd 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/FileFieldTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/FileFieldTest.groovy @@ -8,6 +8,7 @@ import com.netgrif.application.engine.configuration.properties.SuperAdminConfigu import com.netgrif.application.engine.importer.service.Importer import com.netgrif.application.engine.petrinet.domain.PetriNet import com.netgrif.application.engine.petrinet.domain.VersionType +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 @@ -69,10 +70,10 @@ class FileFieldTest { private WebApplicationContext context @Autowired - private IPetriNetService petriNetService; + private IPetriNetService petriNetService @Autowired - private SuperCreator superCreator; + private SuperCreator superCreator private MockMvc mockMvc @@ -86,7 +87,8 @@ class FileFieldTest { } PetriNet getNet() { - def netOptional = petriNetService.importPetriNet(new FileInputStream("src/test/resources/remoteFileField.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()); + def netOptional = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/remoteFileField.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())) assert netOptional.getNet() != null return netOptional.getNet() } diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/FileListFieldTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/FileListFieldTest.groovy index cef902ce08c..e3174cff097 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/FileListFieldTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/FileListFieldTest.groovy @@ -8,6 +8,7 @@ import com.netgrif.application.engine.configuration.properties.SuperAdminConfigu import com.netgrif.application.engine.importer.service.Importer import com.netgrif.application.engine.petrinet.domain.PetriNet import com.netgrif.application.engine.petrinet.domain.VersionType +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 @@ -86,7 +87,8 @@ class FileListFieldTest { } PetriNet getNet() { - def netOptional = petriNetService.importPetriNet(new FileInputStream("src/test/resources/remoteFileListField.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()) + def netOptional = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/remoteFileListField.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())) assert netOptional.getNet() != null return netOptional.getNet() } diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/MapFieldTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/MapFieldTest.groovy index bd060368d2d..c698164e59a 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/MapFieldTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/MapFieldTest.groovy @@ -2,6 +2,7 @@ package com.netgrif.application.engine.petrinet.domain.dataset import com.netgrif.application.engine.TestHelper import com.netgrif.application.engine.petrinet.domain.VersionType +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 @@ -45,7 +46,8 @@ class MapFieldTest { @Test void testImport() { - def netOptional = petriNetService.importPetriNet(netResource.inputStream, VersionType.MAJOR, superCreator.loggedSuper) + def netOptional = petriNetService.importPetriNet(new ImportPetriNetParams( + netResource.inputStream, VersionType.MAJOR, superCreator.loggedSuper)) assert netOptional.getNet() != null def net = netOptional.getNet() @@ -69,7 +71,8 @@ class MapFieldTest { @Test void testValue() { - def netOptional = petriNetService.importPetriNet(netResource.inputStream, VersionType.MAJOR, superCreator.loggedSuper) + def netOptional = petriNetService.importPetriNet(new ImportPetriNetParams( + netResource.inputStream, VersionType.MAJOR, superCreator.loggedSuper)) assert netOptional.getNet() != null Case aCase = importHelper.createCase("Case", netOptional.getNet()) @@ -106,7 +109,8 @@ class MapFieldTest { @Test void testImportMultichoice() { - def netOptional = petriNetService.importPetriNet(netResource2.inputStream, VersionType.MAJOR, superCreator.loggedSuper) + def netOptional = petriNetService.importPetriNet(new ImportPetriNetParams( + netResource2.inputStream, VersionType.MAJOR, superCreator.loggedSuper)) assert netOptional.getNet() != null def net = netOptional.getNet() @@ -130,7 +134,8 @@ class MapFieldTest { @Test void testValueMultichoice() { - def netOptional = petriNetService.importPetriNet(netResource2.inputStream, VersionType.MAJOR, superCreator.loggedSuper) + def netOptional = petriNetService.importPetriNet(new ImportPetriNetParams( + netResource2.inputStream, VersionType.MAJOR, superCreator.loggedSuper)) assert netOptional.getNet() != null Case aCase = importHelper.createCase("Case", netOptional.getNet()) diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/roles/ProcessRoleTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/roles/ProcessRoleTest.groovy index c7aea8a9d98..a667fc8e383 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/roles/ProcessRoleTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/roles/ProcessRoleTest.groovy @@ -6,6 +6,7 @@ import com.netgrif.application.engine.auth.domain.User import com.netgrif.application.engine.auth.domain.UserState import com.netgrif.application.engine.importer.service.Importer import com.netgrif.application.engine.petrinet.domain.VersionType +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 @@ -66,13 +67,13 @@ class ProcessRoleTest { private ImportHelper importHelper @Autowired - private IPetriNetService petriNetService; + private IPetriNetService petriNetService @Autowired private ProcessRoleRepository userProcessRoleRepository @Autowired - private SuperCreator superCreator; + private SuperCreator superCreator @Autowired TestHelper testHelper @@ -86,7 +87,8 @@ class ProcessRoleTest { .apply(springSecurity()) .build() - def net = petriNetService.importPetriNet(new FileInputStream("src/test/resources/rolref_view.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()) + def net = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/rolref_view.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())) assert net.getNet() != null String netId = net.getNet().getStringId() diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/service/CachePetriNetServiceTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/service/CachePetriNetServiceTest.groovy index 92390b6e583..c68b9d600ac 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/service/CachePetriNetServiceTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/service/CachePetriNetServiceTest.groovy @@ -9,6 +9,7 @@ import com.netgrif.application.engine.configuration.properties.CacheProperties import com.netgrif.application.engine.ipc.TaskApiTest import com.netgrif.application.engine.petrinet.domain.PetriNet import com.netgrif.application.engine.petrinet.domain.VersionType +import com.netgrif.application.engine.petrinet.domain.params.ImportPetriNetParams import com.netgrif.application.engine.petrinet.domain.roles.ProcessRole import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService import com.netgrif.application.engine.startup.ImportHelper @@ -50,7 +51,7 @@ class CachePetriNetServiceTest { private CacheManager cacheManager @Autowired - private CacheProperties cacheProperties; + private CacheProperties cacheProperties private def stream = { String name -> return TaskApiTest.getClassLoader().getResourceAsStream(name) @@ -68,7 +69,8 @@ class CachePetriNetServiceTest { @Test void cacheTest() { assert cacheManager.getCache(cacheProperties.getPetriNetNewest()).get("processDeleteTest") == null - ImportPetriNetEventOutcome testNetOptional = petriNetService.importPetriNet(stream(NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper()) + ImportPetriNetEventOutcome testNetOptional = petriNetService.importPetriNet(new ImportPetriNetParams( + stream(NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper())) assert testNetOptional.getNet() != null PetriNet testNet = testNetOptional.getNet() diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/service/PetriNetServiceTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/service/PetriNetServiceTest.groovy index 3d97a0f31ab..08331661f66 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/service/PetriNetServiceTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/service/PetriNetServiceTest.groovy @@ -10,6 +10,7 @@ import com.netgrif.application.engine.elastic.domain.ElasticPetriNet import com.netgrif.application.engine.elastic.domain.ElasticPetriNetRepository import com.netgrif.application.engine.ipc.TaskApiTest import com.netgrif.application.engine.petrinet.domain.* +import com.netgrif.application.engine.petrinet.domain.params.ImportPetriNetParams import com.netgrif.application.engine.petrinet.domain.repositories.PetriNetRepository import com.netgrif.application.engine.petrinet.domain.roles.ProcessRole import com.netgrif.application.engine.petrinet.domain.roles.ProcessRoleRepository @@ -101,7 +102,8 @@ class PetriNetServiceTest { long processCount = petriNetRepository.count() long taskCount = taskRepository.count() - ImportPetriNetEventOutcome testNetOptional = petriNetService.importPetriNet(stream(NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper()) + ImportPetriNetEventOutcome testNetOptional = petriNetService.importPetriNet(new ImportPetriNetParams( + stream(NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper())) assert testNetOptional.getNet() != null assert petriNetRepository.count() == processCount + 1 PetriNet testNet = testNetOptional.getNet() @@ -150,8 +152,10 @@ class PetriNetServiceTest { @Test void findAllByUriNodeIdTest() { UriNode myNode = uriService.getOrCreate("/test", UriContentType.DEFAULT) - petriNetService.importPetriNet(stream(NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper(), myNode.id.toString()) - petriNetService.importPetriNet(stream(NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper(), myNode.id.toString()) + petriNetService.importPetriNet(new ImportPetriNetParams( + stream(NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper(), myNode.id.toString())) + petriNetService.importPetriNet(new ImportPetriNetParams( + stream(NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper(), myNode.id.toString())) Thread.sleep(2000) @@ -165,8 +169,10 @@ class PetriNetServiceTest { def user = userService.findByEmail(CUSTOMER_USER_MAIL, false) assert user != null - petriNetService.importPetriNet(stream(NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper()) - petriNetService.importPetriNet(stream(NET_SEARCH_FILE), VersionType.MAJOR, user.transformToLoggedUser()) + petriNetService.importPetriNet(new ImportPetriNetParams( + stream(NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper())) + petriNetService.importPetriNet(new ImportPetriNetParams( + stream(NET_SEARCH_FILE), VersionType.MAJOR, user.transformToLoggedUser())) assert petriNetRepository.count() == processCount + 2 diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/web/PetriNetControllerTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/web/PetriNetControllerTest.groovy index 177252290f8..7d4a5abe3a8 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/web/PetriNetControllerTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/web/PetriNetControllerTest.groovy @@ -7,6 +7,7 @@ import com.netgrif.application.engine.auth.domain.UserState import com.netgrif.application.engine.ipc.TaskApiTest import com.netgrif.application.engine.petrinet.domain.PetriNet import com.netgrif.application.engine.petrinet.domain.VersionType +import com.netgrif.application.engine.petrinet.domain.params.ImportPetriNetParams import com.netgrif.application.engine.petrinet.domain.roles.ProcessRole import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService import com.netgrif.application.engine.startup.ImportHelper @@ -76,7 +77,8 @@ class PetriNetControllerTest { void before() { testHelper.truncateDbs() - def net = petriNetService.importPetriNet(stream(NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper()) + def net = petriNetService.importPetriNet(new ImportPetriNetParams( + stream(NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper())) assert net.getNet() != null this.net = net.getNet() diff --git a/src/test/groovy/com/netgrif/application/engine/transaction/TransactionTest.groovy b/src/test/groovy/com/netgrif/application/engine/transaction/TransactionTest.groovy index ca90d351dcc..936d00c1e4b 100644 --- a/src/test/groovy/com/netgrif/application/engine/transaction/TransactionTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/transaction/TransactionTest.groovy @@ -10,6 +10,7 @@ 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.domain.throwable.MissingPetriNetMetaDataException import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService import com.netgrif.application.engine.startup.ImportHelper @@ -75,8 +76,9 @@ class TransactionTest { @BeforeEach void before() throws IOException, MissingPetriNetMetaDataException { testHelper.truncateDbs() - testNet = petriNetService.importPetriNet(new FileInputStream("src/test/resources/petriNets/transaction/transaction_test.xml"), - VersionType.MAJOR, superCreator.getLoggedSuper()).getNet() + testNet = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/petriNets/transaction/transaction_test.xml"), + VersionType.MAJOR, superCreator.getLoggedSuper())).getNet() } @Test diff --git a/src/test/groovy/com/netgrif/application/engine/workflow/DataServiceTest.groovy b/src/test/groovy/com/netgrif/application/engine/workflow/DataServiceTest.groovy index 7f13557a817..824ed895160 100644 --- a/src/test/groovy/com/netgrif/application/engine/workflow/DataServiceTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/workflow/DataServiceTest.groovy @@ -6,6 +6,7 @@ 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.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 @@ -29,9 +30,9 @@ import org.springframework.test.context.junit.jupiter.SpringExtension @CompileStatic class DataServiceTest { - private static final String TASK_TITLE = "Transition"; - private static final String FILE_FIELD_TITLE = "File"; - private static final String TEXT_FIELD_TITLE = "Result"; + private static final String TASK_TITLE = "Transition" + private static final String FILE_FIELD_TITLE = "File" + private static final String TEXT_FIELD_TITLE = "Result" @Autowired private ImportHelper importHelper @@ -58,20 +59,24 @@ class DataServiceTest { @BeforeEach void beforeAll() { testHelper.truncateDbs() - ImportPetriNetEventOutcome net = petriNetService.importPetriNet(new FileInputStream("src/test/resources/data_service_referenced.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()) + ImportPetriNetEventOutcome net = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/data_service_referenced.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())) assert net.getNet() != null - net = petriNetService.importPetriNet(new FileInputStream("src/test/resources/data_service_taskref.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()) + net = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/data_service_taskref.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())) assert net.getNet() != null this.net = net.getNet() - ImportPetriNetEventOutcome agreementNet = petriNetService.importPetriNet(new FileInputStream("src/test/resources/agreement.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()) + ImportPetriNetEventOutcome agreementNet = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/agreement.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())) assert agreementNet.getNet() != null this.agreementNet = agreementNet.getNet() - ImportPetriNetEventOutcome netoutcome = petriNetService.importPetriNet(new FileInputStream("src/test/resources/test_setData.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()); - assert netoutcome.getNet() != null; - this.setDataNet = netoutcome.getNet(); + ImportPetriNetEventOutcome netoutcome = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/test_setData.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())) + assert netoutcome.getNet() != null + this.setDataNet = netoutcome.getNet() } @Test diff --git a/src/test/groovy/com/netgrif/application/engine/workflow/NewInitTest.groovy b/src/test/groovy/com/netgrif/application/engine/workflow/NewInitTest.groovy index b8373f69627..6537499e521 100644 --- a/src/test/groovy/com/netgrif/application/engine/workflow/NewInitTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/workflow/NewInitTest.groovy @@ -6,6 +6,7 @@ import com.netgrif.application.engine.petrinet.domain.I18nString import com.netgrif.application.engine.petrinet.domain.VersionType import com.netgrif.application.engine.petrinet.domain.dataset.FileFieldValue import com.netgrif.application.engine.petrinet.domain.dataset.FileListFieldValue +import com.netgrif.application.engine.petrinet.domain.params.ImportPetriNetParams import com.netgrif.application.engine.petrinet.domain.throwable.MissingPetriNetMetaDataException import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService import com.netgrif.application.engine.startup.SuperCreator @@ -46,7 +47,8 @@ class NewInitTest { @Test void newInitTest() throws IOException, MissingIconKeyException, MissingPetriNetMetaDataException { - petriNetService.importPetriNet(new FileInputStream("src/test/resources/petriNets/nae_1276_Init_value_as_choice.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()) + petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/petriNets/nae_1276_Init_value_as_choice.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())) CreateCaseParams createCaseParams = CreateCaseParams.builder() .petriNet(petriNetService.getNewestVersionByIdentifier("new_init_test")) .title("New init test") diff --git a/src/test/groovy/com/netgrif/application/engine/workflow/SetDataOnButtonTest.groovy b/src/test/groovy/com/netgrif/application/engine/workflow/SetDataOnButtonTest.groovy index 9f4b00fae0d..321171a3588 100644 --- a/src/test/groovy/com/netgrif/application/engine/workflow/SetDataOnButtonTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/workflow/SetDataOnButtonTest.groovy @@ -7,6 +7,7 @@ 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.dataset.TextField +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 @@ -78,7 +79,8 @@ class SetDataOnButtonTest { @BeforeEach void initNet() { testHelper.truncateDbs() - net = petriNetService.importPetriNet(new FileInputStream(RESOURCE_PATH), VersionType.MAJOR, userService.loggedOrSystem.transformToLoggedUser()).getNet() + net = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream(RESOURCE_PATH), VersionType.MAJOR, userService.loggedOrSystem.transformToLoggedUser())).getNet() assert net != null } diff --git a/src/test/groovy/com/netgrif/application/engine/workflow/TaskRefInitTest.groovy b/src/test/groovy/com/netgrif/application/engine/workflow/TaskRefInitTest.groovy index 3ee198fa4ff..3ec4eebe892 100644 --- a/src/test/groovy/com/netgrif/application/engine/workflow/TaskRefInitTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/workflow/TaskRefInitTest.groovy @@ -5,6 +5,7 @@ import com.netgrif.application.engine.auth.service.interfaces.IUserService import com.netgrif.application.engine.petrinet.domain.PetriNet import com.netgrif.application.engine.petrinet.domain.VersionType import com.netgrif.application.engine.petrinet.domain.dataset.TaskField +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.workflow.domain.Case @@ -47,8 +48,10 @@ class TaskRefInitTest { @BeforeEach void initNet() { testHelper.truncateDbs() - net = petriNetService.importPetriNet(new FileInputStream("src/test/resources/taskref_init.xml"), VersionType.MAJOR, userService.loggedOrSystem.transformToLoggedUser()).getNet() - autoTrigger = petriNetService.importPetriNet(new FileInputStream("src/test/resources/autotrigger_taskref.xml"), VersionType.MAJOR, userService.loggedOrSystem.transformToLoggedUser()).getNet() + net = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/taskref_init.xml"), VersionType.MAJOR, userService.loggedOrSystem.transformToLoggedUser())).getNet() + autoTrigger = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/autotrigger_taskref.xml"), VersionType.MAJOR, userService.loggedOrSystem.transformToLoggedUser())).getNet() assert net != null } diff --git a/src/test/groovy/com/netgrif/application/engine/workflow/TaskRefPropagationTest.groovy b/src/test/groovy/com/netgrif/application/engine/workflow/TaskRefPropagationTest.groovy index f1f817e4cb7..bfcd7126e70 100644 --- a/src/test/groovy/com/netgrif/application/engine/workflow/TaskRefPropagationTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/workflow/TaskRefPropagationTest.groovy @@ -3,6 +3,7 @@ package com.netgrif.application.engine.workflow import com.netgrif.application.engine.petrinet.domain.DataGroup import com.netgrif.application.engine.petrinet.domain.PetriNet import com.netgrif.application.engine.petrinet.domain.VersionType +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 @@ -48,8 +49,10 @@ class TaskRefPropagationTest { @BeforeEach void beforeAll() { - def parent = petriNetService.importPetriNet(new FileInputStream("src/test/resources/taskRef_propagation_test_parent.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()) - def child = petriNetService.importPetriNet(new FileInputStream("src/test/resources/taskRef_propagation_test_child.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()) + def parent = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/taskRef_propagation_test_parent.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())) + def child = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/taskRef_propagation_test_child.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())) assert parent.getNet() != null assert child.getNet() != null diff --git a/src/test/groovy/com/netgrif/application/engine/workflow/UserRefsTest.groovy b/src/test/groovy/com/netgrif/application/engine/workflow/UserRefsTest.groovy index d5996e75fec..fa6fbc8f7dd 100644 --- a/src/test/groovy/com/netgrif/application/engine/workflow/UserRefsTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/workflow/UserRefsTest.groovy @@ -8,6 +8,7 @@ import com.netgrif.application.engine.petrinet.domain.VersionType import com.netgrif.application.engine.petrinet.domain.dataset.Field import com.netgrif.application.engine.petrinet.domain.dataset.UserListField import com.netgrif.application.engine.petrinet.domain.dataset.UserListFieldValue +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 @@ -69,7 +70,8 @@ class UserRefsTest { @BeforeEach void before() { helper.truncateDbs() - def net = petriNetService.importPetriNet(new FileInputStream("src/test/resources/userrefs_test.xml"), VersionType.MAJOR, userService.loggedOrSystem.transformToLoggedUser()).getNet() + def net = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/userrefs_test.xml"), VersionType.MAJOR, userService.loggedOrSystem.transformToLoggedUser())).getNet() assert net netId = net.getStringId() def userEmails = [configuration.email, "engine@netgrif.com"] diff --git a/src/test/groovy/com/netgrif/application/engine/workflow/WorkflowServiceTest.groovy b/src/test/groovy/com/netgrif/application/engine/workflow/WorkflowServiceTest.groovy index af14dfe6494..df9664ed83d 100644 --- a/src/test/groovy/com/netgrif/application/engine/workflow/WorkflowServiceTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/workflow/WorkflowServiceTest.groovy @@ -3,6 +3,7 @@ package com.netgrif.application.engine.workflow import com.netgrif.application.engine.TestHelper import com.netgrif.application.engine.ipc.TaskApiTest import com.netgrif.application.engine.petrinet.domain.VersionType +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 @@ -62,8 +63,10 @@ class WorkflowServiceTest { @Disabled // todo remove void testblabla() { - def testNetWithTriggers = petriNetService.importPetriNet(stream("petriNets/test_with_triggers.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()).getNet() - def testNet = petriNetService.importPetriNet(stream("petriNets/test_without_triggers.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()).getNet() + def testNetWithTriggers = petriNetService.importPetriNet(new ImportPetriNetParams( + stream("petriNets/test_with_triggers.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())).getNet() + def testNet = petriNetService.importPetriNet(new ImportPetriNetParams( + stream("petriNets/test_without_triggers.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())).getNet() int iterations = 200 def paramsWithoutTrigger = builder() @@ -99,7 +102,8 @@ class WorkflowServiceTest { @Test void testFindOneImmediateData() { - def testNet = petriNetService.importPetriNet(stream(NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper()) + def testNet = petriNetService.importPetriNet(new ImportPetriNetParams( + stream(NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper())) assert testNet.getNet() != null Case aCase = importHelper.createCase("Case 1", testNet.getNet()) @@ -113,7 +117,8 @@ class WorkflowServiceTest { @Test void testFirstTransitionAuto() { - def testNet = petriNetService.importPetriNet(stream(FIRST_AUTO_NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper()).getNet() + def testNet = petriNetService.importPetriNet(new ImportPetriNetParams( + stream(FIRST_AUTO_NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper())).getNet() assert testNet def net = testNet @@ -133,7 +138,8 @@ class WorkflowServiceTest { @Test void testSecondTransitionAuto() { - def net = petriNetService.importPetriNet(stream(SECOND_AUTO_NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper()).getNet() + def net = petriNetService.importPetriNet(new ImportPetriNetParams( + stream(SECOND_AUTO_NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper())).getNet() CreateCaseParams createCaseParams = builder() .petriNet(net) @@ -154,7 +160,8 @@ class WorkflowServiceTest { @Test void createCaseWithLocale() { - def testNet = petriNetService.importPetriNet(stream(CASE_LOCALE_NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper()) + def testNet = petriNetService.importPetriNet(new ImportPetriNetParams( + stream(CASE_LOCALE_NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper())) assert testNet.getNet() != null def net = testNet.getNet() diff --git a/src/test/java/com/netgrif/application/engine/configuration/authentication/providers/NetgrifLdapAuthenticationProviderTest.java b/src/test/java/com/netgrif/application/engine/configuration/authentication/providers/NetgrifLdapAuthenticationProviderTest.java index 787dd73c93c..36bd7b84f89 100644 --- a/src/test/java/com/netgrif/application/engine/configuration/authentication/providers/NetgrifLdapAuthenticationProviderTest.java +++ b/src/test/java/com/netgrif/application/engine/configuration/authentication/providers/NetgrifLdapAuthenticationProviderTest.java @@ -12,6 +12,7 @@ import com.netgrif.application.engine.orgstructure.web.responsebodies.LdapGroupResponseBody; import com.netgrif.application.engine.petrinet.domain.PetriNet; import com.netgrif.application.engine.petrinet.domain.VersionType; +import com.netgrif.application.engine.petrinet.domain.params.ImportPetriNetParams; import com.netgrif.application.engine.petrinet.domain.roles.ProcessRole; import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService; import com.netgrif.application.engine.startup.SuperCreator; @@ -174,12 +175,14 @@ void searchGroups() { assert ldapGroupsTest.size() == 1; List<LdapGroupRef> ldapGroupsNothing = ldapGroupRefService.searchGroups("nothing"); - assert ldapGroupsNothing.size() == 0; + assert ldapGroupsNothing.isEmpty(); } @Test void assignRoleGroup() throws Exception { - PetriNet net = petriNetService.importPetriNet(new FileInputStream("src/test/resources/role_all_data.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()).getNet(); + PetriNet net = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/role_all_data.xml"), VersionType.MAJOR, superCreator.getLoggedSuper() + )).getNet(); assert net != null; Map<String, ProcessRole> roles = net.getRoles(); assert roles != null; @@ -187,9 +190,7 @@ void assignRoleGroup() throws Exception { List<LdapGroupRef> ldapGroupsTest = ldapGroupRefService.searchGroups("test1"); assert ldapGroupsTest.size() == 1; Set<String> role = new HashSet<>(); - roles.forEach((k, v) -> { - role.add(v.getStringId()); - }); + roles.forEach((k, v) -> role.add(v.getStringId())); assert role.size() == roles.size(); ldapGroupRefService.setRoleToLdapGroup(ldapGroupsTest.get(0).getDn().toString(), role, superCreator.getLoggedSuper()); Set<String> group = new HashSet<>(); @@ -214,7 +215,9 @@ void assignRoleGroupAndCheck() throws Exception { JSONArray countProcessRole = (JSONArray) json.get("processRoles"); assert countProcessRole.length() == 1; - PetriNet net = petriNetService.importPetriNet(new FileInputStream("src/test/resources/role_all_data.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()).getNet(); + PetriNet net = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/role_all_data.xml"), VersionType.MAJOR, superCreator.getLoggedSuper() + )).getNet(); assert net != null; Map<String, ProcessRole> roles = net.getRoles(); assert roles != null; @@ -222,9 +225,7 @@ void assignRoleGroupAndCheck() throws Exception { List<LdapGroupRef> ldapGroupsTest = ldapGroupRefService.searchGroups("test1"); assert ldapGroupsTest.size() == 1; Set<String> role = new HashSet<>(); - roles.forEach((k, v) -> { - role.add(v.getStringId()); - }); + roles.forEach((k, v) -> role.add(v.getStringId())); assert role.size() == roles.size(); ldapGroupRefService.setRoleToLdapGroup(ldapGroupsTest.get(0).getDn().toString(), role, superCreator.getLoggedSuper()); @@ -268,7 +269,7 @@ void assignRoleGroupAndCheck() throws Exception { void getProcessRole() { Set<String> findDn = Set.of("nothing"); Set<ProcessRole> processRoles = ldapGroupRefService.getProcessRoleByLdapGroup(findDn); - assert processRoles.size() == 0; + assert processRoles.isEmpty(); } @Test diff --git a/src/test/java/com/netgrif/application/engine/importer/ConstructorAndDestructorTest.java b/src/test/java/com/netgrif/application/engine/importer/ConstructorAndDestructorTest.java index a5fbc7b5c4c..f66f9c1a35e 100644 --- a/src/test/java/com/netgrif/application/engine/importer/ConstructorAndDestructorTest.java +++ b/src/test/java/com/netgrif/application/engine/importer/ConstructorAndDestructorTest.java @@ -3,6 +3,7 @@ import com.netgrif.application.engine.TestHelper; import com.netgrif.application.engine.importer.service.throwable.MissingIconKeyException; import com.netgrif.application.engine.petrinet.domain.VersionType; +import com.netgrif.application.engine.petrinet.domain.params.ImportPetriNetParams; import com.netgrif.application.engine.petrinet.domain.throwable.MissingPetriNetMetaDataException; import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService; import com.netgrif.application.engine.startup.SuperCreator; @@ -46,7 +47,9 @@ public void before() { @Test public void testConstructorAndDestructor() throws MissingPetriNetMetaDataException, IOException, MissingIconKeyException { - ImportPetriNetEventOutcome outcome = petriNetService.importPetriNet(new FileInputStream("src/test/resources/constructor_destructor.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()); + ImportPetriNetEventOutcome outcome = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/constructor_destructor.xml"), VersionType.MAJOR, superCreator.getLoggedSuper() + )); assert outcome.getNet() != null; Optional<Case> caseOpt = caseRepository.findOne(QCase.case$.title.eq("Construct")); diff --git a/src/test/java/com/netgrif/application/engine/importer/ImporterTest.java b/src/test/java/com/netgrif/application/engine/importer/ImporterTest.java index 460a5078149..3342630702a 100644 --- a/src/test/java/com/netgrif/application/engine/importer/ImporterTest.java +++ b/src/test/java/com/netgrif/application/engine/importer/ImporterTest.java @@ -6,6 +6,7 @@ import com.netgrif.application.engine.importer.service.throwable.MissingIconKeyException; import com.netgrif.application.engine.petrinet.domain.PetriNet; import com.netgrif.application.engine.petrinet.domain.VersionType; +import com.netgrif.application.engine.petrinet.domain.params.ImportPetriNetParams; import com.netgrif.application.engine.petrinet.domain.repositories.PetriNetRepository; import com.netgrif.application.engine.petrinet.domain.throwable.MissingPetriNetMetaDataException; import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService; @@ -65,13 +66,15 @@ public void before() { @Test public void importPetriNet() throws MissingPetriNetMetaDataException, IOException, MissingIconKeyException { - petriNetService.importPetriNet(new FileInputStream("src/test/resources/prikladFM_test.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()); + petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/prikladFM_test.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())); assertNetProperlyImported(); } @Test public void priorityTest() throws MissingPetriNetMetaDataException, IOException, MissingIconKeyException { - ImportPetriNetEventOutcome outcome = petriNetService.importPetriNet(new FileInputStream("src/test/resources/priority_test.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()); + ImportPetriNetEventOutcome outcome = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/priority_test.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())); assert outcome.getNet() != null; CreateCaseParams createCaseParams = CreateCaseParams.builder() @@ -87,19 +90,22 @@ public void priorityTest() throws MissingPetriNetMetaDataException, IOException, @Test public void dataGroupTest() throws MissingPetriNetMetaDataException, IOException, MissingIconKeyException { - ImportPetriNetEventOutcome outcome = petriNetService.importPetriNet(new FileInputStream("src/test/resources/datagroup_test.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()); + ImportPetriNetEventOutcome outcome = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/datagroup_test.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())); assert outcome.getNet() != null; } @Test public void readArcImportTest() throws MissingPetriNetMetaDataException, IOException, MissingIconKeyException { - petriNetService.importPetriNet(new FileInputStream("src/test/resources/read_test.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()); + petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/read_test.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())); } @Test public void externalMappingTest() throws MissingPetriNetMetaDataException, IOException, MissingIconKeyException { - ImportPetriNetEventOutcome outcome = petriNetService.importPetriNet(new FileInputStream("src/test/resources/mapping_test.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()); + ImportPetriNetEventOutcome outcome = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/mapping_test.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())); assertExternalMappingImport(outcome.getNet()); } @@ -111,7 +117,7 @@ void importInvalidDataRefLayoutTest() throws FileNotFoundException { FileInputStream fileInputStream = new FileInputStream("src/test/resources/invalid_data_ref_layout.xml"); - assertThatThrownBy(() -> petriNetService.importPetriNet(fileInputStream, VersionType.MAJOR, loggedUser)) + assertThatThrownBy(() -> petriNetService.importPetriNet(new ImportPetriNetParams(fileInputStream, VersionType.MAJOR, loggedUser))) .isInstanceOf(IllegalArgumentException.class) .hasMessageContaining("doesn't have a layout"); } diff --git a/src/test/java/com/netgrif/application/engine/petrinet/service/ProcessRoleServiceTest.java b/src/test/java/com/netgrif/application/engine/petrinet/service/ProcessRoleServiceTest.java index 89e2b0ca93e..828609c4811 100644 --- a/src/test/java/com/netgrif/application/engine/petrinet/service/ProcessRoleServiceTest.java +++ b/src/test/java/com/netgrif/application/engine/petrinet/service/ProcessRoleServiceTest.java @@ -2,6 +2,7 @@ import com.netgrif.application.engine.TestHelper; import com.netgrif.application.engine.petrinet.domain.VersionType; +import com.netgrif.application.engine.petrinet.domain.params.ImportPetriNetParams; import com.netgrif.application.engine.petrinet.domain.roles.ProcessRole; import com.netgrif.application.engine.petrinet.domain.throwable.MissingPetriNetMetaDataException; import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService; @@ -54,8 +55,10 @@ public void before() { void shouldFindAllProcessRoles() throws IOException, MissingPetriNetMetaDataException { List<ProcessRole> roles = processRoleService.findAll(); int originalRoles = roles.size(); - petriNetService.importPetriNet(new FileInputStream("src/test/resources/all_data.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()); - petriNetService.importPetriNet(new FileInputStream("src/test/resources/role_all_data.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()); + petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/all_data.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())); + petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/role_all_data.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())); roles = processRoleService.findAll(); assertNotNull(roles); assertFalse(roles.isEmpty()); @@ -64,7 +67,8 @@ void shouldFindAllProcessRoles() throws IOException, MissingPetriNetMetaDataExce @Test void shouldFindAllProcessRolesByPetriNet() throws IOException, MissingPetriNetMetaDataException { - ImportPetriNetEventOutcome eventOutcome = petriNetService.importPetriNet(new FileInputStream("src/test/resources/all_data.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()); + ImportPetriNetEventOutcome eventOutcome = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/all_data.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())); List<ProcessRole> roles = processRoleService.findAll(eventOutcome.getNet().getStringId()); assertNotNull(roles); assertFalse(roles.isEmpty()); @@ -91,7 +95,8 @@ void shouldGetAnonymousRole() { @Test void shouldFindAllProcessRolesByImportId() throws IOException, MissingPetriNetMetaDataException { - petriNetService.importPetriNet(new FileInputStream("src/test/resources/all_data.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()); + petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/all_data.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())); Set<ProcessRole> roles = processRoleService.findAllByImportId(ROLE_IMPORT_ID); assertNotNull(roles); assertFalse(roles.isEmpty()); @@ -101,7 +106,8 @@ void shouldFindAllProcessRolesByImportId() throws IOException, MissingPetriNetMe @Test void shouldFindAllProcessRolesByName() throws IOException, MissingPetriNetMetaDataException { - petriNetService.importPetriNet(new FileInputStream("src/test/resources/all_data.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()); + petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/all_data.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())); Set<ProcessRole> roles = processRoleService.findAllByDefaultName("Process role"); assertNotNull(roles); assertFalse(roles.isEmpty()); diff --git a/src/test/java/com/netgrif/application/engine/rules/service/RuleEngineTest.java b/src/test/java/com/netgrif/application/engine/rules/service/RuleEngineTest.java index 91593fa1f9b..dc06a2375b1 100644 --- a/src/test/java/com/netgrif/application/engine/rules/service/RuleEngineTest.java +++ b/src/test/java/com/netgrif/application/engine/rules/service/RuleEngineTest.java @@ -7,6 +7,7 @@ import com.netgrif.application.engine.configuration.drools.RefreshableKieBase; import com.netgrif.application.engine.importer.service.throwable.MissingIconKeyException; import com.netgrif.application.engine.petrinet.domain.VersionType; +import com.netgrif.application.engine.petrinet.domain.params.ImportPetriNetParams; import com.netgrif.application.engine.petrinet.domain.throwable.MissingPetriNetMetaDataException; import com.netgrif.application.engine.petrinet.domain.throwable.TransitionNotExecutableException; import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService; @@ -100,7 +101,8 @@ void testNetImportRulePRE() throws IOException, MissingPetriNetMetaDataException .build(); ruleRepository.save(rule); - ImportPetriNetEventOutcome outcome = petriNetService.importPetriNet(new FileInputStream("src/test/resources/rule_engine_test.xml"), VersionType.MAJOR, superUser); + ImportPetriNetEventOutcome outcome = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/rule_engine_test.xml"), VersionType.MAJOR, superUser)); assert outcome.getNet() != null; assert outcome.getNet().getTitle().getDefaultValue().equals(NET_TITLE_PRE); @@ -137,7 +139,8 @@ void testNetImportRulePOST() throws IOException, MissingPetriNetMetaDataExceptio assert refreshableKieBase.shouldRefresh(); - ImportPetriNetEventOutcome outcome = petriNetService.importPetriNet(new FileInputStream("src/test/resources/rule_engine_test.xml"), VersionType.MAJOR, superUser); + ImportPetriNetEventOutcome outcome = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/rule_engine_test.xml"), VersionType.MAJOR, superUser)); assert !refreshableKieBase.shouldRefresh(); @@ -158,7 +161,8 @@ void testTransitionRules() throws IOException, MissingPetriNetMetaDataException, final String NEW_CASE_TITLE_2 = "new case title 2"; final String TEXT_VALUE = "TEXT FIELD VALUE"; - ImportPetriNetEventOutcome outcome = petriNetService.importPetriNet(new FileInputStream("src/test/resources/rule_engine_test.xml"), VersionType.MAJOR, superUser); + ImportPetriNetEventOutcome outcome = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/rule_engine_test.xml"), VersionType.MAJOR, superUser)); assert outcome != null; StoredRule rule = StoredRule.builder() @@ -381,7 +385,8 @@ private StoredRule rule(String when, String then) { } private Case newCase() throws IOException, MissingPetriNetMetaDataException, MissingIconKeyException { - ImportPetriNetEventOutcome outcome = petriNetService.importPetriNet(new FileInputStream("src/test/resources/rule_engine_test.xml"), VersionType.MAJOR, superUser); + ImportPetriNetEventOutcome outcome = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/rule_engine_test.xml"), VersionType.MAJOR, superUser)); CreateCaseParams createCaseParams = CreateCaseParams.builder() .petriNet(outcome.getNet()) .title("Original title") diff --git a/src/test/java/com/netgrif/application/engine/rules/service/RuleEvaluationScheduleServiceTest.java b/src/test/java/com/netgrif/application/engine/rules/service/RuleEvaluationScheduleServiceTest.java index a0a0f91934d..a8e85ccda65 100644 --- a/src/test/java/com/netgrif/application/engine/rules/service/RuleEvaluationScheduleServiceTest.java +++ b/src/test/java/com/netgrif/application/engine/rules/service/RuleEvaluationScheduleServiceTest.java @@ -4,6 +4,7 @@ import com.netgrif.application.engine.auth.domain.LoggedUser; import com.netgrif.application.engine.importer.service.throwable.MissingIconKeyException; import com.netgrif.application.engine.petrinet.domain.VersionType; +import com.netgrif.application.engine.petrinet.domain.params.ImportPetriNetParams; import com.netgrif.application.engine.petrinet.domain.throwable.MissingPetriNetMetaDataException; import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService; import com.netgrif.application.engine.rules.domain.RuleRepository; @@ -68,7 +69,8 @@ public void before() { @Disabled void testScheduledRule() throws IOException, MissingPetriNetMetaDataException, RuleEvaluationScheduleException, InterruptedException, MissingIconKeyException { LoggedUser user = superCreator.getLoggedSuper(); - ImportPetriNetEventOutcome importOutcome = petriNetService.importPetriNet(new FileInputStream("src/test/resources/rule_engine_test.xml"), VersionType.MAJOR, user); + ImportPetriNetEventOutcome importOutcome = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/rule_engine_test.xml"), VersionType.MAJOR, user)); StoredRule rule = StoredRule.builder() .when("$case: Case() $event: ScheduledRuleFact(instanceId == $case.stringId, ruleIdentifier == \"rule2\")") diff --git a/src/test/java/com/netgrif/application/engine/workflow/service/TaskServiceTest.java b/src/test/java/com/netgrif/application/engine/workflow/service/TaskServiceTest.java index 4cb1511a366..176a3341bf9 100644 --- a/src/test/java/com/netgrif/application/engine/workflow/service/TaskServiceTest.java +++ b/src/test/java/com/netgrif/application/engine/workflow/service/TaskServiceTest.java @@ -10,6 +10,7 @@ import com.netgrif.application.engine.importer.service.throwable.MissingIconKeyException; import com.netgrif.application.engine.petrinet.domain.PetriNet; import com.netgrif.application.engine.petrinet.domain.VersionType; +import com.netgrif.application.engine.petrinet.domain.params.ImportPetriNetParams; import com.netgrif.application.engine.petrinet.domain.repositories.PetriNetRepository; import com.netgrif.application.engine.petrinet.domain.throwable.MissingPetriNetMetaDataException; import com.netgrif.application.engine.petrinet.domain.throwable.TransitionNotExecutableException; @@ -91,7 +92,8 @@ public void setUp() throws Exception { userRunner.run(""); uriRunner.run(); - petriNetService.importPetriNet(new FileInputStream("src/test/resources/prikladFM.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()); + petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/prikladFM.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())); PetriNet net = petriNetRepository.findAll().get(0); CreateCaseParams createCaseParams = CreateCaseParams.builder() .petriNet(net) @@ -104,7 +106,8 @@ public void setUp() throws Exception { @Test public void resetArcTest() throws TransitionNotExecutableException, MissingPetriNetMetaDataException, IOException, MissingIconKeyException { - PetriNet net = petriNetService.importPetriNet(new FileInputStream("src/test/resources/reset_inhibitor_test.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()).getNet(); + PetriNet net = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/reset_inhibitor_test.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())).getNet(); LoggedUser loggedUser = mockLoggedUser(); CreateCaseParams createCaseParams = CreateCaseParams.builder() .petriNet(net) @@ -121,9 +124,9 @@ public void resetArcTest() throws TransitionNotExecutableException, MissingPetri user.setState(UserState.ACTIVE); user = userRepository.save(user); - assert outcome.getCase().getConsumedTokens().size() == 0; + assert outcome.getCase().getConsumedTokens().isEmpty(); assert outcome.getCase().getActivePlaces().size() == 1; - assert outcome.getCase().getActivePlaces().values().contains(5); + assert outcome.getCase().getActivePlaces().containsValue(5); Task task = taskRepository.findAll().stream().filter(t -> t.getTitle().getDefaultValue().equalsIgnoreCase("reset")).findFirst().orElse(null); @@ -133,15 +136,15 @@ public void resetArcTest() throws TransitionNotExecutableException, MissingPetri Case useCase = caseRepository.findById(outcome.getCase().getStringId()).get(); assert useCase.getConsumedTokens().size() == 1; - assert useCase.getConsumedTokens().values().contains(5); - assert useCase.getActivePlaces().size() == 0; + assert useCase.getConsumedTokens().containsValue(5); + assert useCase.getActivePlaces().isEmpty(); service.cancelTask(new TaskParams(task, user)); useCase = caseRepository.findById(useCase.getStringId()).get(); - assert useCase.getConsumedTokens().size() == 0; + assert useCase.getConsumedTokens().isEmpty(); assert useCase.getActivePlaces().size() == 1; - assert useCase.getActivePlaces().values().contains(5); + assert useCase.getActivePlaces().containsValue(5); } public LoggedUser mockLoggedUser() { diff --git a/src/test/java/com/netgrif/application/engine/workflow/web/VariableArcsTest.java b/src/test/java/com/netgrif/application/engine/workflow/web/VariableArcsTest.java index 13ca81d92e2..27e7794a457 100644 --- a/src/test/java/com/netgrif/application/engine/workflow/web/VariableArcsTest.java +++ b/src/test/java/com/netgrif/application/engine/workflow/web/VariableArcsTest.java @@ -12,6 +12,7 @@ import com.netgrif.application.engine.petrinet.domain.VersionType; import com.netgrif.application.engine.petrinet.domain.arcs.Arc; import com.netgrif.application.engine.petrinet.domain.dataset.NumberField; +import com.netgrif.application.engine.petrinet.domain.params.ImportPetriNetParams; import com.netgrif.application.engine.petrinet.domain.repositories.PetriNetRepository; import com.netgrif.application.engine.petrinet.domain.roles.ProcessRole; import com.netgrif.application.engine.petrinet.domain.throwable.TransitionNotExecutableException; @@ -102,7 +103,8 @@ public void before() throws Exception { repository.deleteAll(); assertNotNull(processRoleService.defaultRole()); testHelper.truncateDbs(); - ImportPetriNetEventOutcome outcome = service.importPetriNet(new FileInputStream(NET_PATH), VersionType.MAJOR, superCreator.getLoggedSuper()); + ImportPetriNetEventOutcome outcome = service.importPetriNet(new ImportPetriNetParams( + new FileInputStream(NET_PATH), VersionType.MAJOR, superCreator.getLoggedSuper())); assert outcome.getNet() != null; PetriNet net = outcome.getNet(); diff --git a/src/test/resources/petriNets/transaction/transaction_test.xml b/src/test/resources/petriNets/transaction/transaction_test.xml index 320e48ec05a..71d487f021f 100644 --- a/src/test/resources/petriNets/transaction/transaction_test.xml +++ b/src/test/resources/petriNets/transaction/transaction_test.xml @@ -174,8 +174,10 @@ def myTransaction = transaction( event: { - petriNetService.importPetriNet(new java.io.FileInputStream("src/test/resources/petriNets/transaction/transaction_test_secondary.xml"), - com.netgrif.application.engine.petrinet.domain.VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser()) + petriNetService.importPetriNet(new com.netgrif.application.engine.petrinet.domain.params.ImportPetriNetParams( + new java.io.FileInputStream("src/test/resources/petriNets/transaction/transaction_test_secondary.xml"), + com.netgrif.application.engine.petrinet.domain.VersionType.MAJOR, + userService.getLoggedOrSystem().transformToLoggedUser())) def toBeRemovedCase = createCase("transaction_test_secondary", "toBeRemoved") assignTask("t1", toBeRemovedCase) deleteCase(toBeRemovedCase) From 109e60ca633332670964b83189689234292f7ab5 Mon Sep 17 00:00:00 2001 From: chvostek <chvostek@netgrif.com> Date: Thu, 8 Aug 2024 11:29:04 +0200 Subject: [PATCH 31/48] [NAE-1998] Implement transactions for events - fix WorkflowAuthorizationServiceTest --- .../engine/auth/WorkflowAuthorizationServiceTest.groovy | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/test/groovy/com/netgrif/application/engine/auth/WorkflowAuthorizationServiceTest.groovy b/src/test/groovy/com/netgrif/application/engine/auth/WorkflowAuthorizationServiceTest.groovy index 26eed34d6a9..1a40b3b8e05 100644 --- a/src/test/groovy/com/netgrif/application/engine/auth/WorkflowAuthorizationServiceTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/auth/WorkflowAuthorizationServiceTest.groovy @@ -217,7 +217,7 @@ class WorkflowAuthorizationServiceTest { userService.addRole(testUser, negDeleteRole.getStringId()) CreateCaseParams createCaseParams = CreateCaseParams.builder() - .petriNet(net) + .petriNet(netWithUserRefs) .title("Test delete") .color("") .loggedUser(testUser.transformToLoggedUser()) From 031f69769af5d6f235e726ed2aa5879d0ebda152 Mon Sep 17 00:00:00 2001 From: chvostek <chvostek@netgrif.com> Date: Thu, 8 Aug 2024 16:08:41 +0200 Subject: [PATCH 32/48] [NAE-1998] Implement transactions for events - fixes according to unit tests --- .../dataset/logic/action/ActionDelegate.groovy | 12 ++---------- .../engine/petrinet/service/PetriNetService.java | 3 --- .../engine/workflow/service/DataService.java | 7 +------ .../engine/workflow/service/TaskService.java | 14 ++------------ .../engine/workflow/service/WorkflowService.java | 5 ----- .../petriNets/transaction/transaction_test.xml | 6 ++++-- 6 files changed, 9 insertions(+), 38 deletions(-) diff --git a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy index 8f672b9bb93..d63742d6bd7 100644 --- a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy +++ b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy @@ -534,7 +534,7 @@ class ActionDelegate /*TODO: release/8.0.0: implements ActionAPI*/ { (field.stringId): field.class.newInstance(changes) ] as Map<String, Field<?>>), user)) this.outcomes.add(outcome) - updateCase(outcome) + updateCase() return outcome } @@ -894,7 +894,7 @@ class ActionDelegate /*TODO: release/8.0.0: implements ActionAPI*/ { private Task addTaskOutcomeAndReturnTask(TaskEventOutcome outcome) { this.outcomes.add(outcome) - updateCase(outcome) + updateCase() return outcome.getTask() } @@ -2184,14 +2184,6 @@ class ActionDelegate /*TODO: release/8.0.0: implements ActionAPI*/ { initFieldsMap(action.fieldIds, useCase) } - void updateCase(CaseEventOutcome outcome) { - if (!useCase) { - return - } - useCase = outcome.getCase() - initFieldsMap(action.fieldIds, useCase) - } - @Deprecated Map<String, Case> createMenuItem(String id, String uri, String query, String icon, String title, List<String> allowedNets, Map<String, String> roles, Map<String, String> bannedRoles = [:], Case group = null, List<String> defaultHeaders = []) { if (existsMenuItem(id)) { diff --git a/src/main/java/com/netgrif/application/engine/petrinet/service/PetriNetService.java b/src/main/java/com/netgrif/application/engine/petrinet/service/PetriNetService.java index 6991d1858e4..58414e78a6a 100644 --- a/src/main/java/com/netgrif/application/engine/petrinet/service/PetriNetService.java +++ b/src/main/java/com/netgrif/application/engine/petrinet/service/PetriNetService.java @@ -53,7 +53,6 @@ import org.springframework.data.mongodb.core.query.Criteria; import org.springframework.data.mongodb.core.query.Query; import org.springframework.stereotype.Service; -import org.springframework.transaction.annotation.Transactional; import javax.annotation.Resource; import javax.inject.Provider; @@ -183,7 +182,6 @@ public PetriNet clone(ObjectId petriNetId) { * todo javadoc * */ @Override - @Transactional public ImportPetriNetEventOutcome importPetriNet(ImportPetriNetParams importPetriNetParams) throws IOException, MissingPetriNetMetaDataException, MissingIconKeyException { fillMissingAttributes(importPetriNetParams); @@ -522,7 +520,6 @@ private void addValueCriteria(Query query, Query queryTotal, Criteria criteria) } @Override - @Transactional public void deletePetriNet(String processId, LoggedUser loggedUser) { Optional<PetriNet> petriNetOptional = repository.findById(processId); if (petriNetOptional.isEmpty()) { diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/DataService.java b/src/main/java/com/netgrif/application/engine/workflow/service/DataService.java index 3dab66880d5..123e49af4bc 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/DataService.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/DataService.java @@ -43,7 +43,6 @@ import org.springframework.beans.factory.annotation.Value; 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; @@ -90,7 +89,6 @@ public class DataService implements IDataService { * todo javadoc * */ @Override - @Transactional public GetDataEventOutcome getData(GetDataParams getDataParams) { fillMissingAttributes(getDataParams); @@ -154,7 +152,6 @@ private void fillMissingAttributes(GetDataParams getDataParams) throws IllegalAr * todo javadoc * */ @Override - @Transactional public SetDataEventOutcome setData(SetDataParams setDataParams) { fillMissingAttributes(setDataParams); @@ -237,7 +234,7 @@ public SetDataEventOutcome setDataField(Task task, String fieldId, Field<?> newD List<EventOutcome> postSetOutcomes = resolveDataEvents(field, DataEventType.SET, EventPhase.POST, useCase, task, newDataField, params); if (!postSetOutcomes.isEmpty()) { - outcome.addOutcomes(resolveDataEvents(field, DataEventType.SET, EventPhase.POST, useCase, task, newDataField, params)); + outcome.addOutcomes(postSetOutcomes); useCase = workflowService.findOne(task.getCaseId()); } historyService.save(new SetDataEventLog(task, useCase, EventPhase.POST, DataSet.of(fieldId, newDataField), user)); @@ -260,14 +257,12 @@ 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); } diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/TaskService.java b/src/main/java/com/netgrif/application/engine/workflow/service/TaskService.java index e7718b14484..cbd7d5f65bc 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/TaskService.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/TaskService.java @@ -60,7 +60,6 @@ import org.springframework.data.mongodb.core.query.BasicQuery; import org.springframework.scheduling.TaskScheduler; import org.springframework.stereotype.Service; -import org.springframework.transaction.annotation.Transactional; import java.time.LocalDateTime; import java.util.*; @@ -111,7 +110,6 @@ public class TaskService implements ITaskService { * todo javadoc * */ @Override - @Transactional public List<EventOutcome> executeTask(Task task, Case useCase) { log.info("[{}]: executeTask [{}] in case [{}]", useCase.getStringId(), task.getTransitionId(), useCase.getTitle()); List<EventOutcome> outcomes = new ArrayList<>(); @@ -120,7 +118,8 @@ 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(new GetDataParams(task, useCase, userService.getSystem())); + GetDataEventOutcome getDataOutcome = dataService.getData(new GetDataParams(assignOutcome.getTask(), + assignOutcome.getCase(), userService.getSystem())); outcomes.add(getDataOutcome); log.info("finishTask [{}] in case [{}]", task.getTitle(), useCase.getTitle()); outcomes.add(finishTask(new TaskParams(getDataOutcome.getTask()))); @@ -134,7 +133,6 @@ public List<EventOutcome> executeTask(Task task, Case useCase) { * todo javadoc * */ @Override - @Transactional public List<AssignTaskEventOutcome> assignTasks(List<Task> tasks, IUser user, Map<String, String> params) throws TransitionNotExecutableException { List<AssignTaskEventOutcome> outcomes = new ArrayList<>(); for (Task task : tasks) { @@ -153,7 +151,6 @@ public List<AssignTaskEventOutcome> assignTasks(List<Task> tasks, IUser user, Ma * todo javadoc * */ @Override - @Transactional public AssignTaskEventOutcome assignTask(TaskParams taskParams) throws TransitionNotExecutableException { fillMissingAttributes(taskParams); @@ -223,7 +220,6 @@ private DoEventTaskOutcome doAssignTaskToUser(IUser user, Task task, Transition } @Override - @Transactional public List<FinishTaskEventOutcome> finishTasks(List<Task> tasks, IUser user, Map<String, String> params) throws TransitionNotExecutableException { List<FinishTaskEventOutcome> outcomes = new ArrayList<>(); for (Task task : tasks) { @@ -242,7 +238,6 @@ public List<FinishTaskEventOutcome> finishTasks(List<Task> tasks, IUser user, Ma * todo javadoc * */ @Override - @Transactional public FinishTaskEventOutcome finishTask(TaskParams taskParams) throws TransitionNotExecutableException { fillMissingAttributes(taskParams); @@ -313,7 +308,6 @@ private DoEventTaskOutcome doFinishTaskByAssignedUser(Task task, Transition tran } @Override - @Transactional public List<CancelTaskEventOutcome> cancelTasks(List<Task> tasks, IUser user, Map<String, String> params) { List<CancelTaskEventOutcome> outcomes = new ArrayList<>(); for (Task task : tasks) { @@ -332,7 +326,6 @@ public List<CancelTaskEventOutcome> cancelTasks(List<Task> tasks, IUser user, Ma * todo javadoc * */ @Override - @Transactional public CancelTaskEventOutcome cancelTask(TaskParams taskParams) { fillMissingAttributes(taskParams); @@ -405,13 +398,11 @@ private DoEventTaskOutcome doCancelTaskToUser(Task task, Case useCase) { } @Override - @Transactional public DelegateTaskEventOutcome delegateTask(LoggedUser loggedUser, String delegatedId, String taskId) throws TransitionNotExecutableException { return delegateTask(loggedUser, delegatedId, taskId, new HashMap<>()); } @Override - @Transactional public DelegateTaskEventOutcome delegateTask(LoggedUser loggedUser, String delegatedId, String taskId, Map<String, String> params) throws TransitionNotExecutableException { IUser delegatedUser = userService.resolveById(delegatedId, true); IUser delegateUser = userService.getUserFromLoggedUser(loggedUser); @@ -495,7 +486,6 @@ private Case evaluateRules(Case useCase, Task task, EventType eventType, EventPh * </table> */ @Override - @Transactional public boolean reloadTasks(Case useCase) { log.info("[{}]: Reloading tasks in [{}]", useCase.getStringId(), useCase.getTitle()); List<String> taskIds = useCase.getTasks().values().stream() diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/WorkflowService.java b/src/main/java/com/netgrif/application/engine/workflow/service/WorkflowService.java index f0d6ee94067..87bf04af2ab 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/WorkflowService.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/WorkflowService.java @@ -48,7 +48,6 @@ import org.springframework.data.mongodb.core.query.BasicQuery; import org.springframework.data.util.Pair; import org.springframework.stereotype.Service; -import org.springframework.transaction.annotation.Transactional; import java.time.LocalDateTime; import java.util.*; @@ -203,7 +202,6 @@ private List<String> getExistingUsers(UserListFieldValue userListValue) { * todo javadoc * */ @Override - @Transactional public CreateCaseEventOutcome createCase(CreateCaseParams createCaseParams) { fillMissingAttributes(createCaseParams); @@ -326,7 +324,6 @@ public Page<Case> findAllByAuthor(String authorId, String petriNet, Pageable pag * todo javadoc * */ @Override - @Transactional public DeleteCaseEventOutcome deleteCase(DeleteCaseParams deleteCaseParams) { fillMissingAttributes(deleteCaseParams); @@ -367,7 +364,6 @@ private void fillMissingAttributes(DeleteCaseParams deleteCaseParams) throws Ill } @Override - @Transactional public void deleteInstancesOfPetriNet(PetriNet net) { final IUser user = userService.getLoggedOrSystem(); final LoggedUser loggedUser = user.transformToLoggedUser(); @@ -399,7 +395,6 @@ public void deleteInstancesOfPetriNet(PetriNet net) { } @Override - @Transactional public DeleteCaseEventOutcome deleteSubtreeRootedAt(String subtreeRootCaseId) { Case subtreeRoot = findOne(subtreeRootCaseId); if (subtreeRoot.getImmediateDataFields().contains("treeChildCases")) { diff --git a/src/test/resources/petriNets/transaction/transaction_test.xml b/src/test/resources/petriNets/transaction/transaction_test.xml index 71d487f021f..db63f8b9146 100644 --- a/src/test/resources/petriNets/transaction/transaction_test.xml +++ b/src/test/resources/petriNets/transaction/transaction_test.xml @@ -142,8 +142,10 @@ def myTransaction = transaction( event: { - petriNetService.importPetriNet(new java.io.FileInputStream("src/test/resources/petriNets/transaction/transaction_test_secondary.xml"), - com.netgrif.application.engine.petrinet.domain.VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser()) + petriNetService.importPetriNet(new com.netgrif.application.engine.petrinet.domain.params.ImportPetriNetParams( + new java.io.FileInputStream("src/test/resources/petriNets/transaction/transaction_test_secondary.xml"), + com.netgrif.application.engine.petrinet.domain.VersionType.MAJOR, + userService.getLoggedOrSystem().transformToLoggedUser())) def toBeRemovedCase = createCase("transaction_test_secondary", "toBeRemoved") assignTask("t1", toBeRemovedCase) deleteCase(toBeRemovedCase) From dc74e8ed562a91b35dfc231003238c16f254afd0 Mon Sep 17 00:00:00 2001 From: chvostek <chvostek@netgrif.com> Date: Fri, 9 Aug 2024 09:51:45 +0200 Subject: [PATCH 33/48] [NAE-1998] Implement transactions for events - change builder() to with() --- .../logic/action/ActionDelegate.groovy | 30 ++++++------ .../startup/DefaultFiltersRunner.groovy | 2 +- .../engine/startup/ImportHelper.groovy | 2 +- .../orgstructure/groups/NextGroupService.java | 2 +- .../domain/params/CreateCaseParams.java | 2 +- .../domain/params/DeleteCaseParams.java | 2 +- .../workflow/domain/params/GetDataParams.java | 2 +- .../workflow/domain/params/SetDataParams.java | 2 +- .../workflow/domain/params/TaskParams.java | 2 +- .../service/FilterImportExportService.java | 4 +- .../service/MenuImportExportService.java | 2 +- .../engine/workflow/service/TaskService.java | 6 +-- .../workflow/web/AbstractTaskController.java | 6 +-- .../web/PublicWorkflowController.java | 2 +- .../workflow/web/WorkflowController.java | 2 +- .../engine/action/AssignRemoveTest.groovy | 4 +- .../engine/action/MenuItemApiTest.groovy | 2 +- .../auth/TaskAuthorizationServiceTest.groovy | 48 +++++++++---------- .../WorkflowAuthorizationServiceTest.groovy | 8 ++-- .../engine/elastic/ReindexTest.groovy | 2 +- .../engine/history/HistoryServiceTest.groovy | 6 +-- .../ImpersonationServiceTest.groovy | 8 ++-- .../PredefinedRolesPermissionsTest.groovy | 2 +- .../engine/insurance/EncryptionTest.groovy | 2 +- .../ElasticSearchViewPermissionTest.groovy | 28 +++++------ .../petrinet/domain/FunctionsTest.groovy | 16 +++---- .../petrinet/domain/ImporterTest.groovy | 4 +- .../domain/dataset/DynamicCaseNameTest.groovy | 4 +- .../domain/dataset/FileFieldTest.groovy | 4 +- .../domain/dataset/FileListFieldTest.groovy | 4 +- .../engine/workflow/NewInitTest.groovy | 2 +- .../engine/workflow/TaskStateTest.groovy | 4 +- .../engine/importer/ImporterTest.java | 2 +- .../engine/rules/service/RuleEngineTest.java | 4 +- .../RuleEvaluationScheduleServiceTest.java | 2 +- .../workflow/service/TaskServiceTest.java | 4 +- .../engine/workflow/web/VariableArcsTest.java | 34 ++++++------- .../change_caseref_value_action_test.xml | 4 +- 38 files changed, 133 insertions(+), 133 deletions(-) diff --git a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy index d63742d6bd7..96b946051c5 100644 --- a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy +++ b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionDelegate.groovy @@ -811,7 +811,7 @@ class ActionDelegate /*TODO: release/8.0.0: implements ActionAPI*/ { } Case createCase(String identifier, String title = null, String color = "", IUser author = userService.loggedOrSystem, Locale locale = LocaleContextHolder.getLocale(), Map<String, String> params = [:]) { - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNetIdentifier(identifier) .title(title) .color(color) @@ -822,7 +822,7 @@ class ActionDelegate /*TODO: release/8.0.0: implements ActionAPI*/ { } Case createCase(PetriNet net, String title = net.defaultCaseName.getTranslation(locale), String color = "", IUser author = userService.loggedOrSystem, Locale locale = LocaleContextHolder.getLocale(), Map<String, String> params = [:]) { - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(net) .title(title) .color(color) @@ -846,7 +846,7 @@ class ActionDelegate /*TODO: release/8.0.0: implements ActionAPI*/ { Task assignTask(String transitionId, Case aCase = useCase, IUser user = userService.loggedOrSystem, Map<String, String> params = [:]) { String taskId = getTaskId(transitionId, aCase) - TaskParams taskParams = TaskParams.builder() + TaskParams taskParams = TaskParams.with() .taskId(taskId) .useCase(aCase) .user(user) @@ -856,7 +856,7 @@ class ActionDelegate /*TODO: release/8.0.0: implements ActionAPI*/ { } Task assignTask(Task task, IUser user = userService.loggedOrSystem, Map<String, String> params = [:]) { - TaskParams taskParams = TaskParams.builder() + TaskParams taskParams = TaskParams.with() .task(task) .user(user) .params(params) @@ -870,7 +870,7 @@ class ActionDelegate /*TODO: release/8.0.0: implements ActionAPI*/ { Task cancelTask(String transitionId, Case aCase = useCase, IUser user = userService.loggedOrSystem, Map<String, String> params = [:]) { String taskId = getTaskId(transitionId, aCase) - TaskParams taskParams = TaskParams.builder() + TaskParams taskParams = TaskParams.with() .taskId(taskId) .useCase(aCase) .user(user) @@ -880,7 +880,7 @@ class ActionDelegate /*TODO: release/8.0.0: implements ActionAPI*/ { } Task cancelTask(Task task, IUser user = userService.loggedOrSystem, Map<String, String> params = [:]) { - TaskParams taskParams = TaskParams.builder() + TaskParams taskParams = TaskParams.with() .task(task) .user(user) .params(params) @@ -900,7 +900,7 @@ class ActionDelegate /*TODO: release/8.0.0: implements ActionAPI*/ { void finishTask(String transitionId, Case aCase = useCase, IUser user = userService.loggedOrSystem, Map<String, String> params = [:]) { String taskId = getTaskId(transitionId, aCase) - TaskParams taskParams = TaskParams.builder() + TaskParams taskParams = TaskParams.with() .taskId(taskId) .useCase(aCase) .user(user) @@ -910,7 +910,7 @@ class ActionDelegate /*TODO: release/8.0.0: implements ActionAPI*/ { } void finishTask(Task task, IUser user = userService.loggedOrSystem, Map<String, String> params = [:]) { - TaskParams taskParams = TaskParams.builder() + TaskParams taskParams = TaskParams.with() .task(task) .user(user) .params(params) @@ -1000,7 +1000,7 @@ class ActionDelegate /*TODO: release/8.0.0: implements ActionAPI*/ { } SetDataEventOutcome setData(String taskId, DataSet dataSet, IUser user = userService.loggedOrSystem, Map<String, String> params = [:]) { - SetDataParams setDataParams = SetDataParams.builder() + SetDataParams setDataParams = SetDataParams.with() .taskId(taskId) .dataSet(dataSet) .user(user) @@ -1016,7 +1016,7 @@ class ActionDelegate /*TODO: release/8.0.0: implements ActionAPI*/ { SetDataEventOutcome setData(String transitionId, Case useCase, DataSet dataSet, IUser user = userService.loggedOrSystem, Map<String, String> params = [:]) { def predicate = QTask.task.caseId.eq(useCase.stringId) & QTask.task.transitionId.eq(transitionId) def task = taskService.searchOne(predicate) - SetDataParams setDataParams = SetDataParams.builder() + SetDataParams setDataParams = SetDataParams.with() .task(task) .dataSet(dataSet) .user(user) @@ -1050,7 +1050,7 @@ 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) - GetDataParams getDataParams = GetDataParams.builder() + GetDataParams getDataParams = GetDataParams.with() .task(task) .useCase(useCase) .user(user) @@ -1060,7 +1060,7 @@ class ActionDelegate /*TODO: release/8.0.0: implements ActionAPI*/ { } Map<String, Field> getData(String taskId, IUser user = userService.loggedOrSystem, Map<String, String> params = [:]) { - GetDataParams getDataParams = GetDataParams.builder() + GetDataParams getDataParams = GetDataParams.with() .taskId(taskId) .user(user) .params(params) @@ -1078,7 +1078,7 @@ class ActionDelegate /*TODO: release/8.0.0: implements ActionAPI*/ { if (!task) { return new HashMap<String, Field>() } - GetDataParams getDataParams = GetDataParams.builder() + GetDataParams getDataParams = GetDataParams.with() .task(task) .useCase(useCase) .user(user) @@ -1595,7 +1595,7 @@ class ActionDelegate /*TODO: release/8.0.0: implements ActionAPI*/ { * @return */ def deleteFilter(Case filter) { - DeleteCaseParams deleteCaseParams = DeleteCaseParams.builder() + DeleteCaseParams deleteCaseParams = DeleteCaseParams.with() .useCase(filter) .build() workflowService.deleteCase(deleteCaseParams) @@ -1917,7 +1917,7 @@ class ActionDelegate /*TODO: release/8.0.0: implements ActionAPI*/ { */ def deleteMenuItem(Case item) { async.run { - DeleteCaseParams deleteCaseParams = DeleteCaseParams.builder() + DeleteCaseParams deleteCaseParams = DeleteCaseParams.with() .useCase(item) .build() workflowService.deleteCase(deleteCaseParams) diff --git a/src/main/groovy/com/netgrif/application/engine/startup/DefaultFiltersRunner.groovy b/src/main/groovy/com/netgrif/application/engine/startup/DefaultFiltersRunner.groovy index cb8dc604008..8cef6b248a8 100644 --- a/src/main/groovy/com/netgrif/application/engine/startup/DefaultFiltersRunner.groovy +++ b/src/main/groovy/com/netgrif/application/engine/startup/DefaultFiltersRunner.groovy @@ -269,7 +269,7 @@ class DefaultFiltersRunner extends AbstractOrderedCommandLineRunner { } } - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(filterNet) .title(title) .color(null) diff --git a/src/main/groovy/com/netgrif/application/engine/startup/ImportHelper.groovy b/src/main/groovy/com/netgrif/application/engine/startup/ImportHelper.groovy index 79e9495d055..fd99fffa368 100644 --- a/src/main/groovy/com/netgrif/application/engine/startup/ImportHelper.groovy +++ b/src/main/groovy/com/netgrif/application/engine/startup/ImportHelper.groovy @@ -144,7 +144,7 @@ class ImportHelper { } Case createCase(String title, PetriNet net, LoggedUser user) { - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(net) .title(title) .color("") diff --git a/src/main/java/com/netgrif/application/engine/orgstructure/groups/NextGroupService.java b/src/main/java/com/netgrif/application/engine/orgstructure/groups/NextGroupService.java index e5bcd9f37d5..ecd58e00fad 100644 --- a/src/main/java/com/netgrif/application/engine/orgstructure/groups/NextGroupService.java +++ b/src/main/java/com/netgrif/application/engine/orgstructure/groups/NextGroupService.java @@ -107,7 +107,7 @@ public CreateCaseEventOutcome createGroup(String title, IUser author) { if (userDefaultGroup != null && userDefaultGroup.getTitle().equals(title)) { return null; } - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(petriNetService.getNewestVersionByIdentifier(GROUP_NET_IDENTIFIER)) .title(title) .color("") diff --git a/src/main/java/com/netgrif/application/engine/workflow/domain/params/CreateCaseParams.java b/src/main/java/com/netgrif/application/engine/workflow/domain/params/CreateCaseParams.java index cbd3c5c7c67..2e5ca8c8f82 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/domain/params/CreateCaseParams.java +++ b/src/main/java/com/netgrif/application/engine/workflow/domain/params/CreateCaseParams.java @@ -16,7 +16,7 @@ * todo javadoc * */ @Data -@Builder +@Builder(builderMethodName = "with") public class CreateCaseParams { private String petriNetId; diff --git a/src/main/java/com/netgrif/application/engine/workflow/domain/params/DeleteCaseParams.java b/src/main/java/com/netgrif/application/engine/workflow/domain/params/DeleteCaseParams.java index 7e7bc3d756d..2deab8b0931 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/domain/params/DeleteCaseParams.java +++ b/src/main/java/com/netgrif/application/engine/workflow/domain/params/DeleteCaseParams.java @@ -12,8 +12,8 @@ * todo javadoc * */ @Data -@Builder @AllArgsConstructor +@Builder(builderMethodName = "with") public class DeleteCaseParams { private String useCaseId; diff --git a/src/main/java/com/netgrif/application/engine/workflow/domain/params/GetDataParams.java b/src/main/java/com/netgrif/application/engine/workflow/domain/params/GetDataParams.java index f5a705d581c..fbdfda4b6dc 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/domain/params/GetDataParams.java +++ b/src/main/java/com/netgrif/application/engine/workflow/domain/params/GetDataParams.java @@ -11,8 +11,8 @@ import java.util.Map; @Data -@Builder @AllArgsConstructor +@Builder(builderMethodName = "with") public class GetDataParams { private String taskId; diff --git a/src/main/java/com/netgrif/application/engine/workflow/domain/params/SetDataParams.java b/src/main/java/com/netgrif/application/engine/workflow/domain/params/SetDataParams.java index 06e98d0811c..315b3cf5062 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/domain/params/SetDataParams.java +++ b/src/main/java/com/netgrif/application/engine/workflow/domain/params/SetDataParams.java @@ -12,8 +12,8 @@ import java.util.Map; @Data -@Builder @AllArgsConstructor +@Builder(builderMethodName = "with") public class SetDataParams { private Task task; diff --git a/src/main/java/com/netgrif/application/engine/workflow/domain/params/TaskParams.java b/src/main/java/com/netgrif/application/engine/workflow/domain/params/TaskParams.java index 85749bcf4d2..5f44860fd4e 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/domain/params/TaskParams.java +++ b/src/main/java/com/netgrif/application/engine/workflow/domain/params/TaskParams.java @@ -11,8 +11,8 @@ import java.util.Map; @Data -@Builder @AllArgsConstructor +@Builder(builderMethodName = "with") public class TaskParams { private String taskId; diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/FilterImportExportService.java b/src/main/java/com/netgrif/application/engine/workflow/service/FilterImportExportService.java index a9a3c9e7ec0..3ce4f04e138 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/FilterImportExportService.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/FilterImportExportService.java @@ -87,7 +87,7 @@ public class FilterImportExportService implements IFilterImportExportService { @Override public void createFilterImport(IUser author) { - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNetIdentifier(IMPORT_NET_IDENTIFIER) .title("Import filters " + author.getFullName()) .color("") @@ -98,7 +98,7 @@ public void createFilterImport(IUser author) { @Override public void createFilterExport(IUser author) { - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNetIdentifier(EXPORT_NET_IDENTIFIER) .title("Export filters " + author.getFullName()) .color("") diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/MenuImportExportService.java b/src/main/java/com/netgrif/application/engine/workflow/service/MenuImportExportService.java index 96c35d5cf5b..625c9ab2fe3 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/MenuImportExportService.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/MenuImportExportService.java @@ -248,7 +248,7 @@ public String createMenuItemCase(StringBuilder resultMessage, MenuEntry item, St }); } //Creating new Case of preference_filter_item net and setting its data... - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(petriNetService.getNewestVersionByIdentifier("preference_filter_item")) .title(item.getEntryName() + "_" + menuIdentifier) .color("") diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/TaskService.java b/src/main/java/com/netgrif/application/engine/workflow/service/TaskService.java index cbd7d5f65bc..e20c0b3fcc4 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/TaskService.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/TaskService.java @@ -137,7 +137,7 @@ public List<AssignTaskEventOutcome> assignTasks(List<Task> tasks, IUser user, Ma List<AssignTaskEventOutcome> outcomes = new ArrayList<>(); for (Task task : tasks) { outcomes.add( - assignTask(TaskParams.builder() + assignTask(TaskParams.with() .task(task) .user(user) .params(params) @@ -224,7 +224,7 @@ public List<FinishTaskEventOutcome> finishTasks(List<Task> tasks, IUser user, Ma List<FinishTaskEventOutcome> outcomes = new ArrayList<>(); for (Task task : tasks) { outcomes.add( - finishTask(TaskParams.builder() + finishTask(TaskParams.with() .task(task) .user(user) .params(params) @@ -312,7 +312,7 @@ public List<CancelTaskEventOutcome> cancelTasks(List<Task> tasks, IUser user, Ma List<CancelTaskEventOutcome> outcomes = new ArrayList<>(); for (Task task : tasks) { outcomes.add( - cancelTask(TaskParams.builder() + cancelTask(TaskParams.with() .task(task) .user(user) .params(params) diff --git a/src/main/java/com/netgrif/application/engine/workflow/web/AbstractTaskController.java b/src/main/java/com/netgrif/application/engine/workflow/web/AbstractTaskController.java index 2890a6db7bc..ac1af9a0d68 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/web/AbstractTaskController.java +++ b/src/main/java/com/netgrif/application/engine/workflow/web/AbstractTaskController.java @@ -91,7 +91,7 @@ public TaskResource getOne(String taskId, Locale locale) { public EntityModel<EventOutcomeWithMessage> assign(LoggedUser loggedUser, String taskId) { try { - TaskParams taskParams = TaskParams.builder() + TaskParams taskParams = TaskParams.with() .taskId(taskId) .user(loggedUser.transformToUser()) .build(); @@ -113,7 +113,7 @@ public EntityModel<EventOutcomeWithMessage> delegate(LoggedUser loggedUser, Stri public EntityModel<EventOutcomeWithMessage> finish(LoggedUser loggedUser, String taskId) { try { - TaskParams taskParams = TaskParams.builder() + TaskParams taskParams = TaskParams.with() .taskId(taskId) .user(loggedUser.transformToUser()) .build(); @@ -130,7 +130,7 @@ public EntityModel<EventOutcomeWithMessage> finish(LoggedUser loggedUser, String public EntityModel<EventOutcomeWithMessage> cancel(LoggedUser loggedUser, String taskId) { try { - TaskParams taskParams = TaskParams.builder() + TaskParams taskParams = TaskParams.with() .taskId(taskId) .user(loggedUser.transformToUser()) .build(); diff --git a/src/main/java/com/netgrif/application/engine/workflow/web/PublicWorkflowController.java b/src/main/java/com/netgrif/application/engine/workflow/web/PublicWorkflowController.java index 6d9a16fff0f..6b18e7efc43 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/web/PublicWorkflowController.java +++ b/src/main/java/com/netgrif/application/engine/workflow/web/PublicWorkflowController.java @@ -48,7 +48,7 @@ public PublicWorkflowController(IWorkflowService workflowService, IUserService u public EntityModel<EventOutcomeWithMessage> createCase(@RequestBody CreateCaseBody body, Locale locale) { LoggedUser loggedUser = userService.getAnonymousLogged(); try { - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNetId(body.netId) .title(body.title) .color(body.color) diff --git a/src/main/java/com/netgrif/application/engine/workflow/web/WorkflowController.java b/src/main/java/com/netgrif/application/engine/workflow/web/WorkflowController.java index dd4f74860c1..5d30b3ebb1c 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/web/WorkflowController.java +++ b/src/main/java/com/netgrif/application/engine/workflow/web/WorkflowController.java @@ -78,7 +78,7 @@ public WorkflowController(IWorkflowService workflowService, ITaskService taskSer public EntityModel<EventOutcomeWithMessage> createCase(@RequestBody CreateCaseBody body, Authentication auth, Locale locale) { LoggedUser loggedUser = (LoggedUser) auth.getPrincipal(); try { - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNetId(body.netId) .title(body.title) .color(body.color) diff --git a/src/test/groovy/com/netgrif/application/engine/action/AssignRemoveTest.groovy b/src/test/groovy/com/netgrif/application/engine/action/AssignRemoveTest.groovy index 54e84ec5feb..827b8eaca49 100644 --- a/src/test/groovy/com/netgrif/application/engine/action/AssignRemoveTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/action/AssignRemoveTest.groovy @@ -76,7 +76,7 @@ class AssignRemoveTest { def roleCount = userService.system.processRoles.size() // create - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(net) .title("TEST") .color("") @@ -86,7 +86,7 @@ class AssignRemoveTest { assert userService.system.processRoles.size() == roleCount + 4 // delete - DeleteCaseParams deleteCaseParams = DeleteCaseParams.builder() + DeleteCaseParams deleteCaseParams = DeleteCaseParams.with() .useCase(caze) .build() workflowService.deleteCase(deleteCaseParams) diff --git a/src/test/groovy/com/netgrif/application/engine/action/MenuItemApiTest.groovy b/src/test/groovy/com/netgrif/application/engine/action/MenuItemApiTest.groovy index 128f693433c..90d2c70b6de 100644 --- a/src/test/groovy/com/netgrif/application/engine/action/MenuItemApiTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/action/MenuItemApiTest.groovy @@ -323,7 +323,7 @@ class MenuItemApiTest { assert workflowService.findOne(testFolder.stringId) != null assert workflowService.findOne(leafItemId) != null - DeleteCaseParams deleteCaseParams = DeleteCaseParams.builder() + DeleteCaseParams deleteCaseParams = DeleteCaseParams.with() .useCase(testFolder) .build() workflowService.deleteCase(deleteCaseParams) diff --git a/src/test/groovy/com/netgrif/application/engine/auth/TaskAuthorizationServiceTest.groovy b/src/test/groovy/com/netgrif/application/engine/auth/TaskAuthorizationServiceTest.groovy index e6648de109b..72e9f60830c 100644 --- a/src/test/groovy/com/netgrif/application/engine/auth/TaskAuthorizationServiceTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/auth/TaskAuthorizationServiceTest.groovy @@ -281,7 +281,7 @@ class TaskAuthorizationServiceTest { void testCanAssign() { ProcessRole positiveRole = this.net.getRoles().values().find(v -> v.getImportId() == "assign_pos_role") userService.addRole(testUser, positiveRole.getStringId()) - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(net) .title("Test assign") .color("") @@ -290,7 +290,7 @@ class TaskAuthorizationServiceTest { Case case_ = workflowService.createCase(createCaseParams).getCase() assert taskAuthorizationService.canCallAssign(testUser.transformToLoggedUser(), case_.getTaskStringId("1")) userService.removeRole(testUser, positiveRole.getStringId()) - DeleteCaseParams deleteCaseParams = DeleteCaseParams.builder() + DeleteCaseParams deleteCaseParams = DeleteCaseParams.with() .useCase(case_) .build() workflowService.deleteCase(deleteCaseParams) @@ -300,7 +300,7 @@ class TaskAuthorizationServiceTest { void testCanNotAssign() { ProcessRole negativeRole = this.net.getRoles().values().find(v -> v.getImportId() == "assign_neg_role") userService.addRole(testUser, negativeRole.getStringId()) - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(net) .title("Test assign") .color("") @@ -309,7 +309,7 @@ class TaskAuthorizationServiceTest { Case case_ = workflowService.createCase(createCaseParams).getCase() assert !taskAuthorizationService.canCallAssign(testUser.transformToLoggedUser(), case_.getTaskStringId("1")) userService.removeRole(testUser, negativeRole.getStringId()) - DeleteCaseParams deleteCaseParams = DeleteCaseParams.builder() + DeleteCaseParams deleteCaseParams = DeleteCaseParams.with() .useCase(case_) .build() workflowService.deleteCase(deleteCaseParams) @@ -317,7 +317,7 @@ class TaskAuthorizationServiceTest { @Test void testCanAssignWithUsersRef() { - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(netWithUserRefs) .title("Test assign") .color("") @@ -332,7 +332,7 @@ class TaskAuthorizationServiceTest { sleep(4000) assert taskAuthorizationService.canCallAssign(testUser.transformToLoggedUser(), taskId) - DeleteCaseParams deleteCaseParams = DeleteCaseParams.builder() + DeleteCaseParams deleteCaseParams = DeleteCaseParams.with() .useCase(case_) .build() workflowService.deleteCase(deleteCaseParams) @@ -340,7 +340,7 @@ class TaskAuthorizationServiceTest { @Test void testCannotAssignWithUsersRef() { - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(netWithUserRefs) .title("Test assign") .color("") @@ -361,7 +361,7 @@ class TaskAuthorizationServiceTest { void testCanAssignWithNegRoleAndPosUsersRef() { ProcessRole positiveRole = this.netWithUserRefs.getRoles().values().find(v -> v.getImportId() == "assign_pos_role") userService.addRole(testUser, positiveRole.getStringId()) - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(netWithUserRefs) .title("Test assign") .color("") @@ -376,7 +376,7 @@ class TaskAuthorizationServiceTest { assert taskAuthorizationService.canCallAssign(testUser.transformToLoggedUser(), taskId) userService.removeRole(testUser, positiveRole.getStringId()) - DeleteCaseParams deleteCaseParams = DeleteCaseParams.builder() + DeleteCaseParams deleteCaseParams = DeleteCaseParams.with() .useCase(case_) .build() workflowService.deleteCase(deleteCaseParams) @@ -386,7 +386,7 @@ class TaskAuthorizationServiceTest { void testCanFinish() { ProcessRole positiveRole = this.netWithUserRefs.getRoles().values().find(v -> v.getImportId() == "finish_pos_role") userService.addRole(testUser, positiveRole.getStringId()) - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(netWithUserRefs) .title("Test Finish") .color("") @@ -395,14 +395,14 @@ class TaskAuthorizationServiceTest { Case case_ = workflowService.createCase(createCaseParams).getCase() String taskId = case_.getTaskStringId("1") - TaskParams taskParams = TaskParams.builder() + TaskParams taskParams = TaskParams.with() .taskId(taskId) .user(testUser) .build() taskService.assignTask(taskParams) assert taskAuthorizationService.canCallFinish(testUser.transformToLoggedUser(), taskId) userService.removeRole(testUser, positiveRole.getStringId()) - DeleteCaseParams deleteCaseParams = DeleteCaseParams.builder() + DeleteCaseParams deleteCaseParams = DeleteCaseParams.with() .useCase(case_) .build() workflowService.deleteCase(deleteCaseParams) @@ -412,7 +412,7 @@ class TaskAuthorizationServiceTest { void testCanNotFinish() { ProcessRole negativeRole = this.netWithUserRefs.getRoles().values().find(v -> v.getImportId() == "finish_neg_role") userService.addRole(testUser, negativeRole.getStringId()) - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(netWithUserRefs) .title("Test Finish") .color("") @@ -421,14 +421,14 @@ class TaskAuthorizationServiceTest { Case case_ = workflowService.createCase(createCaseParams).getCase() String taskId = case_.getTaskStringId("1") - TaskParams taskParams = TaskParams.builder() + TaskParams taskParams = TaskParams.with() .taskId(taskId) .user(testUser) .build() taskService.assignTask(taskParams) assert !taskAuthorizationService.canCallFinish(testUser.transformToLoggedUser(), taskId) userService.removeRole(testUser, negativeRole.getStringId()) - DeleteCaseParams deleteCaseParams = DeleteCaseParams.builder() + DeleteCaseParams deleteCaseParams = DeleteCaseParams.with() .useCase(case_) .build() workflowService.deleteCase(deleteCaseParams) @@ -436,7 +436,7 @@ class TaskAuthorizationServiceTest { @Test void testCanFinishWithUsersRef() { - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(netWithUserRefs) .title("Test Finish") .color("") @@ -449,13 +449,13 @@ class TaskAuthorizationServiceTest { ] as Map<String, Field<?>>), superCreator.getSuperUser())).getCase() sleep(4000) - TaskParams taskParams = TaskParams.builder() + TaskParams taskParams = TaskParams.with() .taskId(taskId) .user(testUser) .build() taskService.assignTask(taskParams) assert taskAuthorizationService.canCallFinish(testUser.transformToLoggedUser(), taskId) - DeleteCaseParams deleteCaseParams = DeleteCaseParams.builder() + DeleteCaseParams deleteCaseParams = DeleteCaseParams.with() .useCase(case_) .build() workflowService.deleteCase(deleteCaseParams) @@ -463,7 +463,7 @@ class TaskAuthorizationServiceTest { @Test void testCannotFinishWithUsersRef() { - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(netWithUserRefs) .title("Test Finish") .color("") @@ -476,13 +476,13 @@ class TaskAuthorizationServiceTest { ] as Map<String, Field<?>>), superCreator.getSuperUser())).getCase() sleep(4000) - TaskParams taskParams = TaskParams.builder() + TaskParams taskParams = TaskParams.with() .taskId(taskId) .user(testUser) .build() taskService.assignTask(taskParams) assert !taskAuthorizationService.canCallFinish(testUser.transformToLoggedUser(), taskId) - DeleteCaseParams deleteCaseParams = DeleteCaseParams.builder() + DeleteCaseParams deleteCaseParams = DeleteCaseParams.with() .useCase(case_) .build() workflowService.deleteCase(deleteCaseParams) @@ -492,7 +492,7 @@ class TaskAuthorizationServiceTest { void testCanFinishWithNegRoleAndPosUsersRef() { ProcessRole positiveRole = this.netWithUserRefs.getRoles().values().find(v -> v.getImportId() == "finish_pos_role") userService.addRole(testUser, positiveRole.getStringId()) - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(netWithUserRefs) .title("Test Finish") .color("") @@ -505,14 +505,14 @@ class TaskAuthorizationServiceTest { ] as Map<String, Field<?>>), superCreator.getSuperUser())).getCase() sleep(4000) - TaskParams taskParams = TaskParams.builder() + TaskParams taskParams = TaskParams.with() .taskId(taskId) .user(testUser) .build() taskService.assignTask(taskParams) assert taskAuthorizationService.canCallFinish(testUser.transformToLoggedUser(), taskId) userService.removeRole(testUser, positiveRole.getStringId()) - DeleteCaseParams deleteCaseParams = DeleteCaseParams.builder() + DeleteCaseParams deleteCaseParams = DeleteCaseParams.with() .useCase(case_) .build() workflowService.deleteCase(deleteCaseParams) diff --git a/src/test/groovy/com/netgrif/application/engine/auth/WorkflowAuthorizationServiceTest.groovy b/src/test/groovy/com/netgrif/application/engine/auth/WorkflowAuthorizationServiceTest.groovy index 1a40b3b8e05..6b66add2265 100644 --- a/src/test/groovy/com/netgrif/application/engine/auth/WorkflowAuthorizationServiceTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/auth/WorkflowAuthorizationServiceTest.groovy @@ -173,7 +173,7 @@ class WorkflowAuthorizationServiceTest { void testCanCallDelete() { ProcessRole positiveDeleteRole = this.net.getRoles().values().find(v -> v.getImportId() == "delete_pos_role") userService.addRole(testUser, positiveDeleteRole.getStringId()) - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(net) .title("Test delete") .color("") @@ -196,7 +196,7 @@ class WorkflowAuthorizationServiceTest { void testCanCallDeleteFalse() { ProcessRole deleteRole = this.net.getRoles().values().find(v -> v.getImportId() == "delete_neg_role") userService.addRole(testUser, deleteRole.getStringId()) - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(net) .title("Test delete") .color("") @@ -216,7 +216,7 @@ class WorkflowAuthorizationServiceTest { userService.addRole(testUser, posDeleteRole.getStringId()) userService.addRole(testUser, negDeleteRole.getStringId()) - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(netWithUserRefs) .title("Test delete") .color("") @@ -243,7 +243,7 @@ class WorkflowAuthorizationServiceTest { userService.addRole(testUser, posDeleteRole.getStringId()) userService.addRole(testUser, negDeleteRole.getStringId()) - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(netWithUserRefs) .title("Test delete") .color("") diff --git a/src/test/groovy/com/netgrif/application/engine/elastic/ReindexTest.groovy b/src/test/groovy/com/netgrif/application/engine/elastic/ReindexTest.groovy index 6e3ce61a4f0..63ef323217f 100644 --- a/src/test/groovy/com/netgrif/application/engine/elastic/ReindexTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/elastic/ReindexTest.groovy @@ -58,7 +58,7 @@ class ReindexTest { int countTread = Thread.activeCount() List<Thread> threads = [] List<Case> savedCase = [] - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(net.getNet()) .title("Test") .color("color") diff --git a/src/test/groovy/com/netgrif/application/engine/history/HistoryServiceTest.groovy b/src/test/groovy/com/netgrif/application/engine/history/HistoryServiceTest.groovy index d69beee2719..9261d4b60d4 100644 --- a/src/test/groovy/com/netgrif/application/engine/history/HistoryServiceTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/history/HistoryServiceTest.groovy @@ -69,7 +69,7 @@ class HistoryServiceTest { @Test void findAllAssignTaskEventLogsByCaseIdTest() { - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(net) .title("Test assign") .color("") @@ -86,7 +86,7 @@ class HistoryServiceTest { @Test void findAllFinishTaskEventLogsByCaseId() { - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(net) .title("Test finish") .color("") @@ -105,7 +105,7 @@ class HistoryServiceTest { @Test void findAllSetDataEventLogsByCaseId() { - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(net) .title("Test set data") .color("") diff --git a/src/test/groovy/com/netgrif/application/engine/impersonation/ImpersonationServiceTest.groovy b/src/test/groovy/com/netgrif/application/engine/impersonation/ImpersonationServiceTest.groovy index 5d30763d034..8e25ee82ab4 100644 --- a/src/test/groovy/com/netgrif/application/engine/impersonation/ImpersonationServiceTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/impersonation/ImpersonationServiceTest.groovy @@ -219,7 +219,7 @@ class ImpersonationServiceTest { assert tasks.content[0].stringId == testTask1.stringId assert taskAuthorizationService.canCallAssign(userService.loggedUserFromContext, testTask1.stringId) - TaskParams taskParams = TaskParams.builder() + TaskParams taskParams = TaskParams.with() .taskId(testTask1.stringId) .user(userService.loggedUser) .build() @@ -231,7 +231,7 @@ class ImpersonationServiceTest { assert taskAuthorizationService.canCallSaveFile(userService.loggedUserFromContext, testTask1.stringId) assert taskAuthorizationService.canCallFinish(userService.loggedUserFromContext, testTask1.stringId) - taskParams = TaskParams.builder() + taskParams = TaskParams.with() .taskId(testTask1.stringId) .user(userService.loggedUser) .build() @@ -326,12 +326,12 @@ class ImpersonationServiceTest { ((MultichoiceMapField) caze.dataSet.get("impersonated_authorities")).options = (caze.dataSet.get("impersonated_authorities").rawValue as List).collectEntries { [(it): new I18nString(it as String)] } as Map<String, I18nString> caze = workflowService.save(caze) def initTask = caze.getTaskStringId("t2") - TaskParams taskParams = TaskParams.builder() + TaskParams taskParams = TaskParams.with() .taskId(initTask) .user(userService.system) .build() taskService.assignTask(taskParams) - taskParams = TaskParams.builder() + taskParams = TaskParams.with() .taskId(initTask) .user(userService.system) .build() diff --git a/src/test/groovy/com/netgrif/application/engine/importer/PredefinedRolesPermissionsTest.groovy b/src/test/groovy/com/netgrif/application/engine/importer/PredefinedRolesPermissionsTest.groovy index 108ce121a15..f271067fa15 100644 --- a/src/test/groovy/com/netgrif/application/engine/importer/PredefinedRolesPermissionsTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/importer/PredefinedRolesPermissionsTest.groovy @@ -459,7 +459,7 @@ class PredefinedRolesPermissionsTest { PetriNet net = importOutcome.getNet() - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(net) .title("") .color("") diff --git a/src/test/groovy/com/netgrif/application/engine/insurance/EncryptionTest.groovy b/src/test/groovy/com/netgrif/application/engine/insurance/EncryptionTest.groovy index c416d86a4cc..d60d3e070f3 100644 --- a/src/test/groovy/com/netgrif/application/engine/insurance/EncryptionTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/insurance/EncryptionTest.groovy @@ -87,7 +87,7 @@ class EncryptionTest { ImportPetriNetEventOutcome net = petriNetService.importPetriNet(new ImportPetriNetParams( new FileInputStream("src/test/resources/mapping_test.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())) assert net.getNet() != null - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(net.getNet()) .title("Encryption test") .color("color") diff --git a/src/test/groovy/com/netgrif/application/engine/permissions/ElasticSearchViewPermissionTest.groovy b/src/test/groovy/com/netgrif/application/engine/permissions/ElasticSearchViewPermissionTest.groovy index b214b8dba52..cb62cbaa518 100644 --- a/src/test/groovy/com/netgrif/application/engine/permissions/ElasticSearchViewPermissionTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/permissions/ElasticSearchViewPermissionTest.groovy @@ -106,7 +106,7 @@ class ElasticSearchViewPermissionTest { @Test void testSearchElasticViewWithUserWithoutRole() { - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(net) .title("Permission test") .color("") @@ -119,7 +119,7 @@ class ElasticSearchViewPermissionTest { Page<Case> casePage = elasticCaseService.search([caseSearchRequest] as List, testUser.transformToLoggedUser(), PageRequest.of(0, 20), LocaleContextHolder.getLocale(), false) assert casePage.getContent().size() == 0 - DeleteCaseParams deleteCaseParams = DeleteCaseParams.builder() + DeleteCaseParams deleteCaseParams = DeleteCaseParams.with() .useCase(case_) .build() workflowService.deleteCase(deleteCaseParams) @@ -127,7 +127,7 @@ class ElasticSearchViewPermissionTest { @Test void testSearchElasticViewWithUserWithPosRole() { - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(net) .title("Permission test") .color("") @@ -146,7 +146,7 @@ class ElasticSearchViewPermissionTest { assert casePage.getContent().size() == 1 assert casePage.getContent()[0].stringId == case_.stringId userService.removeRole(testUser, posViewRole.getStringId()) - DeleteCaseParams deleteCaseParams = DeleteCaseParams.builder() + DeleteCaseParams deleteCaseParams = DeleteCaseParams.with() .useCase(case_) .build() workflowService.deleteCase(deleteCaseParams) @@ -154,7 +154,7 @@ class ElasticSearchViewPermissionTest { @Test void testSearchElasticViewWithUserWithNegRole() { - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(net) .title("Permission test") .color("") @@ -170,7 +170,7 @@ class ElasticSearchViewPermissionTest { assert casePage.getContent().size() == 0 && case_.negativeViewRoles.contains(negViewRole.stringId) userService.removeRole(testUser, negViewRole.getStringId()) - DeleteCaseParams deleteCaseParams = DeleteCaseParams.builder() + DeleteCaseParams deleteCaseParams = DeleteCaseParams.with() .useCase(case_) .build() workflowService.deleteCase(deleteCaseParams) @@ -178,7 +178,7 @@ class ElasticSearchViewPermissionTest { @Test void testSearchElasticViewWithUserWithoutUserRef() { - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(netWithUserRefs) .title("Permission test") .color("") @@ -191,7 +191,7 @@ class ElasticSearchViewPermissionTest { Page<Case> casePage = elasticCaseService.search([caseSearchRequest] as List, testUser.transformToLoggedUser(), PageRequest.of(0, 20), LocaleContextHolder.getLocale(), false) assert casePage.getContent().size() == 0 - DeleteCaseParams deleteCaseParams = DeleteCaseParams.builder() + DeleteCaseParams deleteCaseParams = DeleteCaseParams.with() .useCase(case_) .build() workflowService.deleteCase(deleteCaseParams) @@ -199,7 +199,7 @@ class ElasticSearchViewPermissionTest { @Test void testSearchElasticViewWithUserWithPosUserRef() { - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(netWithUserRefs) .title("Permission test") .color("") @@ -218,7 +218,7 @@ class ElasticSearchViewPermissionTest { Page<Case> casePage = elasticCaseService.search([caseSearchRequest] as List, testUser.transformToLoggedUser(), PageRequest.of(0, 20), LocaleContextHolder.getLocale(), false) assert casePage.getContent().size() == 1 && casePage.getContent()[0].stringId == case_.stringId && case_.viewUsers.contains(testUser.getStringId()) - DeleteCaseParams deleteCaseParams = DeleteCaseParams.builder() + DeleteCaseParams deleteCaseParams = DeleteCaseParams.with() .useCase(case_) .build() workflowService.deleteCase(deleteCaseParams) @@ -226,7 +226,7 @@ class ElasticSearchViewPermissionTest { @Test void testSearchElasticViewWithUserWithNegUserRef() { - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(netWithUserRefs) .title("Permission test") .color("") @@ -245,7 +245,7 @@ class ElasticSearchViewPermissionTest { Page<Case> casePage = elasticCaseService.search([caseSearchRequest] as List, testUser.transformToLoggedUser(), PageRequest.of(0, 20), LocaleContextHolder.getLocale(), false) assert casePage.getContent().size() == 0 && case_.negativeViewUsers.contains(testUser.getStringId()) - DeleteCaseParams deleteCaseParams = DeleteCaseParams.builder() + DeleteCaseParams deleteCaseParams = DeleteCaseParams.with() .useCase(case_) .build() workflowService.deleteCase(deleteCaseParams) @@ -253,7 +253,7 @@ class ElasticSearchViewPermissionTest { @Test void testSearchElasticViewWithUserWithNegativeRoleAndPosUserRef() { - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(netWithUserRefs) .title("Permission test") .color("") @@ -275,7 +275,7 @@ class ElasticSearchViewPermissionTest { assert casePage.getContent().size() == 1 && case_.viewUsers.contains(testUser.stringId) userService.removeRole(testUser, negViewRole.getStringId()) - DeleteCaseParams deleteCaseParams = DeleteCaseParams.builder() + DeleteCaseParams deleteCaseParams = DeleteCaseParams.with() .useCase(case_) .build() workflowService.deleteCase(deleteCaseParams) diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/FunctionsTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/FunctionsTest.groovy index bea0d8baae0..d8970aa8b81 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/FunctionsTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/FunctionsTest.groovy @@ -100,7 +100,7 @@ class FunctionsTest { assert functionResNet assert functionTestNet - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(functionTestNet) .title("Test") .color("") @@ -127,7 +127,7 @@ class FunctionsTest { assert functionResNet assert functionTestNet - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(functionTestNet) .title("Test") .color("") @@ -165,7 +165,7 @@ class FunctionsTest { functionTestNetResource.inputStream, VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser())).getNet() assert functionTestNet - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(functionTestNet) .title("Test") .color("") @@ -191,7 +191,7 @@ class FunctionsTest { functionTestNetResource.inputStream, VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser())).getNet() assert functionTestNet - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(functionTestNet) .title("Test") .color("") @@ -217,7 +217,7 @@ class FunctionsTest { functionTestNetResource.inputStream, VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser())).getNet() assert functionTestNet - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(functionTestNet) .title("Test") .color("") @@ -239,7 +239,7 @@ class FunctionsTest { assert functionResNet assert functionTestNet - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(functionTestNet) .title("Test") .color("") @@ -278,7 +278,7 @@ class FunctionsTest { def functionTestV2Net = petriNetService.importPetriNet(new ImportPetriNetParams( functionTestNetResourceV2.inputStream, VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser())).getNet() - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(functionTestV2Net) .title("Test") .color("") @@ -316,7 +316,7 @@ class FunctionsTest { resource.inputStream, VersionType.MAJOR, userService.getLoggedOrSystem().transformToLoggedUser())).getNet() assert petriNet - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(petriNet) .title("Test") .color("") diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/ImporterTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/ImporterTest.groovy index aa5441a8338..7b20da328c0 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/ImporterTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/ImporterTest.groovy @@ -296,7 +296,7 @@ class ImporterTest { new ClassPathResource("/this_kw_test.xml").getInputStream(), VersionType.MAJOR, superCreator.getLoggedSuper())).getNet() assert net != null - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(net) .title("Test case") .color("") @@ -315,7 +315,7 @@ class ImporterTest { new ClassPathResource("/initial_behavior.xml").getInputStream(), VersionType.MAJOR, superCreator.getLoggedSuper())).getNet() assert net - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(net) .title("Test case") .color("") diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicCaseNameTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicCaseNameTest.groovy index 335441548d7..336efff5bc4 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicCaseNameTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicCaseNameTest.groovy @@ -43,7 +43,7 @@ class DynamicCaseNameTest { void testInitValues() { ImportPetriNetEventOutcome optNet = petriNetService.importPetriNet(new ImportPetriNetParams( new FileInputStream("src/test/resources/petriNets/dynamic_case_name_test.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())) - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(optNet.getNet()) .title(null) .color("") @@ -53,7 +53,7 @@ class DynamicCaseNameTest { Case useCase = workflowService.createCase(createCaseParams).getCase() assert useCase.title == "SK text value 6" - CreateCaseParams createCaseParams2 = CreateCaseParams.builder() + CreateCaseParams createCaseParams2 = CreateCaseParams.with() .petriNet(optNet.getNet()) .title(null) .color("") diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/FileFieldTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/FileFieldTest.groovy index dfdf90579bd..0bd24cdc787 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/FileFieldTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/FileFieldTest.groovy @@ -107,7 +107,7 @@ class FileFieldTest { IUser user = userService.findByEmail(configuration.email, true) assert user != null - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(net) .title("Test file download") .color("black") @@ -133,7 +133,7 @@ class FileFieldTest { IUser user = userService.findByEmail(configuration.email, true) assert user != null - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(net) .title("Test file download") .color("black") diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/FileListFieldTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/FileListFieldTest.groovy index e3174cff097..ad55b548b88 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/FileListFieldTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/FileListFieldTest.groovy @@ -107,7 +107,7 @@ class FileListFieldTest { IUser user = userService.findByEmail(configuration.email, true) assert user != null - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(net) .title("Test file from file list download") .color("black") @@ -134,7 +134,7 @@ class FileListFieldTest { IUser user = userService.findByEmail(configuration.email, true) assert user != null - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(net) .title("Test file from file list download") .color("black") diff --git a/src/test/groovy/com/netgrif/application/engine/workflow/NewInitTest.groovy b/src/test/groovy/com/netgrif/application/engine/workflow/NewInitTest.groovy index 6537499e521..062ed9d3dee 100644 --- a/src/test/groovy/com/netgrif/application/engine/workflow/NewInitTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/workflow/NewInitTest.groovy @@ -49,7 +49,7 @@ class NewInitTest { void newInitTest() throws IOException, MissingIconKeyException, MissingPetriNetMetaDataException { petriNetService.importPetriNet(new ImportPetriNetParams( new FileInputStream("src/test/resources/petriNets/nae_1276_Init_value_as_choice.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())) - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(petriNetService.getNewestVersionByIdentifier("new_init_test")) .title("New init test") .color("") diff --git a/src/test/groovy/com/netgrif/application/engine/workflow/TaskStateTest.groovy b/src/test/groovy/com/netgrif/application/engine/workflow/TaskStateTest.groovy index 6d68e3f7668..d7b8f0aea49 100644 --- a/src/test/groovy/com/netgrif/application/engine/workflow/TaskStateTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/workflow/TaskStateTest.groovy @@ -53,7 +53,7 @@ class TaskStateTest { assert netOptional.isPresent() PetriNet net = netOptional.get() - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(net) .title("Test Case") .color("") @@ -74,7 +74,7 @@ class TaskStateTest { assert netOptional.isPresent() PetriNet net = netOptional.get() - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(net) .title("Test Case") .color("") diff --git a/src/test/java/com/netgrif/application/engine/importer/ImporterTest.java b/src/test/java/com/netgrif/application/engine/importer/ImporterTest.java index 3342630702a..afae222b207 100644 --- a/src/test/java/com/netgrif/application/engine/importer/ImporterTest.java +++ b/src/test/java/com/netgrif/application/engine/importer/ImporterTest.java @@ -77,7 +77,7 @@ public void priorityTest() throws MissingPetriNetMetaDataException, IOException, new FileInputStream("src/test/resources/priority_test.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())); assert outcome.getNet() != null; - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(outcome.getNet()) .title(outcome.getNet().getTitle().getDefaultValue()) .color("color") diff --git a/src/test/java/com/netgrif/application/engine/rules/service/RuleEngineTest.java b/src/test/java/com/netgrif/application/engine/rules/service/RuleEngineTest.java index dc06a2375b1..c5f4bfdf579 100644 --- a/src/test/java/com/netgrif/application/engine/rules/service/RuleEngineTest.java +++ b/src/test/java/com/netgrif/application/engine/rules/service/RuleEngineTest.java @@ -202,7 +202,7 @@ void testTransitionRules() throws IOException, MissingPetriNetMetaDataException, ruleRepository.save(rule3); ruleRepository.save(rule4); - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(outcome.getNet()) .title("Original title") .color("original color") @@ -387,7 +387,7 @@ private StoredRule rule(String when, String then) { private Case newCase() throws IOException, MissingPetriNetMetaDataException, MissingIconKeyException { ImportPetriNetEventOutcome outcome = petriNetService.importPetriNet(new ImportPetriNetParams( new FileInputStream("src/test/resources/rule_engine_test.xml"), VersionType.MAJOR, superUser)); - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(outcome.getNet()) .title("Original title") .color("original color") diff --git a/src/test/java/com/netgrif/application/engine/rules/service/RuleEvaluationScheduleServiceTest.java b/src/test/java/com/netgrif/application/engine/rules/service/RuleEvaluationScheduleServiceTest.java index a8e85ccda65..73f7b2a9b29 100644 --- a/src/test/java/com/netgrif/application/engine/rules/service/RuleEvaluationScheduleServiceTest.java +++ b/src/test/java/com/netgrif/application/engine/rules/service/RuleEvaluationScheduleServiceTest.java @@ -81,7 +81,7 @@ void testScheduledRule() throws IOException, MissingPetriNetMetaDataException, R .build(); ruleRepository.save(rule); - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(importOutcome.getNet()) .title("Original title") .color("original color") diff --git a/src/test/java/com/netgrif/application/engine/workflow/service/TaskServiceTest.java b/src/test/java/com/netgrif/application/engine/workflow/service/TaskServiceTest.java index 176a3341bf9..623fe0e61c2 100644 --- a/src/test/java/com/netgrif/application/engine/workflow/service/TaskServiceTest.java +++ b/src/test/java/com/netgrif/application/engine/workflow/service/TaskServiceTest.java @@ -95,7 +95,7 @@ public void setUp() throws Exception { petriNetService.importPetriNet(new ImportPetriNetParams( new FileInputStream("src/test/resources/prikladFM.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())); PetriNet net = petriNetRepository.findAll().get(0); - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(net) .title("Storage Unit") .color("color") @@ -109,7 +109,7 @@ public void resetArcTest() throws TransitionNotExecutableException, MissingPetri PetriNet net = petriNetService.importPetriNet(new ImportPetriNetParams( new FileInputStream("src/test/resources/reset_inhibitor_test.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())).getNet(); LoggedUser loggedUser = mockLoggedUser(); - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(net) .title("Reset test") .color("color") diff --git a/src/test/java/com/netgrif/application/engine/workflow/web/VariableArcsTest.java b/src/test/java/com/netgrif/application/engine/workflow/web/VariableArcsTest.java index 27e7794a457..fea7316ee44 100644 --- a/src/test/java/com/netgrif/application/engine/workflow/web/VariableArcsTest.java +++ b/src/test/java/com/netgrif/application/engine/workflow/web/VariableArcsTest.java @@ -128,7 +128,7 @@ public void importTest() throws MissingIconKeyException { List<Arc> arcs = this.loaded.getArcs().values().stream().flatMap(List::stream).collect(Collectors.toList()); assert !arcs.isEmpty(); - CreateCaseParams createCaseParams = CreateCaseParams.builder() + CreateCaseParams createCaseParams = CreateCaseParams.with() .petriNet(this.loaded) .title("VARTEST") .color("red") @@ -157,7 +157,7 @@ public void finishTasksTest() throws TransitionNotExecutableException { private void assertInhibArcsFinishTask(List<TaskReference> tasks) throws TransitionNotExecutableException { for (TaskReference taskRef : tasks) { Task task = taskService.findOne(taskRef.getStringId()); - TaskParams taskParams = TaskParams.builder() + TaskParams taskParams = TaskParams.with() .task(task) .user(testUser) .build(); @@ -165,7 +165,7 @@ private void assertInhibArcsFinishTask(List<TaskReference> tasks) throws Transit finishCase = workflowService.findOne(task.getCaseId()); assert !finishCase.getActivePlaces().containsKey(task.getTitle().getDefaultValue() + "_start") && !finishCase.getActivePlaces().containsKey(task.getTitle().getDefaultValue() + "_res"); - taskParams = TaskParams.builder() + taskParams = TaskParams.with() .task(task) .user(testUser) .build(); @@ -180,7 +180,7 @@ private void assertReadArcsFinishTask(List<TaskReference> tasks) throws Transiti for (TaskReference taskRef : tasks) { Task task = taskService.findOne(taskRef.getStringId()); int markingBeforeAssign = finishCase.getActivePlaces().get(task.getTitle().getDefaultValue() + "_start"); - TaskParams taskParams = TaskParams.builder() + TaskParams taskParams = TaskParams.with() .task(task) .user(testUser) .build(); @@ -189,7 +189,7 @@ private void assertReadArcsFinishTask(List<TaskReference> tasks) throws Transiti assert markingBeforeAssign == finishCase.getActivePlaces().get(task.getTitle().getDefaultValue() + "_start"); - taskParams = TaskParams.builder() + taskParams = TaskParams.with() .task(task) .user(testUser) .build(); @@ -205,7 +205,7 @@ private void assertFinishTasks(String arcType, List<TaskReference> tasks) throws List<TaskReference> filteredTasks = tasks.stream().filter(task -> task.getTitle().contains(arcType)).collect(Collectors.toList()); for (TaskReference taskRef : filteredTasks) { Task task = taskService.findOne(taskRef.getStringId()); - TaskParams taskParams = TaskParams.builder() + TaskParams taskParams = TaskParams.with() .task(task) .user(testUser) .build(); @@ -215,7 +215,7 @@ private void assertFinishTasks(String arcType, List<TaskReference> tasks) throws // TODO: release/8.0.0 assert !finishCase.getActivePlaces().containsKey(task.getTitle().getDefaultValue() + "_start"); - taskParams = TaskParams.builder() + taskParams = TaskParams.with() .task(task) .user(testUser) .build(); @@ -231,7 +231,7 @@ private void assertOutArcsFinishTasks(List<TaskReference> tasks) throws Transiti List<TaskReference> filteredTasks = tasks.stream().filter(task -> task.getTitle().equals("var_arc_out") || task.getTitle().equals("place_var_arc_out")).collect(Collectors.toList()); for (TaskReference taskRef : filteredTasks) { Task task = taskService.findOne(taskRef.getStringId()); - TaskParams taskParams = TaskParams.builder() + TaskParams taskParams = TaskParams.with() .task(task) .user(testUser) .build(); @@ -240,7 +240,7 @@ private void assertOutArcsFinishTasks(List<TaskReference> tasks) throws Transiti assert !finishCase.getActivePlaces().containsKey(task.getTitle().getDefaultValue() + "_end"); - taskParams = TaskParams.builder() + taskParams = TaskParams.with() .task(task) .user(testUser) .build(); @@ -280,7 +280,7 @@ private void assertCancelTasks(String arcType, List<TaskReference> tasks) throws if (!arcType.equals("inhib")) { tokensBeforeAssign = cancelCase.getActivePlaces().get(task.getTitle().getDefaultValue() + "_start"); } - TaskParams taskParams = TaskParams.builder() + TaskParams taskParams = TaskParams.with() .task(task) .user(testUser) .build(); @@ -302,19 +302,19 @@ private void assertCancelTasks(String arcType, List<TaskReference> tasks) throws if (task.getTitle().getDefaultValue().contains("ref")) { QTask qTask = new QTask("task"); Task addTokensTask = taskService.searchOne(qTask.transitionId.eq("add_tokens").and(qTask.caseId.eq(cancelCase.getStringId()))); - taskParams = TaskParams.builder() + taskParams = TaskParams.with() .task(addTokensTask) .user(testUser) .build(); taskService.assignTask(taskParams); - taskParams = TaskParams.builder() + taskParams = TaskParams.with() .task(addTokensTask) .user(testUser) .build(); taskService.finishTask(taskParams); } int tokensAfterCancel = 0; - taskParams = TaskParams.builder() + taskParams = TaskParams.with() .task(task) .user(testUser) .build(); @@ -339,12 +339,12 @@ private void assertCancelTasks(String arcType, List<TaskReference> tasks) throws if (task.getTitle().getDefaultValue().contains("ref")) { QTask qTask = new QTask("task"); Task removeTokensTask = taskService.searchOne(qTask.transitionId.eq("remove_tokens").and(qTask.caseId.eq(cancelCase.getStringId()))); - taskParams = TaskParams.builder() + taskParams = TaskParams.with() .task(removeTokensTask) .user(testUser) .build(); taskService.assignTask(taskParams); - taskParams = TaskParams.builder() + taskParams = TaskParams.with() .task(removeTokensTask) .user(testUser) .build(); @@ -358,7 +358,7 @@ private void assertOutArcsCancelTasks(List<TaskReference> tasks) throws Transiti List<TaskReference> filteredTasks = tasks.stream().filter(task -> task.getTitle().equals("var_arc_out") || task.getTitle().equals("place_var_arc_out")).collect(Collectors.toList()); for (TaskReference taskRef : filteredTasks) { Task task = taskService.findOne(taskRef.getStringId()); - TaskParams taskParams = TaskParams.builder() + TaskParams taskParams = TaskParams.with() .task(task) .user(testUser) .build(); @@ -367,7 +367,7 @@ private void assertOutArcsCancelTasks(List<TaskReference> tasks) throws Transiti assert !cancelCase.getActivePlaces().containsKey(task.getTitle().getDefaultValue() + "_end"); - taskParams = TaskParams.builder() + taskParams = TaskParams.with() .task(task) .user(testUser) .build(); diff --git a/src/test/resources/change_caseref_value_action_test.xml b/src/test/resources/change_caseref_value_action_test.xml index 74ab34a4cf2..42aaa73ffeb 100644 --- a/src/test/resources/change_caseref_value_action_test.xml +++ b/src/test/resources/change_caseref_value_action_test.xml @@ -30,7 +30,7 @@ <!-- @formatter:off --> caseref: f.caseref; def net = petriNetService.getNewestVersionByIdentifier("change_value") - def createCaseParams = CreateCaseParams.builder() + def createCaseParams = CreateCaseParams.with() .petriNet(net) .title("") .color("") @@ -50,7 +50,7 @@ <!-- @formatter:off --> caseref: f.caseref; def net = petriNetService.getNewestVersionByIdentifier("test") - def createCaseParams = CreateCaseParams.builder() + def createCaseParams = CreateCaseParams.with() .petriNet(net) .title("") .color("") From dd7060eec40d3fdc9b860a29318c080d1efc03a3 Mon Sep 17 00:00:00 2001 From: chvostek <chvostek@netgrif.com> Date: Fri, 9 Aug 2024 10:03:54 +0200 Subject: [PATCH 34/48] [NAE-1998] Implement transactions for events - change builder() to with() - remove disabled test --- .../workflow/WorkflowServiceTest.groovy | 49 ++----------------- 1 file changed, 4 insertions(+), 45 deletions(-) diff --git a/src/test/groovy/com/netgrif/application/engine/workflow/WorkflowServiceTest.groovy b/src/test/groovy/com/netgrif/application/engine/workflow/WorkflowServiceTest.groovy index df9664ed83d..44611fd60a9 100644 --- a/src/test/groovy/com/netgrif/application/engine/workflow/WorkflowServiceTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/workflow/WorkflowServiceTest.groovy @@ -59,47 +59,6 @@ class WorkflowServiceTest { testHelper.truncateDbs() } - @Test - @Disabled - // todo remove - void testblabla() { - def testNetWithTriggers = petriNetService.importPetriNet(new ImportPetriNetParams( - stream("petriNets/test_with_triggers.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())).getNet() - def testNet = petriNetService.importPetriNet(new ImportPetriNetParams( - stream("petriNets/test_without_triggers.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())).getNet() - - int iterations = 200 - def paramsWithoutTrigger = builder() - .petriNet(testNet) - .loggedUser(superCreator.getLoggedSuper()) - .build() - def paramsWithTrigger = builder() - .petriNet(testNetWithTriggers) - .loggedUser(superCreator.getLoggedSuper()) - .build() - - long totalWithoutTriggers = 0 - (0..iterations).each { - Date startTime = new Date() - workflowService.createCase(paramsWithoutTrigger) - Date endTime = new Date() - TimeDuration elapsedTimeTransactional = TimeCategory.minus( endTime, startTime ) - totalWithoutTriggers += elapsedTimeTransactional.toMilliseconds() - } - - long totalWithTriggers = 0 - (0..iterations).each { - Date startTime = new Date() - workflowService.createCase(paramsWithTrigger) - Date endTime = new Date() - TimeDuration elapsedTimeTransactional = TimeCategory.minus( endTime, startTime ) - totalWithTriggers += elapsedTimeTransactional.toMilliseconds() - } - - println("AVG without triggers for 1 create case: " + totalWithoutTriggers / iterations + "ms") - println("AVG with triggers for 1 create case: " + totalWithTriggers / iterations + "ms") - } - @Test void testFindOneImmediateData() { def testNet = petriNetService.importPetriNet(new ImportPetriNetParams( @@ -122,7 +81,7 @@ class WorkflowServiceTest { assert testNet def net = testNet - CreateCaseParams createCaseParams = builder() + CreateCaseParams createCaseParams = with() .petriNet(net) .title("autoErr") .color("red") @@ -141,7 +100,7 @@ class WorkflowServiceTest { def net = petriNetService.importPetriNet(new ImportPetriNetParams( stream(SECOND_AUTO_NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper())).getNet() - CreateCaseParams createCaseParams = builder() + CreateCaseParams createCaseParams = with() .petriNet(net) .title("autoErr") .color("red") @@ -165,7 +124,7 @@ class WorkflowServiceTest { assert testNet.getNet() != null def net = testNet.getNet() - CreateCaseParams createCaseParams = builder() + CreateCaseParams createCaseParams = with() .petriNet(net) .title(null) .color(null) @@ -177,7 +136,7 @@ class WorkflowServiceTest { assert aCase.title == "Slovenský preklad" assert workflowService.findOne(aCase.stringId).uriNodeId == net.uriNodeId - createCaseParams = builder() + createCaseParams = with() .petriNet(net) .title(null) .color(null) From 4f9e4a6f22c2233e196d2212f7646fc9d3f8b932 Mon Sep 17 00:00:00 2001 From: chvostek <chvostek@netgrif.com> Date: Fri, 9 Aug 2024 14:26:25 +0200 Subject: [PATCH 35/48] [NAE-1998] Implement transactions for events - add javadoc --- .../petrinet/service/PetriNetService.java | 19 ++- .../domain/params/CreateCaseParams.java | 13 +- .../domain/params/DeleteCaseParams.java | 10 +- .../engine/workflow/service/DataService.java | 15 ++- .../engine/workflow/service/TaskService.java | 120 ++++++++++++++---- .../workflow/service/WorkflowService.java | 38 ++++-- 6 files changed, 156 insertions(+), 59 deletions(-) diff --git a/src/main/java/com/netgrif/application/engine/petrinet/service/PetriNetService.java b/src/main/java/com/netgrif/application/engine/petrinet/service/PetriNetService.java index 58414e78a6a..b4f3abcac74 100644 --- a/src/main/java/com/netgrif/application/engine/petrinet/service/PetriNetService.java +++ b/src/main/java/com/netgrif/application/engine/petrinet/service/PetriNetService.java @@ -179,7 +179,18 @@ public PetriNet clone(ObjectId petriNetId) { } /** - * todo javadoc + * Creates {@link PetriNet} and saves it into database. + * + * @param importPetriNetParams parameters for PetriNet creation + * <br> + * <b>Required parameters</b> + * <ul> + * <li>xmlFile</li> + * <li>releaseType</li> + * <li>author</li> + * </ul> + * + * @return outcome containing the created PetriNet * */ @Override public ImportPetriNetEventOutcome importPetriNet(ImportPetriNetParams importPetriNetParams) throws IOException, @@ -209,7 +220,8 @@ public ImportPetriNetEventOutcome importPetriNet(ImportPetriNetParams importPetr log.info("Petri net {} ({} v{}) imported successfully and saved in a folder: {}", net.getTitle(), net.getInitials(), net.getVersion(), savedPath.toString()); - outcome.setOutcomes(eventService.runActions(net.getPreUploadActions(), null, Optional.empty(), importPetriNetParams.getParams())); + outcome.setOutcomes(eventService.runActions(net.getPreUploadActions(), null, Optional.empty(), + importPetriNetParams.getParams())); boolean wasSaved = evaluateRules(net, EventPhase.PRE); historyService.save(new ImportPetriNetEventLog(null, EventPhase.PRE, net.getObjectId())); @@ -218,7 +230,8 @@ public ImportPetriNetEventOutcome importPetriNet(ImportPetriNetParams importPetr save(net); } - outcome.setOutcomes(eventService.runActions(net.getPostUploadActions(), null, Optional.empty(), importPetriNetParams.getParams())); + outcome.setOutcomes(eventService.runActions(net.getPostUploadActions(), null, Optional.empty(), + importPetriNetParams.getParams())); evaluateRules(net, EventPhase.POST); historyService.save(new ImportPetriNetEventLog(null, EventPhase.POST, net.getObjectId())); diff --git a/src/main/java/com/netgrif/application/engine/workflow/domain/params/CreateCaseParams.java b/src/main/java/com/netgrif/application/engine/workflow/domain/params/CreateCaseParams.java index 2e5ca8c8f82..99d278803c7 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/domain/params/CreateCaseParams.java +++ b/src/main/java/com/netgrif/application/engine/workflow/domain/params/CreateCaseParams.java @@ -12,9 +12,7 @@ import java.util.Map; import java.util.function.Function; -/** - * todo javadoc - * */ + @Data @Builder(builderMethodName = "with") public class CreateCaseParams { @@ -31,14 +29,9 @@ public class CreateCaseParams { @Builder.Default private Map<String, String> params = new HashMap<>(); - /** - * todo javadoc - * Builder extension of the {@link Builder} implementation for {@link }. Containing additional logic over the native builder - * implementation - * */ public static class CreateCaseParamsBuilder { /** - * todo javadoc + * Sets the {@link #title} and {@link #makeTitle} as well * */ public CreateCaseParams.CreateCaseParamsBuilder title(String title) { this.title = title; @@ -51,7 +44,7 @@ public CreateCaseParams.CreateCaseParamsBuilder title(String title) { } /** - * todo javadoc + * Sets the {@link #petriNet} as clone, {@link #petriNetIdentifier} and {@link #petriNetId} * */ public CreateCaseParams.CreateCaseParamsBuilder petriNet(PetriNet petriNet) { this.petriNet = petriNet.clone(); diff --git a/src/main/java/com/netgrif/application/engine/workflow/domain/params/DeleteCaseParams.java b/src/main/java/com/netgrif/application/engine/workflow/domain/params/DeleteCaseParams.java index 2deab8b0931..2765a6b4c8a 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/domain/params/DeleteCaseParams.java +++ b/src/main/java/com/netgrif/application/engine/workflow/domain/params/DeleteCaseParams.java @@ -8,9 +8,6 @@ import java.util.HashMap; import java.util.Map; -/** - * todo javadoc - * */ @Data @AllArgsConstructor @Builder(builderMethodName = "with") @@ -32,14 +29,9 @@ public DeleteCaseParams(String useCaseId) { this.useCaseId = useCaseId; } - /** - * todo javadoc - * Builder extension of the {@link Builder} implementation for {@link }. Containing additional logic over the native builder - * implementation - * */ public static class DeleteCaseParamsBuilder { /** - * todo javadoc + * Sets the {@link #useCase} and {@link #useCaseId} * */ public DeleteCaseParams.DeleteCaseParamsBuilder useCase(Case useCase) { this.useCase = useCase; diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/DataService.java b/src/main/java/com/netgrif/application/engine/workflow/service/DataService.java index 123e49af4bc..63c3c0c1b3d 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/DataService.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/DataService.java @@ -86,7 +86,17 @@ public class DataService implements IDataService { private boolean validationEnable; /** - * todo javadoc + * Gets the data of the {@link Task} provided by {@link GetDataParams} + * + * @param getDataParams parameters where the Task is specified + * <br> + * <b>Required parameters</b> + * <ul> + * <li>taskId or task</li> + * <li>user</li> + * </ul> + * + * @return outcome containing the fields present in Task * */ @Override public GetDataEventOutcome getData(GetDataParams getDataParams) { @@ -148,9 +158,6 @@ private void fillMissingAttributes(GetDataParams getDataParams) throws IllegalAr } } - /** - * todo javadoc - * */ @Override public SetDataEventOutcome setData(SetDataParams setDataParams) { fillMissingAttributes(setDataParams); diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/TaskService.java b/src/main/java/com/netgrif/application/engine/workflow/service/TaskService.java index e20c0b3fcc4..3a51150228a 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/TaskService.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/TaskService.java @@ -107,7 +107,12 @@ public class TaskService implements ITaskService { private IRuleEngine ruleEngine; /** - * todo javadoc + * Executes provided {@link Task} in provided {@link Case} + * + * @param task Task to be executed + * @param useCase Case where the task exists + * + * @return list of outcomes from the triggered events during the task execution * */ @Override public List<EventOutcome> executeTask(Task task, Case useCase) { @@ -130,7 +135,13 @@ public List<EventOutcome> executeTask(Task task, Case useCase) { } /** - * todo javadoc + * Assigns all provided tasks by provided user. + * + * @param tasks list of tasks to be assigned + * @param user assignee of the tasks + * @param params additional parameters for the assign task event + * + * @return list of outcomes of the assign events. The order is the same as the order of the provided list of tasks * */ @Override public List<AssignTaskEventOutcome> assignTasks(List<Task> tasks, IUser user, Map<String, String> params) throws TransitionNotExecutableException { @@ -148,7 +159,17 @@ public List<AssignTaskEventOutcome> assignTasks(List<Task> tasks, IUser user, Ma } /** - * todo javadoc + * Assigns the {@link Task} by provided parameters + * + * @param taskParams parameters to determine the Task to be assigned + * <br> + * <b>Required parameters</b> + * <ul> + * <li>taskId or task</li> + * <li>user</li> + * </ul> + * + * @return outcome of the assign event * */ @Override public AssignTaskEventOutcome assignTask(TaskParams taskParams) throws TransitionNotExecutableException { @@ -219,6 +240,15 @@ private DoEventTaskOutcome doAssignTaskToUser(IUser user, Task task, Transition return new DoEventTaskOutcome(task, useCase); } + /** + * Finishes all provided tasks by provided user. + * + * @param tasks list of tasks to be finished + * @param user assignee of the tasks + * @param params additional parameters for the finish task event + * + * @return list of outcomes of the finish events. The order is the same as the order of the provided list of tasks + * */ @Override public List<FinishTaskEventOutcome> finishTasks(List<Task> tasks, IUser user, Map<String, String> params) throws TransitionNotExecutableException { List<FinishTaskEventOutcome> outcomes = new ArrayList<>(); @@ -235,7 +265,17 @@ public List<FinishTaskEventOutcome> finishTasks(List<Task> tasks, IUser user, Ma } /** - * todo javadoc + * Finishes the {@link Task} by provided parameters + * + * @param taskParams parameters to determine the Task to be finished + * <br> + * <b>Required parameters</b> + * <ul> + * <li>taskId or task</li> + * <li>user</li> + * </ul> + * + * @return outcome of the finish event * */ @Override public FinishTaskEventOutcome finishTask(TaskParams taskParams) throws TransitionNotExecutableException { @@ -307,6 +347,15 @@ private DoEventTaskOutcome doFinishTaskByAssignedUser(Task task, Transition tran return new DoEventTaskOutcome(task, useCase); } + /** + * Cancels all provided tasks by provided user. + * + * @param tasks list of tasks to be canceled + * @param user by which the task is canceled + * @param params additional parameters for the cancel task event + * + * @return list of outcomes of the cancel events. The order is the same as the order of the provided list of tasks + * */ @Override public List<CancelTaskEventOutcome> cancelTasks(List<Task> tasks, IUser user, Map<String, String> params) { List<CancelTaskEventOutcome> outcomes = new ArrayList<>(); @@ -323,7 +372,17 @@ public List<CancelTaskEventOutcome> cancelTasks(List<Task> tasks, IUser user, Ma } /** - * todo javadoc + * Cancels the {@link Task} by provided parameters + * + * @param taskParams parameters to determine the Task to be canceled + * <br> + * <b>Required parameters</b> + * <ul> + * <li>taskId or task</li> + * <li>user</li> + * </ul> + * + * @return outcome of the cancel event * */ @Override public CancelTaskEventOutcome cancelTask(TaskParams taskParams) { @@ -471,19 +530,11 @@ private Case evaluateRules(Case useCase, Task task, EventType eventType, EventPh } /** - * todo javadoc - * Reloads all unassigned tasks of given case: - * <table border="1"> - * <tr> - * <td></td><td>Task is present</td><td>Task is not present</td> - * </tr> - * <tr> - * <td>Transition executable</td><td>no action</td><td>create task</td> - * </tr> - * <tr> - * <td>Transition not executable</td><td>destroy task</td><td>no action</td> - * </tr> - * </table> + * Updates the {@link State} of all the {@link Task} objects of the provided {@link Case} + * + * @param useCase Case where the tasks exist, which are updated + * + * @return true if at least one auto-trigger Task was executed. */ @Override public boolean reloadTasks(Case useCase) { @@ -503,7 +554,13 @@ public boolean reloadTasks(Case useCase) { } /** - * todo javadoc + * Updates {@link State} of the provided tasks, that exist in provided {@link Case}. Only tasks with the changed + * state are updated in database. + * + * @param tasks list of tasks to be updated + * @param useCase Case object where the tasks exist + * + * @return optional auto-trigger task, that is not yet executed. * */ private Optional<Task> reloadAndSaveTasks(List<Task> tasks, Case useCase) { Task autoTriggered = null; @@ -525,7 +582,13 @@ private Optional<Task> reloadAndSaveTasks(List<Task> tasks, Case useCase) { } /** - * todo javadoc + * For every {@link Transition} in {@link PetriNet} is created {@link Task} and saved into provided {@link Case}. + * Tasks are saved into database by {@link #reloadAndSaveTasks(List, Case)}. UseCase is not saved into database by + * this method. + * + * @param useCase Case object, where the new tasks are saved. It must contain {@link Case#getPetriNet()} initialized. + * + * @return created tasks and auto-trigger task as optional. Auto-trigger task is within the tasks collection * */ @Override public CreateTasksOutcome createAndSetTasksInCase(Case useCase) { @@ -541,7 +604,13 @@ public CreateTasksOutcome createAndSetTasksInCase(Case useCase) { } /** - * todo javadoc + * Creates the {@link Task} object by the provided {@link Transition} and {@link Case}. Task is not saved in database + * and Case object. + * + * @param transition transition, from which the Task is created + * @param useCase Case, where the created Task should be later saved + * + * @return created Task * */ private Task createTaskFromTransition(Transition transition, Case useCase) { final Task task = Task.with() @@ -600,8 +669,13 @@ private Task createTaskFromTransition(Transition transition, Case useCase) { /** - * todo javadoc - * returns true if it is autotrigger + * Updates the {@link State} of provided {@link Task}. The state depends on {@link #isExecutable(Transition, PetriNet)} + * + * @param task Task, where the state might be updated + * @param transition transition, by which the execution is determined + * @param net petriNet, by which the execution is determined + * + * @return boolean value if the state was updated and if the task must be executed * */ private UpdateTaskStateOutcome updateStateOfTask(Task task, Transition transition, PetriNet net) { if (isExecutable(transition, net)) { diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/WorkflowService.java b/src/main/java/com/netgrif/application/engine/workflow/service/WorkflowService.java index 87bf04af2ab..d5df260bd89 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/WorkflowService.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/WorkflowService.java @@ -199,7 +199,19 @@ private List<String> getExistingUsers(UserListFieldValue userListValue) { } /** - * todo javadoc + * Create {@link Case} object as {@link CreateCaseEventOutcome} by provided parameters as {@link CreateCaseParams}. + * Created object is saved into database along with the tasks. Any {@link Task}, that should be executed at the + * object creation is executed (auto-trigger tasks). + * + * @param createCaseParams parameters for {@link Case} creation + * <br> + * <b>Required parameters:</b> + * <ul> + * <li>petriNet or petriNetIdentifier or petriNetId</li> + * <li>loggedUser</li> + * </ul> + * + * @return outcome with up to date {@link} Case object containing sub-outcomes as result of triggered events * */ @Override public CreateCaseEventOutcome createCase(CreateCaseParams createCaseParams) { @@ -252,7 +264,11 @@ public CreateCaseEventOutcome createCase(CreateCaseParams createCaseParams) { } /** - * todo javadoc + * Creates pure {@link Case} object without any {@link Task} object initialized. + * + * @param createCaseParams parameters for object creation + * + * @return created {@link Case} object * */ private Case createCaseObject(CreateCaseParams createCaseParams) { LoggedUser loggedOrImpersonated = createCaseParams.getLoggedUser().getSelfOrImpersonated(); @@ -270,10 +286,6 @@ private Case createCaseObject(CreateCaseParams createCaseParams) { return useCase; } - /** - * todo javadoc - * makeTitle, petriNet - * */ private void fillMissingAttributes(CreateCaseParams createCaseParams) throws IllegalArgumentException { if (createCaseParams.getLoggedUser() == null) { throw new IllegalArgumentException("Logged user cannot be null on Case creation."); @@ -321,7 +333,16 @@ public Page<Case> findAllByAuthor(String authorId, String petriNet, Pageable pag } /** - * todo javadoc + * Deletes the {@link Case} object from database by provided parameters as {@link DeleteCaseParams} + * + * @param deleteCaseParams parameters to determine the object to be deleted + * <br> + * <b>Required parameters</b> + * <ul> + * <li>useCaseId or useCase</li> + * </ul> + * + * @return outcome with the removed {@link Case} object and sub-outcomes as result of triggered events * */ @Override public DeleteCaseEventOutcome deleteCase(DeleteCaseParams deleteCaseParams) { @@ -350,9 +371,6 @@ public DeleteCaseEventOutcome deleteCase(DeleteCaseParams deleteCaseParams) { return outcome; } - /** - * todo javadoc - * */ private void fillMissingAttributes(DeleteCaseParams deleteCaseParams) throws IllegalArgumentException { if (deleteCaseParams.getUseCase() == null) { if (deleteCaseParams.getUseCaseId() != null) { From cf7713d2ba753171e2d608373679053d9798acc6 Mon Sep 17 00:00:00 2001 From: chvostek <chvostek@netgrif.com> Date: Fri, 9 Aug 2024 16:14:14 +0200 Subject: [PATCH 36/48] [NAE-1998] Implement transactions for events - fix tests - update application-test.properties --- docs/_media/roles/usersRef_functions.groovy | 2 +- .../application/engine/action/ActionDelegateTest.groovy | 6 +++--- .../engine/elastic/DataSearchRequestTest.groovy | 2 +- .../engine/event/GroovyShellFactoryTest.groovy | 4 ++-- .../application/engine/insurance/mvc/InsuranceTest.groovy | 2 +- .../orgstructure/groups/NextGroupServiceTest.groovy | 8 ++++---- .../engine/petrinet/domain/dataset/FileFieldTest.groovy | 4 ++-- .../petrinet/domain/dataset/FileListFieldTest.groovy | 4 ++-- .../engine/petrinet/service/PetriNetServiceTest.groovy | 8 ++++---- src/test/resources/application-test.properties | 3 +++ src/test/resources/petriNets/dynamic_init.xml | 4 ++-- src/test/resources/userrefs_test.xml | 2 +- 12 files changed, 26 insertions(+), 23 deletions(-) diff --git a/docs/_media/roles/usersRef_functions.groovy b/docs/_media/roles/usersRef_functions.groovy index 6effbe44b83..c2cc284feb9 100644 --- a/docs/_media/roles/usersRef_functions.groovy +++ b/docs/_media/roles/usersRef_functions.groovy @@ -1,5 +1,5 @@ Long getDummyUser() { - return userService.findByEmail("dummy@netgrif.com", true).id + return userService.findByEmail("dummy@netgrif.com").id } void debug() { diff --git a/src/test/groovy/com/netgrif/application/engine/action/ActionDelegateTest.groovy b/src/test/groovy/com/netgrif/application/engine/action/ActionDelegateTest.groovy index 4183e5134a9..b0d0bd8c8d2 100644 --- a/src/test/groovy/com/netgrif/application/engine/action/ActionDelegateTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/action/ActionDelegateTest.groovy @@ -65,15 +65,15 @@ class ActionDelegateTest { void deleteUser(){ GreenMail smtpServer = new GreenMail(new ServerSetup(2525, null, "smtp")) smtpServer.start() - String mail = "test@netgrif.com"; + String mail = "test@netgrif.com" MessageResource messageResource = actionDelegate.inviteUser(mail) assert messageResource.getContent().success - IUser user = userService.findByEmail(mail, false) + IUser user = userService.findByEmail(mail) assert user != null MimeMessage[] messages = smtpServer.getReceivedMessages() assert messages actionDelegate.deleteUser(mail) - IUser user2 = userService.findByEmail(mail, false) + IUser user2 = userService.findByEmail(mail) assert user2 == null smtpServer.stop() } diff --git a/src/test/groovy/com/netgrif/application/engine/elastic/DataSearchRequestTest.groovy b/src/test/groovy/com/netgrif/application/engine/elastic/DataSearchRequestTest.groovy index a7cdfb60af8..d0a636c2cd5 100644 --- a/src/test/groovy/com/netgrif/application/engine/elastic/DataSearchRequestTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/elastic/DataSearchRequestTest.groovy @@ -114,7 +114,7 @@ class DataSearchRequestTest { new FileInputStream("src/test/resources/all_data.xml"), VersionType.MAJOR, superCreator.getLoggedSuper())) assert net.getNet() != null - def users = userService.findAll(true) + def users = userService.findAll() assert users.size() >= 2 def testUser1 = users[0] def testUser2 = users[1] diff --git a/src/test/groovy/com/netgrif/application/engine/event/GroovyShellFactoryTest.groovy b/src/test/groovy/com/netgrif/application/engine/event/GroovyShellFactoryTest.groovy index b5296effb6b..0dca4593f27 100644 --- a/src/test/groovy/com/netgrif/application/engine/event/GroovyShellFactoryTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/event/GroovyShellFactoryTest.groovy @@ -84,7 +84,7 @@ class GroovyShellFactoryTest { void roleActionsTest() { userService.metaClass.groovyShellTestMethod = { String string, I18nString i18nString -> println("groovyShellTestMethod") } - def user = userService.findByEmail(userService.getSystem().getEmail(), false) + def user = userService.findByEmail(userService.getSystem().getEmail()) def processRoleCount = user.processRoles.size() def roles = roleService.findAll(net.getStringId()) assert roles.size() == 1 @@ -93,7 +93,7 @@ class GroovyShellFactoryTest { new HashSet<String>(roles.collect { it.stringId } + user.processRoles.collect { it.stringId }), new LoggedUser("", "a", "", []) ) - user = userService.findByEmail(userService.getSystem().getEmail(), false) + user = userService.findByEmail(userService.getSystem().getEmail()) assert user.processRoles.size() == processRoleCount + 1 } diff --git a/src/test/groovy/com/netgrif/application/engine/insurance/mvc/InsuranceTest.groovy b/src/test/groovy/com/netgrif/application/engine/insurance/mvc/InsuranceTest.groovy index 6b52185829b..897a25cb5ce 100644 --- a/src/test/groovy/com/netgrif/application/engine/insurance/mvc/InsuranceTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/insurance/mvc/InsuranceTest.groovy @@ -146,7 +146,7 @@ class InsuranceTest { [auths.get("user"), auths.get("admin")] as Authority[], [processRoles.get("agent"), processRoles.get("company")] as ProcessRole[]) List<ProcessRole> roles = processRoleService.findAll(netId) - processRoleService.assignRolesToUser(userService.findByEmail(USER_EMAIL, false).stringId, roles.findAll { it.importId in ["1", "2"] }.collect { it.stringId } as Set, userService.getLoggedOrSystem().transformToLoggedUser()) + processRoleService.assignRolesToUser(userService.findByEmail(USER_EMAIL).stringId, roles.findAll { it.importId in ["1", "2"] }.collect { it.stringId } as Set, userService.getLoggedOrSystem().transformToLoggedUser()) auth = new UsernamePasswordAuthenticationToken(USER_EMAIL, "password") auth.setDetails(new WebAuthenticationDetails(new MockHttpServletRequest())) diff --git a/src/test/groovy/com/netgrif/application/engine/orgstructure/groups/NextGroupServiceTest.groovy b/src/test/groovy/com/netgrif/application/engine/orgstructure/groups/NextGroupServiceTest.groovy index 43133d77fcd..838c653ff4a 100644 --- a/src/test/groovy/com/netgrif/application/engine/orgstructure/groups/NextGroupServiceTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/orgstructure/groups/NextGroupServiceTest.groovy @@ -80,7 +80,7 @@ class NextGroupServiceTest { } Case createGroup() { - return nextGroupService.createGroup("CUSTOM_GROUP_1", userService.findByEmail(DUMMY_USER_MAIL, false)).getCase() + return nextGroupService.createGroup("CUSTOM_GROUP_1", userService.findByEmail(DUMMY_USER_MAIL)).getCase() } List<Case> findGroup() { @@ -95,15 +95,15 @@ class NextGroupServiceTest { Case addUser() { QCase qCase = new QCase("case") Case group = nextGroupService.findByPredicate(qCase.title.eq("CUSTOM_GROUP_1")).get(0) - nextGroupService.addUser(userService.findByEmail(CUSTOMER_USER_MAIL, false), group) - nextGroupService.addUser(userService.findByEmail("engine@netgrif.com", false), group) + nextGroupService.addUser(userService.findByEmail(CUSTOMER_USER_MAIL), group) + nextGroupService.addUser(userService.findByEmail("engine@netgrif.com"), group) return group } Case removeUser() { QCase qCase = new QCase("case") Case group = nextGroupService.findByPredicate(qCase.title.eq("CUSTOM_GROUP_1")).get(0) - nextGroupService.removeUser(userService.findByEmail(CUSTOMER_USER_MAIL, false), group) + nextGroupService.removeUser(userService.findByEmail(CUSTOMER_USER_MAIL), group) return group } } diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/FileFieldTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/FileFieldTest.groovy index 0bd24cdc787..d72f65fdbd9 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/FileFieldTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/FileFieldTest.groovy @@ -104,7 +104,7 @@ class FileFieldTest { void downloadFileByCase() { PetriNet net = getNet() - IUser user = userService.findByEmail(configuration.email, true) + IUser user = userService.findByEmail(configuration.email) assert user != null CreateCaseParams createCaseParams = CreateCaseParams.with() @@ -130,7 +130,7 @@ class FileFieldTest { void downloadFileByTask() { PetriNet net = getNet() - IUser user = userService.findByEmail(configuration.email, true) + IUser user = userService.findByEmail(configuration.email) assert user != null CreateCaseParams createCaseParams = CreateCaseParams.with() diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/FileListFieldTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/FileListFieldTest.groovy index ad55b548b88..46e45741098 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/FileListFieldTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/FileListFieldTest.groovy @@ -104,7 +104,7 @@ class FileListFieldTest { void downloadFileByCaseAndName() { PetriNet net = getNet() - IUser user = userService.findByEmail(configuration.email, true) + IUser user = userService.findByEmail(configuration.email) assert user != null CreateCaseParams createCaseParams = CreateCaseParams.with() @@ -131,7 +131,7 @@ class FileListFieldTest { void downloadFileByTask() { PetriNet net = getNet() - IUser user = userService.findByEmail(configuration.email, true) + IUser user = userService.findByEmail(configuration.email) assert user != null CreateCaseParams createCaseParams = CreateCaseParams.with() diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/service/PetriNetServiceTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/service/PetriNetServiceTest.groovy index 08331661f66..cda45d3fe62 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/service/PetriNetServiceTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/service/PetriNetServiceTest.groovy @@ -118,12 +118,12 @@ class PetriNetServiceTest { assert taskRepository.count() == taskCount + 3 assert processRoleRepository.count() == processRoleCount + 2 - def user = userService.findByEmail(CUSTOMER_USER_MAIL, false) + def user = userService.findByEmail(CUSTOMER_USER_MAIL) assert user != null assert user.processRoles.size() == 1 userService.addRole(user, testNet.roles.values().collect().get(0).stringId) - user = userService.findByEmail(CUSTOMER_USER_MAIL, false) + user = userService.findByEmail(CUSTOMER_USER_MAIL) assert user != null assert user.processRoles.size() == 2 assert petriNetService.get(new ObjectId(testNet.stringId)) != null @@ -135,7 +135,7 @@ class PetriNetServiceTest { assert caseRepository.findAllByProcessIdentifier(testNetOptional.getNet().getImportId()).size() == 0 assert taskRepository.count() == taskCount assert processRoleRepository.count() == processRoleCount - user = userService.findByEmail(CUSTOMER_USER_MAIL, false) + user = userService.findByEmail(CUSTOMER_USER_MAIL) assert user != null assert user.processRoles.size() == 1 @@ -167,7 +167,7 @@ class PetriNetServiceTest { void processSearch() { long processCount = petriNetRepository.count() - def user = userService.findByEmail(CUSTOMER_USER_MAIL, false) + def user = userService.findByEmail(CUSTOMER_USER_MAIL) assert user != null petriNetService.importPetriNet(new ImportPetriNetParams( stream(NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper())) diff --git a/src/test/resources/application-test.properties b/src/test/resources/application-test.properties index 30bdd2a714b..50c737c41d1 100644 --- a/src/test/resources/application-test.properties +++ b/src/test/resources/application-test.properties @@ -20,6 +20,9 @@ nae.security.limits.login-timeout-unit=seconds # Storage nae.storage.clean=true +# Rule engine +rule-engine.enabled=true + nae.admin.password=password diff --git a/src/test/resources/petriNets/dynamic_init.xml b/src/test/resources/petriNets/dynamic_init.xml index d7593bed06a..7aba8e7764a 100644 --- a/src/test/resources/petriNets/dynamic_init.xml +++ b/src/test/resources/petriNets/dynamic_init.xml @@ -8,13 +8,13 @@ <data type="text" immediate="true"> <id>text</id> <title>Text - userService.findByEmail("super@netgrif.com", true).name + userService.findByEmail("super@netgrif.com").name number number - userService.findByEmail("super@netgrif.com", true).name.length() + userService.findByEmail("super@netgrif.com").name.length() diff --git a/src/test/resources/userrefs_test.xml b/src/test/resources/userrefs_test.xml index e2b0c67e704..1971de0e989 100644 --- a/src/test/resources/userrefs_test.xml +++ b/src/test/resources/userrefs_test.xml @@ -89,7 +89,7 @@ userList: f.user_list_1, email: f.email; - change userList value { [userService.findByEmail(email.value, true).id] } + change userList value { [userService.findByEmail(email.value).id] } From ee214a6283a6a71e1f20d3f46da4ca0f537c1a5a Mon Sep 17 00:00:00 2001 From: chvostek Date: Mon, 26 Aug 2024 15:43:36 +0200 Subject: [PATCH 37/48] [NAE-1998] Implement transactions for events - fix TransactionTest.testBasicTransactionWithFailure - implement transactional option in DataService.setData - implement new tests in DataServiceTest --- .../engine/transaction/NaeTransaction.java | 6 +- .../workflow/domain/params/SetDataParams.java | 2 + .../engine/workflow/service/DataService.java | 36 ++++++++- .../engine/transaction/TransactionTest.groovy | 2 +- .../engine/workflow/DataServiceTest.groovy | 75 +++++++++++++++++++ 5 files changed, 118 insertions(+), 3 deletions(-) diff --git a/src/main/java/com/netgrif/application/engine/transaction/NaeTransaction.java b/src/main/java/com/netgrif/application/engine/transaction/NaeTransaction.java index a853f1fffd9..c58caf5b1a7 100644 --- a/src/main/java/com/netgrif/application/engine/transaction/NaeTransaction.java +++ b/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; diff --git a/src/main/java/com/netgrif/application/engine/workflow/domain/params/SetDataParams.java b/src/main/java/com/netgrif/application/engine/workflow/domain/params/SetDataParams.java index 315b3cf5062..49077726f40 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/domain/params/SetDataParams.java +++ b/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 params = new HashMap<>(); public SetDataParams(Task task, DataSet dataSet, IUser user) { diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/DataService.java b/src/main/java/com/netgrif/application/engine/workflow/service/DataService.java index e17115a2fc1..c98af9740e8 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/DataService.java +++ b/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(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 outcomes = new ArrayList<>(); for (Map.Entry> 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); diff --git a/src/test/groovy/com/netgrif/application/engine/transaction/TransactionTest.groovy b/src/test/groovy/com/netgrif/application/engine/transaction/TransactionTest.groovy index 936d00c1e4b..e638544d47e 100644 --- a/src/test/groovy/com/netgrif/application/engine/transaction/TransactionTest.groovy +++ b/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 diff --git a/src/test/groovy/com/netgrif/application/engine/workflow/DataServiceTest.groovy b/src/test/groovy/com/netgrif/application/engine/workflow/DataServiceTest.groovy index 824ed895160..1428775c757 100644 --- a/src/test/groovy/com/netgrif/application/engine/workflow/DataServiceTest.groovy +++ b/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) buttonWithValueOne, + "button_0", (Field) 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) buttonWithValueOne, + "non_existing_button", (Field) 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) buttonWithValueOne, + "non_existing_button", (Field) 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) From 808f3de97c68c4a669a751c3574aa6d0e64d4c5c Mon Sep 17 00:00:00 2001 From: chvostek Date: Tue, 27 Aug 2024 08:27:50 +0200 Subject: [PATCH 38/48] [NAE-1998] Implement transactions for events - update DataServiceTest --- .../application/engine/workflow/DataServiceTest.groovy | 2 ++ src/test/resources/test_setData.xml | 10 ++++++++++ 2 files changed, 12 insertions(+) diff --git a/src/test/groovy/com/netgrif/application/engine/workflow/DataServiceTest.groovy b/src/test/groovy/com/netgrif/application/engine/workflow/DataServiceTest.groovy index 1428775c757..06a56309459 100644 --- a/src/test/groovy/com/netgrif/application/engine/workflow/DataServiceTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/workflow/DataServiceTest.groovy @@ -175,6 +175,7 @@ class DataServiceTest { aCase = workflowService.findOne(aCase.stringId) assert aCase.getDataSet().get("button_1").getRawValue() != 1 + assert aCase.getDataSet().get("button_0").getRawValue() != 1337 // forbidden result of set action of button_1 } @Test @@ -198,6 +199,7 @@ class DataServiceTest { aCase = workflowService.findOne(aCase.stringId) assert aCase.getDataSet().get("button_1").getRawValue() == 1 + assert aCase.getDataSet().get("button_0").getRawValue() == 1337 // allowed result of set action of button_1 } // @Test diff --git a/src/test/resources/test_setData.xml b/src/test/resources/test_setData.xml index 86fde7e4000..50962c23298 100644 --- a/src/test/resources/test_setData.xml +++ b/src/test/resources/test_setData.xml @@ -28,6 +28,16 @@ button_1 + <event type="set"> + <id>0</id> + <actions phase="pre"> + <action> + button_0: f.button_0; + + change button_0 value { 1337 } + </action> + </actions> + </event> </data> <transition> <id>t1</id> From d5797db87f891ca9637ed4466551bf9671a423d5 Mon Sep 17 00:00:00 2001 From: chvostek <chvostek@netgrif.com> Date: Tue, 27 Aug 2024 09:19:52 +0200 Subject: [PATCH 39/48] [NAE-1998] Implement transactions for events - make DataService.getData optionally transactional - add javadoc for DataService.setData - optimize DataService.setData - update DataServiceTest --- .../workflow/domain/params/GetDataParams.java | 2 + .../engine/workflow/service/DataService.java | 42 ++++++++++++++++--- .../engine/workflow/DataServiceTest.groovy | 15 +++---- 3 files changed, 44 insertions(+), 15 deletions(-) diff --git a/src/main/java/com/netgrif/application/engine/workflow/domain/params/GetDataParams.java b/src/main/java/com/netgrif/application/engine/workflow/domain/params/GetDataParams.java index fbdfda4b6dc..a1a6468da4f 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/domain/params/GetDataParams.java +++ b/src/main/java/com/netgrif/application/engine/workflow/domain/params/GetDataParams.java @@ -20,6 +20,8 @@ public class GetDataParams { private IUser user; private Case useCase; @Builder.Default + private boolean isTransactional = false; + @Builder.Default private Map<String, String> params = new HashMap<>(); public GetDataParams(Task task, Case useCase, IUser user) { diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/DataService.java b/src/main/java/com/netgrif/application/engine/workflow/service/DataService.java index c98af9740e8..8786ac56e6e 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/DataService.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/DataService.java @@ -112,10 +112,32 @@ public GetDataEventOutcome getData(GetDataParams getDataParams) { Case useCase = getDataParams.getUseCase(); Task task = getDataParams.getTask(); - IUser user = getDataParams.getUser(); log.info("[{}]: Getting data of task {} [{}]", useCase.getStringId(), task.getTransitionId(), task.getStringId()); + if (getDataParams.isTransactional()) { + NaeTransaction transaction = NaeTransaction.builder() + .timeout(TransactionDefinition.TIMEOUT_DEFAULT) + .forceCreation(false) + .transactionManager(transactionManager) + .event(new Closure<GetDataEventOutcome>(null) { + @Override + public GetDataEventOutcome call() { + return doGetData(getDataParams); + } + }) + .build(); + transaction.begin(); + return (GetDataEventOutcome) transaction.getResultOfEvent(); + } else { + return doGetData(getDataParams); + } + } + + private GetDataEventOutcome doGetData(GetDataParams getDataParams) { + Case useCase = getDataParams.getUseCase(); + Task task = getDataParams.getTask(); + IUser user = getDataParams.getUser(); Transition transition = useCase.getPetriNet().getTransition(task.getTransitionId()); Map<String, DataRef> dataRefs = transition.getDataSet(); List<DataRef> dataSetFields = new ArrayList<>(); @@ -167,7 +189,17 @@ private void fillMissingAttributes(GetDataParams getDataParams) throws IllegalAr } /** - * todo javadoc + * Sets the provided data by {@link SetDataParams} + * + * @param setDataParams parameters containing the data to be set within the {@link Case} or {@link Task} object + * <br> + * <b>Required parameters</b> + * <ul> + * <li>taskId or task or useCase</li> + * <li>user</li> + * </ul> + * + * @return outcome containing changed fields, updated Task and Case * */ @Override public SetDataEventOutcome setData(SetDataParams setDataParams) { @@ -213,6 +245,9 @@ private SetDataEventOutcome doSetData(SetDataParams setDataParams) { } private void fillMissingAttributes(SetDataParams setDataParams) { + if (setDataParams.getUser() == null) { + throw new IllegalArgumentException("User must be provided on set data."); + } if (setDataParams.getTask() == null) { if (setDataParams.getTaskId() != null) { Task task = taskService.findOne(setDataParams.getTaskId()); @@ -229,9 +264,6 @@ private void fillMissingAttributes(SetDataParams setDataParams) { throw new IllegalArgumentException("Cannot set data without provided task."); } } - if (setDataParams.getUser() == null) { - throw new IllegalArgumentException("User must be provided on set data."); - } } @Override diff --git a/src/test/groovy/com/netgrif/application/engine/workflow/DataServiceTest.groovy b/src/test/groovy/com/netgrif/application/engine/workflow/DataServiceTest.groovy index 06a56309459..73a8b36b5a7 100644 --- a/src/test/groovy/com/netgrif/application/engine/workflow/DataServiceTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/workflow/DataServiceTest.groovy @@ -12,6 +12,7 @@ import com.netgrif.application.engine.petrinet.domain.params.ImportPetriNetParam 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.Case 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 @@ -134,12 +135,10 @@ class DataServiceTest { @Test void testTransactionalSetDataOutcomes() { - def aCase = importHelper.createCase("Case", this.setDataNet) + Case 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) @@ -156,12 +155,10 @@ class DataServiceTest { @Test void testTransactionalSetDataFailure() { - def aCase = importHelper.createCase("Case", this.setDataNet) + Case 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) @@ -179,13 +176,11 @@ class DataServiceTest { } @Test - void testTransactionalSetDataSuccess() { - def aCase = importHelper.createCase("Case", this.setDataNet) + void testNonTransactionalSetDataFailure() { + Case 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) From 430ecc69499c0eebc3d9741b86ff5b5a0b594685 Mon Sep 17 00:00:00 2001 From: chvostek <chvostek@netgrif.com> Date: Tue, 27 Aug 2024 10:23:59 +0200 Subject: [PATCH 40/48] [NAE-1998] Implement transactions for events - make WorkflowService.createCase optionally transactional - implement new tests in WorkflowServiceTest - fix id of create_case_locale.xml --- .../domain/params/CreateCaseParams.java | 2 + .../engine/workflow/service/DataService.java | 1 - .../workflow/service/WorkflowService.java | 28 ++++++++++ .../workflow/WorkflowServiceTest.groovy | 53 +++++++++++++++++-- src/test/resources/create_case_failure.xml | 23 ++++++++ src/test/resources/create_case_locale.xml | 2 +- 6 files changed, 103 insertions(+), 6 deletions(-) create mode 100644 src/test/resources/create_case_failure.xml diff --git a/src/main/java/com/netgrif/application/engine/workflow/domain/params/CreateCaseParams.java b/src/main/java/com/netgrif/application/engine/workflow/domain/params/CreateCaseParams.java index 99d278803c7..abda8951fa0 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/domain/params/CreateCaseParams.java +++ b/src/main/java/com/netgrif/application/engine/workflow/domain/params/CreateCaseParams.java @@ -27,6 +27,8 @@ public class CreateCaseParams { @Builder.Default private Locale locale = LocaleContextHolder.getLocale(); @Builder.Default + private boolean isTransactional = false; + @Builder.Default private Map<String, String> params = new HashMap<>(); public static class CreateCaseParamsBuilder { diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/DataService.java b/src/main/java/com/netgrif/application/engine/workflow/service/DataService.java index 8786ac56e6e..e035a188f85 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/DataService.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/DataService.java @@ -47,7 +47,6 @@ 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; diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/WorkflowService.java b/src/main/java/com/netgrif/application/engine/workflow/service/WorkflowService.java index d5df260bd89..3d46d154536 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/WorkflowService.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/WorkflowService.java @@ -19,6 +19,7 @@ import com.netgrif.application.engine.rules.domain.facts.CaseCreatedFact; import com.netgrif.application.engine.rules.service.interfaces.IRuleEngine; import com.netgrif.application.engine.security.service.EncryptionService; +import com.netgrif.application.engine.transaction.NaeTransaction; import com.netgrif.application.engine.utils.FullPageRequest; import com.netgrif.application.engine.workflow.domain.Case; import com.netgrif.application.engine.workflow.domain.DataFieldValue; @@ -36,6 +37,7 @@ import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowService; import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams; import com.querydsl.core.types.Predicate; +import groovy.lang.Closure; import lombok.extern.slf4j.Slf4j; import org.bson.types.ObjectId; import org.springframework.beans.factory.annotation.Autowired; @@ -44,10 +46,13 @@ import org.springframework.data.domain.PageImpl; import org.springframework.data.domain.PageRequest; import org.springframework.data.domain.Pageable; +import org.springframework.data.mongodb.MongoTransactionManager; import org.springframework.data.mongodb.core.MongoTemplate; import org.springframework.data.mongodb.core.query.BasicQuery; import org.springframework.data.util.Pair; import org.springframework.stereotype.Service; +import org.springframework.transaction.TransactionDefinition; +import org.springframework.transaction.annotation.Transactional; import java.time.LocalDateTime; import java.util.*; @@ -95,6 +100,9 @@ public class WorkflowService implements IWorkflowService { @Autowired private DataSetInitializer dataSetInitializer; + @Autowired + private MongoTransactionManager transactionManager; + @Autowired public void setElasticCaseService(IElasticCaseService elasticCaseService) { this.elasticCaseService = elasticCaseService; @@ -217,6 +225,26 @@ private List<String> getExistingUsers(UserListFieldValue userListValue) { public CreateCaseEventOutcome createCase(CreateCaseParams createCaseParams) { fillMissingAttributes(createCaseParams); + if (createCaseParams.isTransactional()) { + NaeTransaction transaction = NaeTransaction.builder() + .timeout(TransactionDefinition.TIMEOUT_DEFAULT) + .forceCreation(false) + .transactionManager(transactionManager) + .event(new Closure<CreateCaseEventOutcome>(null) { + @Override + public CreateCaseEventOutcome call() { + return doCreateCase(createCaseParams); + } + }) + .build(); + transaction.begin(); + return (CreateCaseEventOutcome) transaction.getResultOfEvent(); + } else { + return doCreateCase(createCaseParams); + } + } + + private CreateCaseEventOutcome doCreateCase(CreateCaseParams createCaseParams) { Case useCase = createCaseObject(createCaseParams); CreateTasksOutcome createTasksOutcome = taskService.createAndSetTasksInCase(useCase); save(useCase); // must be after tasks creation for effectivity reasons diff --git a/src/test/groovy/com/netgrif/application/engine/workflow/WorkflowServiceTest.groovy b/src/test/groovy/com/netgrif/application/engine/workflow/WorkflowServiceTest.groovy index 44611fd60a9..4ca92815f61 100644 --- a/src/test/groovy/com/netgrif/application/engine/workflow/WorkflowServiceTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/workflow/WorkflowServiceTest.groovy @@ -2,19 +2,18 @@ package com.netgrif.application.engine.workflow import com.netgrif.application.engine.TestHelper import com.netgrif.application.engine.ipc.TaskApiTest +import com.netgrif.application.engine.petrinet.domain.PetriNet import com.netgrif.application.engine.petrinet.domain.VersionType 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.Case +import com.netgrif.application.engine.workflow.domain.QCase import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowService -import groovy.time.TimeCategory -import groovy.time.TimeDuration import groovy.transform.CompileStatic import org.junit.jupiter.api.BeforeEach -import org.junit.jupiter.api.Disabled import org.junit.jupiter.api.Test import org.junit.jupiter.api.extension.ExtendWith import org.springframework.beans.factory.annotation.Autowired @@ -22,7 +21,8 @@ import org.springframework.boot.test.context.SpringBootTest import org.springframework.test.context.ActiveProfiles import org.springframework.test.context.junit.jupiter.SpringExtension -import static com.netgrif.application.engine.workflow.domain.params.CreateCaseParams.* +import static com.netgrif.application.engine.workflow.domain.params.CreateCaseParams.with +import static org.junit.jupiter.api.Assertions.assertThrows @ExtendWith(SpringExtension.class) @ActiveProfiles(["test"]) @@ -32,6 +32,7 @@ class WorkflowServiceTest { public static final String NET_FILE = "case_search_test.xml" public static final String CASE_LOCALE_NET_FILE = "create_case_locale.xml" + public static final String CASE_FAILURE_NET_FILE = "create_case_failure.xml" public static final String FIRST_AUTO_NET_FILE = "petriNets/NAE_1382_first_trans_auto.xml" public static final String SECOND_AUTO_NET_FILE = "petriNets/NAE_1382_first_trans_auto_2.xml" @@ -147,4 +148,48 @@ class WorkflowServiceTest { assert enCase.title == "English translation" } + + @Test + void testTransactionalCreateCaseFailure() { + petriNetService.importPetriNet(new ImportPetriNetParams( + stream(CASE_LOCALE_NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper())) + PetriNet net = petriNetService.importPetriNet(new ImportPetriNetParams( + stream(CASE_FAILURE_NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper())).getNet() + + CreateCaseParams createCaseParams = with() + .isTransactional(true) + .petriNet(net) + .title("FailedCase") + .color(null) + .loggedUser(superCreator.getLoggedSuper()) + .build() + + assertThrows(RuntimeException.class, { workflowService.createCase(createCaseParams) }) + + assert workflowService.searchOne(QCase.case$.title.eq("FailedCase")) == null + assert workflowService.searchOne(QCase.case$.title.eq("CaseFromPre")) == null + assert workflowService.searchOne(QCase.case$.title.eq("CaseFromPost")) == null + } + + @Test + void testNonTransactionalCreateCaseFailure() { + petriNetService.importPetriNet(new ImportPetriNetParams( + stream(CASE_LOCALE_NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper())) + PetriNet net = petriNetService.importPetriNet(new ImportPetriNetParams( + stream(CASE_FAILURE_NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper())).getNet() + + CreateCaseParams createCaseParams = with() + .isTransactional(false) + .petriNet(net) + .title("FailedCase") + .color(null) + .loggedUser(superCreator.getLoggedSuper()) + .build() + + assertThrows(RuntimeException.class, { workflowService.createCase(createCaseParams) }) + + assert workflowService.searchOne(QCase.case$.title.eq("FailedCase")) != null // failure in post action + assert workflowService.searchOne(QCase.case$.title.eq("CaseFromPre")) != null + assert workflowService.searchOne(QCase.case$.title.eq("CaseFromPost")) != null + } } diff --git a/src/test/resources/create_case_failure.xml b/src/test/resources/create_case_failure.xml new file mode 100644 index 00000000000..1b5cd70d6e0 --- /dev/null +++ b/src/test/resources/create_case_failure.xml @@ -0,0 +1,23 @@ +<?xml version="1.0" encoding="UTF-8"?> +<document xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" + xsi:noNamespaceSchemaLocation="https://petriflow.com/petriflow.schema.xsd"> + <id>create_case_failure</id> + <initials>TST</initials> + <title>Test + + + 123 + + + createCase("create_case_locale", "CaseFromPre") + + + + + createCase("create_case_locale", "CaseFromPost") + throw new RuntimeException("error on purpose") + + + + + \ No newline at end of file diff --git a/src/test/resources/create_case_locale.xml b/src/test/resources/create_case_locale.xml index 99fe3759b8a..8b8715ec589 100644 --- a/src/test/resources/create_case_locale.xml +++ b/src/test/resources/create_case_locale.xml @@ -1,7 +1,7 @@ - currency_test.xml + create_case_locale TST Test Slovenský preklad From 0c13aefecfe2a99c926430ab34332d06a69f0b00 Mon Sep 17 00:00:00 2001 From: chvostek Date: Tue, 27 Aug 2024 11:08:35 +0200 Subject: [PATCH 41/48] [NAE-1998] Implement transactions for events - make WorkflowService.deleteCase optionally transactional - implement new tests in WorkflowServiceTest --- .../domain/params/DeleteCaseParams.java | 2 + .../workflow/service/WorkflowService.java | 21 ++++++- .../workflow/WorkflowServiceTest.groovy | 58 ++++++++++++++++++- src/test/resources/delete_case_failure.xml | 23 ++++++++ 4 files changed, 100 insertions(+), 4 deletions(-) create mode 100644 src/test/resources/delete_case_failure.xml diff --git a/src/main/java/com/netgrif/application/engine/workflow/domain/params/DeleteCaseParams.java b/src/main/java/com/netgrif/application/engine/workflow/domain/params/DeleteCaseParams.java index 2765a6b4c8a..cdf43ba6877 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/domain/params/DeleteCaseParams.java +++ b/src/main/java/com/netgrif/application/engine/workflow/domain/params/DeleteCaseParams.java @@ -16,6 +16,8 @@ public class DeleteCaseParams { private String useCaseId; private Case useCase; @Builder.Default + private boolean isTransactional = false; + @Builder.Default private Map params = new HashMap<>(); public DeleteCaseParams(Case useCase) { diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/WorkflowService.java b/src/main/java/com/netgrif/application/engine/workflow/service/WorkflowService.java index 3d46d154536..31bd170fbd9 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/WorkflowService.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/WorkflowService.java @@ -52,7 +52,6 @@ import org.springframework.data.util.Pair; import org.springframework.stereotype.Service; import org.springframework.transaction.TransactionDefinition; -import org.springframework.transaction.annotation.Transactional; import java.time.LocalDateTime; import java.util.*; @@ -376,6 +375,26 @@ public Page findAllByAuthor(String authorId, String petriNet, Pageable pag public DeleteCaseEventOutcome deleteCase(DeleteCaseParams deleteCaseParams) { fillMissingAttributes(deleteCaseParams); + if (deleteCaseParams.isTransactional()) { + NaeTransaction transaction = NaeTransaction.builder() + .timeout(TransactionDefinition.TIMEOUT_DEFAULT) + .forceCreation(false) + .transactionManager(transactionManager) + .event(new Closure(null) { + @Override + public DeleteCaseEventOutcome call() { + return doDeleteCase(deleteCaseParams); + } + }) + .build(); + transaction.begin(); + return (DeleteCaseEventOutcome) transaction.getResultOfEvent(); + } else { + return doDeleteCase(deleteCaseParams); + } + } + + private DeleteCaseEventOutcome doDeleteCase(DeleteCaseParams deleteCaseParams) { Case useCase = deleteCaseParams.getUseCase(); List preEventOutcomes = eventService.runActions(useCase.getPetriNet().getPreDeleteActions(), diff --git a/src/test/groovy/com/netgrif/application/engine/workflow/WorkflowServiceTest.groovy b/src/test/groovy/com/netgrif/application/engine/workflow/WorkflowServiceTest.groovy index 4ca92815f61..ed1d128e3d5 100644 --- a/src/test/groovy/com/netgrif/application/engine/workflow/WorkflowServiceTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/workflow/WorkflowServiceTest.groovy @@ -11,6 +11,7 @@ import com.netgrif.application.engine.startup.SuperCreator import com.netgrif.application.engine.workflow.domain.Case import com.netgrif.application.engine.workflow.domain.QCase import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams +import com.netgrif.application.engine.workflow.domain.params.DeleteCaseParams import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowService import groovy.transform.CompileStatic import org.junit.jupiter.api.BeforeEach @@ -32,7 +33,8 @@ class WorkflowServiceTest { public static final String NET_FILE = "case_search_test.xml" public static final String CASE_LOCALE_NET_FILE = "create_case_locale.xml" - public static final String CASE_FAILURE_NET_FILE = "create_case_failure.xml" + public static final String CREATE_CASE_FAILURE_NET_FILE = "create_case_failure.xml" + public static final String DELETE_CASE_FAILURE_NET_FILE = "delete_case_failure.xml" public static final String FIRST_AUTO_NET_FILE = "petriNets/NAE_1382_first_trans_auto.xml" public static final String SECOND_AUTO_NET_FILE = "petriNets/NAE_1382_first_trans_auto_2.xml" @@ -154,7 +156,7 @@ class WorkflowServiceTest { petriNetService.importPetriNet(new ImportPetriNetParams( stream(CASE_LOCALE_NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper())) PetriNet net = petriNetService.importPetriNet(new ImportPetriNetParams( - stream(CASE_FAILURE_NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper())).getNet() + stream(CREATE_CASE_FAILURE_NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper())).getNet() CreateCaseParams createCaseParams = with() .isTransactional(true) @@ -176,7 +178,7 @@ class WorkflowServiceTest { petriNetService.importPetriNet(new ImportPetriNetParams( stream(CASE_LOCALE_NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper())) PetriNet net = petriNetService.importPetriNet(new ImportPetriNetParams( - stream(CASE_FAILURE_NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper())).getNet() + stream(CREATE_CASE_FAILURE_NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper())).getNet() CreateCaseParams createCaseParams = with() .isTransactional(false) @@ -192,4 +194,54 @@ class WorkflowServiceTest { assert workflowService.searchOne(QCase.case$.title.eq("CaseFromPre")) != null assert workflowService.searchOne(QCase.case$.title.eq("CaseFromPost")) != null } + + @Test + void testTransactionalDeleteCaseFailure() { + PetriNet net = petriNetService.importPetriNet(new ImportPetriNetParams( + stream(DELETE_CASE_FAILURE_NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper())).getNet() + + CreateCaseParams createCaseParams = with() + .petriNet(net) + .title("CaseToRemove") + .color(null) + .loggedUser(superCreator.getLoggedSuper()) + .build() + + Case useCase = workflowService.createCase(createCaseParams).getCase() + + DeleteCaseParams deleteCaseParams = DeleteCaseParams.with() + .isTransactional(true) + .useCase(useCase) + .build() + assertThrows(RuntimeException.class, { workflowService.deleteCase(deleteCaseParams) }) + + assert workflowService.searchOne(QCase.case$.title.eq("CaseToRemove")) != null + assert workflowService.searchOne(QCase.case$.title.eq("CaseFromPre")) == null + assert workflowService.searchOne(QCase.case$.title.eq("CaseFromPost")) == null + } + + @Test + void testNonTransactionalDeleteCaseFailure() { + PetriNet net = petriNetService.importPetriNet(new ImportPetriNetParams( + stream(DELETE_CASE_FAILURE_NET_FILE), VersionType.MAJOR, superCreator.getLoggedSuper())).getNet() + + CreateCaseParams createCaseParams = with() + .petriNet(net) + .title("CaseToRemove") + .color(null) + .loggedUser(superCreator.getLoggedSuper()) + .build() + + Case useCase = workflowService.createCase(createCaseParams).getCase() + + DeleteCaseParams deleteCaseParams = DeleteCaseParams.with() + .isTransactional(false) + .useCase(useCase) + .build() + assertThrows(RuntimeException.class, { workflowService.deleteCase(deleteCaseParams) }) + + assert workflowService.searchOne(QCase.case$.title.eq("CaseToRemove")) == null // failure in post action + assert workflowService.searchOne(QCase.case$.title.eq("CaseFromPre")) != null + assert workflowService.searchOne(QCase.case$.title.eq("CaseFromPost")) != null + } } diff --git a/src/test/resources/delete_case_failure.xml b/src/test/resources/delete_case_failure.xml new file mode 100644 index 00000000000..49ccac387b7 --- /dev/null +++ b/src/test/resources/delete_case_failure.xml @@ -0,0 +1,23 @@ + + + delete_case_failure + TST + Test + + + 123 + + + createCase("delete_case_failure", "CaseFromPre") + + + + + createCase("delete_case_failure", "CaseFromPost") + throw new RuntimeException("error on purpose") + + + + + \ No newline at end of file From 1d8bf430be68790a368155429657edaaf2a58e0d Mon Sep 17 00:00:00 2001 From: chvostek Date: Tue, 27 Aug 2024 11:14:23 +0200 Subject: [PATCH 42/48] [NAE-1998] Implement transactions for events - optimize transactions in API --- .../application/engine/workflow/service/DataService.java | 5 +++-- .../application/engine/workflow/service/WorkflowService.java | 5 +++-- 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/DataService.java b/src/main/java/com/netgrif/application/engine/workflow/service/DataService.java index e035a188f85..71390114711 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/DataService.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/DataService.java @@ -47,6 +47,7 @@ import org.springframework.data.mongodb.MongoTransactionManager; import org.springframework.stereotype.Service; import org.springframework.transaction.TransactionDefinition; +import org.springframework.transaction.support.TransactionSynchronizationManager; import org.springframework.web.multipart.MultipartFile; import javax.imageio.ImageIO; @@ -114,7 +115,7 @@ public GetDataEventOutcome getData(GetDataParams getDataParams) { log.info("[{}]: Getting data of task {} [{}]", useCase.getStringId(), task.getTransitionId(), task.getStringId()); - if (getDataParams.isTransactional()) { + if (getDataParams.isTransactional() && !TransactionSynchronizationManager.isSynchronizationActive()) { NaeTransaction transaction = NaeTransaction.builder() .timeout(TransactionDefinition.TIMEOUT_DEFAULT) .forceCreation(false) @@ -211,7 +212,7 @@ public SetDataEventOutcome setData(SetDataParams setDataParams) { task.setUser(userService.findById(task.getUserId())); } - if (setDataParams.isTransactional()) { + if (setDataParams.isTransactional() && !TransactionSynchronizationManager.isSynchronizationActive()) { NaeTransaction transaction = NaeTransaction.builder() .timeout(TransactionDefinition.TIMEOUT_DEFAULT) .forceCreation(false) diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/WorkflowService.java b/src/main/java/com/netgrif/application/engine/workflow/service/WorkflowService.java index 31bd170fbd9..9505e0dbef0 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/WorkflowService.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/WorkflowService.java @@ -52,6 +52,7 @@ import org.springframework.data.util.Pair; import org.springframework.stereotype.Service; import org.springframework.transaction.TransactionDefinition; +import org.springframework.transaction.support.TransactionSynchronizationManager; import java.time.LocalDateTime; import java.util.*; @@ -224,7 +225,7 @@ private List getExistingUsers(UserListFieldValue userListValue) { public CreateCaseEventOutcome createCase(CreateCaseParams createCaseParams) { fillMissingAttributes(createCaseParams); - if (createCaseParams.isTransactional()) { + if (createCaseParams.isTransactional() && !TransactionSynchronizationManager.isSynchronizationActive()) { NaeTransaction transaction = NaeTransaction.builder() .timeout(TransactionDefinition.TIMEOUT_DEFAULT) .forceCreation(false) @@ -375,7 +376,7 @@ public Page findAllByAuthor(String authorId, String petriNet, Pageable pag public DeleteCaseEventOutcome deleteCase(DeleteCaseParams deleteCaseParams) { fillMissingAttributes(deleteCaseParams); - if (deleteCaseParams.isTransactional()) { + if (deleteCaseParams.isTransactional() && !TransactionSynchronizationManager.isSynchronizationActive()) { NaeTransaction transaction = NaeTransaction.builder() .timeout(TransactionDefinition.TIMEOUT_DEFAULT) .forceCreation(false) From 411eb479c6b81c4b97f67d74ca32683c38064711 Mon Sep 17 00:00:00 2001 From: chvostek Date: Tue, 27 Aug 2024 13:25:26 +0200 Subject: [PATCH 43/48] [NAE-1998] Implement transactions for events - make TaskService.assignTask optionally transactional - make TaskService.finishTask optionally transactional - make TaskService.cancelTask optionally transactional - implement new tests in TaskServiceTest --- .../workflow/domain/params/TaskParams.java | 2 + .../engine/workflow/service/TaskService.java | 76 +++++++++ .../workflow/service/TaskServiceTest.java | 148 ++++++++++++++++++ .../transactional_task_event_test.xml | 68 ++++++++ 4 files changed, 294 insertions(+) create mode 100644 src/test/resources/transactional_task_event_test.xml diff --git a/src/main/java/com/netgrif/application/engine/workflow/domain/params/TaskParams.java b/src/main/java/com/netgrif/application/engine/workflow/domain/params/TaskParams.java index 5f44860fd4e..9dd0d7a6bd4 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/domain/params/TaskParams.java +++ b/src/main/java/com/netgrif/application/engine/workflow/domain/params/TaskParams.java @@ -20,6 +20,8 @@ public class TaskParams { private Case useCase; private IUser user; @Builder.Default + private boolean isTransactional = false; + @Builder.Default private Map params = new HashMap<>(); public TaskParams(Task task) { diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/TaskService.java b/src/main/java/com/netgrif/application/engine/workflow/service/TaskService.java index 2ed4a7aa106..2cb0cf68cbc 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/TaskService.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/TaskService.java @@ -27,6 +27,7 @@ import com.netgrif.application.engine.petrinet.service.interfaces.IProcessRoleService; import com.netgrif.application.engine.rules.domain.facts.TransitionEventFact; import com.netgrif.application.engine.rules.service.interfaces.IRuleEngine; +import com.netgrif.application.engine.transaction.NaeTransaction; import com.netgrif.application.engine.utils.DateUtils; import com.netgrif.application.engine.utils.FullPageRequest; import com.netgrif.application.engine.workflow.domain.*; @@ -49,6 +50,7 @@ import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowService; import com.netgrif.application.engine.workflow.web.requestbodies.TaskSearchRequest; import com.netgrif.application.engine.workflow.web.responsebodies.TaskReference; +import groovy.lang.Closure; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Qualifier; @@ -56,10 +58,13 @@ import org.springframework.data.domain.PageImpl; import org.springframework.data.domain.PageRequest; import org.springframework.data.domain.Pageable; +import org.springframework.data.mongodb.MongoTransactionManager; import org.springframework.data.mongodb.core.MongoTemplate; import org.springframework.data.mongodb.core.query.BasicQuery; import org.springframework.scheduling.TaskScheduler; import org.springframework.stereotype.Service; +import org.springframework.transaction.TransactionDefinition; +import org.springframework.transaction.support.TransactionSynchronizationManager; import java.time.LocalDateTime; import java.util.*; @@ -106,6 +111,9 @@ public class TaskService implements ITaskService { @Autowired private IRuleEngine ruleEngine; + @Autowired + private MongoTransactionManager transactionManager; + /** * Executes provided {@link Task} in provided {@link Case} * @@ -175,6 +183,30 @@ public List assignTasks(List tasks, IUser user, Ma public AssignTaskEventOutcome assignTask(TaskParams taskParams) throws TransitionNotExecutableException { fillMissingAttributes(taskParams); + if (taskParams.isTransactional() && !TransactionSynchronizationManager.isSynchronizationActive()) { + NaeTransaction transaction = NaeTransaction.builder() + .timeout(TransactionDefinition.TIMEOUT_DEFAULT) + .forceCreation(false) + .transactionManager(transactionManager) + .event(new Closure(null) { + @Override + public AssignTaskEventOutcome call() { + try { + return doAssignTask(taskParams); + } catch (TransitionNotExecutableException e) { + throw new RuntimeException(e); + } + } + }) + .build(); + transaction.begin(); + return (AssignTaskEventOutcome) transaction.getResultOfEvent(); + } else { + return doAssignTask(taskParams); + } + } + + private AssignTaskEventOutcome doAssignTask(TaskParams taskParams) throws TransitionNotExecutableException { Task task = taskParams.getTask(); Case useCase = taskParams.getUseCase(); IUser user = taskParams.getUser(); @@ -281,6 +313,30 @@ public List finishTasks(List tasks, IUser user, Ma public FinishTaskEventOutcome finishTask(TaskParams taskParams) throws TransitionNotExecutableException { fillMissingAttributes(taskParams); + if (taskParams.isTransactional() && !TransactionSynchronizationManager.isSynchronizationActive()) { + NaeTransaction transaction = NaeTransaction.builder() + .timeout(TransactionDefinition.TIMEOUT_DEFAULT) + .forceCreation(false) + .transactionManager(transactionManager) + .event(new Closure(null) { + @Override + public FinishTaskEventOutcome call() { + try { + return doFinishTask(taskParams); + } catch (TransitionNotExecutableException e) { + throw new RuntimeException(e); + } + } + }) + .build(); + transaction.begin(); + return (FinishTaskEventOutcome) transaction.getResultOfEvent(); + } else { + return doFinishTask(taskParams); + } + } + + private FinishTaskEventOutcome doFinishTask(TaskParams taskParams) throws TransitionNotExecutableException { Task task = taskParams.getTask(); Case useCase = taskParams.getUseCase(); IUser user = taskParams.getUser(); @@ -388,6 +444,26 @@ public List cancelTasks(List tasks, IUser user, Ma public CancelTaskEventOutcome cancelTask(TaskParams taskParams) { fillMissingAttributes(taskParams); + if (taskParams.isTransactional() && !TransactionSynchronizationManager.isSynchronizationActive()) { + NaeTransaction transaction = NaeTransaction.builder() + .timeout(TransactionDefinition.TIMEOUT_DEFAULT) + .forceCreation(false) + .transactionManager(transactionManager) + .event(new Closure(null) { + @Override + public CancelTaskEventOutcome call() { + return doCancelTask(taskParams); + } + }) + .build(); + transaction.begin(); + return (CancelTaskEventOutcome) transaction.getResultOfEvent(); + } else { + return doCancelTask(taskParams); + } + } + + private CancelTaskEventOutcome doCancelTask(TaskParams taskParams) { Task task = taskParams.getTask(); IUser user = taskParams.getUser(); Case useCase = taskParams.getUseCase(); diff --git a/src/test/java/com/netgrif/application/engine/workflow/service/TaskServiceTest.java b/src/test/java/com/netgrif/application/engine/workflow/service/TaskServiceTest.java index 623fe0e61c2..6984fba360a 100644 --- a/src/test/java/com/netgrif/application/engine/workflow/service/TaskServiceTest.java +++ b/src/test/java/com/netgrif/application/engine/workflow/service/TaskServiceTest.java @@ -19,6 +19,7 @@ import com.netgrif.application.engine.startup.SystemUserRunner; import com.netgrif.application.engine.startup.UriRunner; import com.netgrif.application.engine.workflow.domain.Case; +import com.netgrif.application.engine.workflow.domain.QCase; import com.netgrif.application.engine.workflow.domain.Task; import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.caseoutcomes.CreateCaseEventOutcome; import com.netgrif.application.engine.workflow.domain.params.CreateCaseParams; @@ -40,6 +41,9 @@ import java.io.FileInputStream; import java.io.IOException; import java.util.Collections; +import java.util.Objects; + +import static org.junit.jupiter.api.Assertions.assertThrows; @SpringBootTest @ActiveProfiles({"test"}) @@ -84,6 +88,8 @@ public class TaskServiceTest { @Autowired private SuperAdminConfiguration configuration; + @Autowired + private TaskService taskService; @BeforeEach public void setUp() throws Exception { @@ -151,4 +157,146 @@ public LoggedUser mockLoggedUser() { Authority authorityUser = authorityService.getOrCreate(Authority.user); return new LoggedUser(new ObjectId().toString(), configuration.getEmail(), configuration.getPassword(), Collections.singleton(authorityUser)); } + + @Test + public void testTransactionalAssignTaskFailure() throws IOException, MissingPetriNetMetaDataException, TransitionNotExecutableException { + String taskId = createCaseAndReturnTaskId("src/test/resources/transactional_task_event_test.xml", + "assignTest"); + + TaskParams taskParams = TaskParams.with() + .isTransactional(true) + .taskId(taskId) + .user(superCreator.getSuperUser()) + .build(); + + assertThrows(RuntimeException.class, () -> taskService.assignTask(taskParams)); + + Task aTask = taskService.findOne(taskId); + assert aTask.getUserId() == null; + assert workflowService.searchOne(QCase.case$.title.eq("CasePre")) == null; + assert workflowService.searchOne(QCase.case$.title.eq("CasePost")) == null; + } + + @Test + public void testNonTransactionalAssignTaskFailure() throws IOException, MissingPetriNetMetaDataException { + String taskId = createCaseAndReturnTaskId("src/test/resources/transactional_task_event_test.xml", + "assignTest"); + + TaskParams taskParams = TaskParams.with() + .isTransactional(false) + .taskId(taskId) + .user(superCreator.getSuperUser()) + .build(); + + assertThrows(RuntimeException.class, () -> taskService.assignTask(taskParams)); + + Task aTask = taskService.findOne(taskId); + assert aTask.getUserId() != null; + assert workflowService.searchOne(QCase.case$.title.eq("CasePre")) != null; + assert workflowService.searchOne(QCase.case$.title.eq("CasePost")) != null; + } + + @Test + public void testTransactionalCancelTaskFailure() throws IOException, MissingPetriNetMetaDataException, TransitionNotExecutableException { + String taskId = createCaseAndReturnTaskId("src/test/resources/transactional_task_event_test.xml", + "cancelTest"); + + TaskParams taskParams = TaskParams.with() + .isTransactional(false) + .taskId(taskId) + .user(superCreator.getSuperUser()) + .build(); + + Task aTask = taskService.assignTask(taskParams).getTask(); + assert Objects.equals(aTask.getUserId(), superCreator.getSuperUser().getStringId()); + + taskParams.setTransactional(true); + assertThrows(RuntimeException.class, () -> taskService.cancelTask(taskParams)); + + aTask = taskService.findOne(taskId); + assert Objects.equals(aTask.getUserId(), superCreator.getSuperUser().getStringId()); + assert workflowService.searchOne(QCase.case$.title.eq("CasePre")) == null; + assert workflowService.searchOne(QCase.case$.title.eq("CasePost")) == null; + } + + @Test + public void testNonTransactionalCancelTaskFailure() throws IOException, MissingPetriNetMetaDataException, TransitionNotExecutableException { + String taskId = createCaseAndReturnTaskId("src/test/resources/transactional_task_event_test.xml", + "cancelTest"); + + TaskParams taskParams = TaskParams.with() + .isTransactional(false) + .taskId(taskId) + .user(superCreator.getSuperUser()) + .build(); + + Task aTask = taskService.assignTask(taskParams).getTask(); + assert Objects.equals(aTask.getUserId(), superCreator.getSuperUser().getStringId()); + + assertThrows(RuntimeException.class, () -> taskService.cancelTask(taskParams)); + + aTask = taskService.findOne(taskId); + assert aTask.getUserId() == null; + assert workflowService.searchOne(QCase.case$.title.eq("CasePre")) != null; + assert workflowService.searchOne(QCase.case$.title.eq("CasePost")) != null; + } + + @Test + public void testTransactionalFinishTaskFailure() throws IOException, MissingPetriNetMetaDataException, TransitionNotExecutableException { + String taskId = createCaseAndReturnTaskId("src/test/resources/transactional_task_event_test.xml", + "finishTest"); + + TaskParams taskParams = TaskParams.with() + .isTransactional(false) + .taskId(taskId) + .user(superCreator.getSuperUser()) + .build(); + + Task aTask = taskService.assignTask(taskParams).getTask(); + assert Objects.equals(aTask.getUserId(), superCreator.getSuperUser().getStringId()); + + taskParams.setTransactional(true); + assertThrows(RuntimeException.class, () -> taskService.finishTask(taskParams)); + + aTask = taskService.findOne(taskId); + assert Objects.equals(aTask.getUserId(), superCreator.getSuperUser().getStringId()); + assert aTask.getFinishedBy() == null; + assert workflowService.searchOne(QCase.case$.title.eq("CasePre")) == null; + assert workflowService.searchOne(QCase.case$.title.eq("CasePost")) == null; + } + + @Test + public void testNonTransactionalFinishTaskFailure() throws IOException, MissingPetriNetMetaDataException, TransitionNotExecutableException { + String taskId = createCaseAndReturnTaskId("src/test/resources/transactional_task_event_test.xml", + "finishTest"); + + TaskParams taskParams = TaskParams.with() + .isTransactional(false) + .taskId(taskId) + .user(superCreator.getSuperUser()) + .build(); + + Task aTask = taskService.assignTask(taskParams).getTask(); + assert Objects.equals(aTask.getUserId(), superCreator.getSuperUser().getStringId()); + + assertThrows(RuntimeException.class, () -> taskService.finishTask(taskParams)); + + aTask = taskService.findOne(taskId); + assert aTask.getUserId() == null; + assert aTask.getFinishedBy().equals(superCreator.getSuperUser().getStringId()); + assert workflowService.searchOne(QCase.case$.title.eq("CasePre")) != null; + assert workflowService.searchOne(QCase.case$.title.eq("CasePost")) != null; + } + + private String createCaseAndReturnTaskId(String filePath, String transId) throws IOException, MissingPetriNetMetaDataException { + PetriNet net = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream(filePath), VersionType.MAJOR, superCreator.getLoggedSuper())).getNet(); + + CreateCaseParams createCaseParams = CreateCaseParams.with() + .petriNet(net) + .loggedUser(superCreator.getLoggedSuper()) + .build(); + Case useCase = workflowService.createCase(createCaseParams).getCase(); + return useCase.getTaskStringId(transId); + } } \ No newline at end of file diff --git a/src/test/resources/transactional_task_event_test.xml b/src/test/resources/transactional_task_event_test.xml new file mode 100644 index 00000000000..726fb0bd33c --- /dev/null +++ b/src/test/resources/transactional_task_event_test.xml @@ -0,0 +1,68 @@ + + + transactional_task_event_test + TST + Test + true + + assignTest + 0 + 0 + + + 1 + + + createCase("transactional_task_event_test", "CasePre") + + + + + createCase("transactional_task_event_test", "CasePost") + throw new RuntimeException("error on purpose") + + + + + + cancelTest + 0 + 0 + + + 2 + + + createCase("transactional_task_event_test", "CasePre") + + + + + createCase("transactional_task_event_test", "CasePost") + throw new RuntimeException("error on purpose") + + + + + + finishTest + 0 + 0 + + + 3 + + + createCase("transactional_task_event_test", "CasePre") + + + + + createCase("transactional_task_event_test", "CasePost") + throw new RuntimeException("error on purpose") + + + + + \ No newline at end of file From 0770948f02ea19de65c838fd10b23b7d42c8152c Mon Sep 17 00:00:00 2001 From: chvostek Date: Tue, 27 Aug 2024 14:47:51 +0200 Subject: [PATCH 44/48] [NAE-1998] Implement transactions for events - make PetriNetService.importPetriNet optionally transactional - fix handling non-existing petriNets in PetriNetService.findByImportId - implement new tests in PetriNetServiceTest --- .../domain/params/ImportPetriNetParams.java | 2 + .../petrinet/service/PetriNetService.java | 35 +++++++++++++++- .../service/PetriNetServiceTest.groovy | 41 +++++++++++++++++++ .../resources/petriNet_import_failure.xml | 23 +++++++++++ 4 files changed, 100 insertions(+), 1 deletion(-) create mode 100644 src/test/resources/petriNet_import_failure.xml diff --git a/src/main/java/com/netgrif/application/engine/petrinet/domain/params/ImportPetriNetParams.java b/src/main/java/com/netgrif/application/engine/petrinet/domain/params/ImportPetriNetParams.java index 178564e1900..8095c6bd08f 100644 --- a/src/main/java/com/netgrif/application/engine/petrinet/domain/params/ImportPetriNetParams.java +++ b/src/main/java/com/netgrif/application/engine/petrinet/domain/params/ImportPetriNetParams.java @@ -20,6 +20,8 @@ public class ImportPetriNetParams { private VersionType releaseType; private LoggedUser author; @Builder.Default + private boolean isTransactional = false; + @Builder.Default private Map params = new HashMap<>(); public ImportPetriNetParams(InputStream xmlFile, VersionType releaseType, LoggedUser author, String uriNodeId) { diff --git a/src/main/java/com/netgrif/application/engine/petrinet/service/PetriNetService.java b/src/main/java/com/netgrif/application/engine/petrinet/service/PetriNetService.java index b4f3abcac74..b370b4c39df 100644 --- a/src/main/java/com/netgrif/application/engine/petrinet/service/PetriNetService.java +++ b/src/main/java/com/netgrif/application/engine/petrinet/service/PetriNetService.java @@ -31,12 +31,14 @@ import com.netgrif.application.engine.petrinet.web.responsebodies.*; import com.netgrif.application.engine.rules.domain.facts.NetImportedFact; import com.netgrif.application.engine.rules.service.interfaces.IRuleEngine; +import com.netgrif.application.engine.transaction.NaeTransaction; import com.netgrif.application.engine.workflow.domain.Case; import com.netgrif.application.engine.workflow.domain.FileStorageConfiguration; import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome; import com.netgrif.application.engine.workflow.service.interfaces.IEventService; import com.netgrif.application.engine.workflow.service.interfaces.IFieldActionsCacheService; import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowService; +import groovy.lang.Closure; import lombok.extern.slf4j.Slf4j; import org.apache.tomcat.util.http.fileupload.IOUtils; import org.bson.Document; @@ -46,6 +48,7 @@ import org.springframework.cache.annotation.Cacheable; import org.springframework.core.io.FileSystemResource; import org.springframework.data.domain.*; +import org.springframework.data.mongodb.MongoTransactionManager; import org.springframework.data.mongodb.core.MongoTemplate; import org.springframework.data.mongodb.core.aggregation.Aggregation; import org.springframework.data.mongodb.core.aggregation.AggregationResults; @@ -53,6 +56,8 @@ import org.springframework.data.mongodb.core.query.Criteria; import org.springframework.data.mongodb.core.query.Query; import org.springframework.stereotype.Service; +import org.springframework.transaction.TransactionDefinition; +import org.springframework.transaction.support.TransactionSynchronizationManager; import javax.annotation.Resource; import javax.inject.Provider; @@ -124,6 +129,9 @@ public class PetriNetService implements IPetriNetService { @Autowired private IUriService uriService; + @Autowired + private MongoTransactionManager transactionManager; + private IElasticPetriNetService elasticPetriNetService; @Autowired @@ -197,6 +205,30 @@ public ImportPetriNetEventOutcome importPetriNet(ImportPetriNetParams importPetr MissingPetriNetMetaDataException, MissingIconKeyException { fillMissingAttributes(importPetriNetParams); + if (importPetriNetParams.isTransactional() && !TransactionSynchronizationManager.isSynchronizationActive()) { + NaeTransaction transaction = NaeTransaction.builder() + .timeout(TransactionDefinition.TIMEOUT_DEFAULT) + .forceCreation(false) + .transactionManager(transactionManager) + .event(new Closure(null) { + @Override + public ImportPetriNetEventOutcome call() { + try { + return doImportPetriNet(importPetriNetParams); + } catch (MissingPetriNetMetaDataException | IOException e) { + throw new RuntimeException(e); + } + } + }) + .build(); + transaction.begin(); + return (ImportPetriNetEventOutcome) transaction.getResultOfEvent(); + } else { + return doImportPetriNet(importPetriNetParams); + } + } + + private ImportPetriNetEventOutcome doImportPetriNet(ImportPetriNetParams importPetriNetParams) throws MissingPetriNetMetaDataException, IOException { ImportPetriNetEventOutcome outcome = new ImportPetriNetEventOutcome(); ByteArrayOutputStream xmlCopy = new ByteArrayOutputStream(); IOUtils.copy(importPetriNetParams.getXmlFile(), xmlCopy); @@ -471,7 +503,8 @@ public List getDataFieldReferences(List @Override public Optional findByImportId(String id) { - return Optional.of(repository.findByImportId(id)); + PetriNet net = repository.findByImportId(id); + return net == null ? Optional.empty() : Optional.of(net); } @Override diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/service/PetriNetServiceTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/service/PetriNetServiceTest.groovy index cda45d3fe62..9d975461d95 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/service/PetriNetServiceTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/service/PetriNetServiceTest.groovy @@ -19,6 +19,7 @@ import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetServi import com.netgrif.application.engine.petrinet.service.interfaces.IProcessRoleService import com.netgrif.application.engine.startup.ImportHelper import com.netgrif.application.engine.startup.SuperCreator +import com.netgrif.application.engine.workflow.domain.QCase import com.netgrif.application.engine.workflow.domain.outcomes.eventoutcomes.petrinetoutcomes.ImportPetriNetEventOutcome import com.netgrif.application.engine.workflow.domain.repositories.CaseRepository import com.netgrif.application.engine.workflow.domain.repositories.TaskRepository @@ -34,6 +35,8 @@ import org.springframework.data.domain.PageRequest 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 @@ -41,6 +44,9 @@ class PetriNetServiceTest { public static final String NET_FILE = "process_delete_test.xml" public static final String NET_SEARCH_FILE = "process_search_test.xml" + public static final String NET_IMPORT_FILE = "net_import_1.xml" + public static final String PETRINET_IMPORT_FAILURE_FILE = "petriNet_import_failure.xml" + public static final String PETRINET_IMPORT_FAILURE_IDENTIFIER = "petriNet_import_failure" public static final String CUSTOMER_USER_MAIL = "customer@netgrif.com" @Autowired @@ -224,4 +230,39 @@ class PetriNetServiceTest { search8.setAuthor(author) assert petriNetService.search(search8, superCreator.getLoggedSuper(), PageRequest.of(0, 50), LocaleContextHolder.locale).getNumberOfElements() == 1 } + + @Test + void testTransactionalImportFailure() { + ImportPetriNetParams importPetriNetParams = ImportPetriNetParams.with() + .isTransactional(true) + .xmlFile(stream(PETRINET_IMPORT_FAILURE_FILE)) + .releaseType(VersionType.MAJOR) + .author(superCreator.getLoggedSuper()) + .build() + + assertThrows(RuntimeException.class, { petriNetService.importPetriNet(importPetriNetParams) }) + + assert petriNetService.findByImportId(PETRINET_IMPORT_FAILURE_IDENTIFIER).isEmpty() + assert workflowService.searchOne(QCase.case$.title.eq("CaseFromPre")) == null + assert workflowService.searchOne(QCase.case$.title.eq("CaseFromPost")) == null + } + + @Test + void testNonTransactionalImportFailure() { + petriNetService.importPetriNet(new ImportPetriNetParams(stream(NET_IMPORT_FILE), VersionType.MAJOR, + superCreator.getLoggedSuper())) + + ImportPetriNetParams importPetriNetParams = ImportPetriNetParams.with() + .isTransactional(false) + .xmlFile(stream(PETRINET_IMPORT_FAILURE_FILE)) + .releaseType(VersionType.MAJOR) + .author(superCreator.getLoggedSuper()) + .build() + + assertThrows(RuntimeException.class, { petriNetService.importPetriNet(importPetriNetParams) }) + + assert petriNetService.findByImportId(PETRINET_IMPORT_FAILURE_IDENTIFIER).isPresent() + assert workflowService.searchOne(QCase.case$.title.eq("CaseFromPre")) != null + assert workflowService.searchOne(QCase.case$.title.eq("CaseFromPost")) != null + } } diff --git a/src/test/resources/petriNet_import_failure.xml b/src/test/resources/petriNet_import_failure.xml new file mode 100644 index 00000000000..dac608920d9 --- /dev/null +++ b/src/test/resources/petriNet_import_failure.xml @@ -0,0 +1,23 @@ + + + petriNet_import_failure + TST + Test + + + 123 + + + createCase("new_model", "CaseFromPre") + + + + + createCase("new_model", "CaseFromPost") + throw new RuntimeException("error on purpose") + + + + + \ No newline at end of file From 77fca7b3fbbf4a37e4298bb285f06e0c99eeb136 Mon Sep 17 00:00:00 2001 From: chvostek Date: Wed, 28 Aug 2024 09:03:19 +0200 Subject: [PATCH 45/48] [NAE-1998] Implement transactions for events - refactor PetriNetService.deletePetriNet - make PetriNetService.deletePetriNet optionally transactional - optimize NaeTransaction build up --- .../dataset/logic/action/ActionRunner.groovy | 2 - .../domain/params/DeletePetriNetParams.java | 23 +++++++++++ .../petrinet/service/PetriNetService.java | 38 ++++++++++++++++--- .../service/interfaces/IPetriNetService.java | 3 +- .../petrinet/web/PetriNetController.java | 3 +- .../engine/transaction/NaeTransaction.java | 13 ++++--- .../engine/workflow/service/DataService.java | 4 -- .../engine/workflow/service/TaskService.java | 6 --- .../workflow/service/WorkflowService.java | 4 -- .../petrinet/domain/FunctionsTest.groovy | 16 +++++--- .../service/PetriNetServiceTest.groovy | 3 +- 11 files changed, 81 insertions(+), 34 deletions(-) create mode 100644 src/main/java/com/netgrif/application/engine/petrinet/domain/params/DeletePetriNetParams.java diff --git a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionRunner.groovy b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionRunner.groovy index d69510f629f..3570419126b 100644 --- a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionRunner.groovy +++ b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ActionRunner.groovy @@ -45,8 +45,6 @@ abstract class ActionRunner { code.init(action, useCase, task, changes, this, params) if (TransactionSynchronizationManager.isSynchronizationActive()) { def transaction = NaeTransaction.builder() - .timeout(TransactionDefinition.TIMEOUT_DEFAULT) - .forceCreation(false) .transactionManager(transactionManager) .event(code) .build() diff --git a/src/main/java/com/netgrif/application/engine/petrinet/domain/params/DeletePetriNetParams.java b/src/main/java/com/netgrif/application/engine/petrinet/domain/params/DeletePetriNetParams.java new file mode 100644 index 00000000000..5ebc8a1255b --- /dev/null +++ b/src/main/java/com/netgrif/application/engine/petrinet/domain/params/DeletePetriNetParams.java @@ -0,0 +1,23 @@ +package com.netgrif.application.engine.petrinet.domain.params; + + +import com.netgrif.application.engine.auth.domain.LoggedUser; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; + +@Data +@AllArgsConstructor +@Builder(builderMethodName = "with") +public class DeletePetriNetParams { + + private String petriNetId; + private LoggedUser loggedUser; + @Builder.Default + private boolean isTransactional = false; + + public DeletePetriNetParams(String petriNetId, LoggedUser loggedUser) { + this.petriNetId = petriNetId; + this.loggedUser = loggedUser; + } +} diff --git a/src/main/java/com/netgrif/application/engine/petrinet/service/PetriNetService.java b/src/main/java/com/netgrif/application/engine/petrinet/service/PetriNetService.java index b370b4c39df..f7a198d9c1f 100644 --- a/src/main/java/com/netgrif/application/engine/petrinet/service/PetriNetService.java +++ b/src/main/java/com/netgrif/application/engine/petrinet/service/PetriNetService.java @@ -21,6 +21,7 @@ import com.netgrif.application.engine.petrinet.domain.dataset.logic.action.Action; import com.netgrif.application.engine.petrinet.domain.dataset.logic.action.ActionRunner; import com.netgrif.application.engine.petrinet.domain.events.EventPhase; +import com.netgrif.application.engine.petrinet.domain.params.DeletePetriNetParams; import com.netgrif.application.engine.petrinet.domain.params.ImportPetriNetParams; import com.netgrif.application.engine.petrinet.domain.repositories.PetriNetRepository; import com.netgrif.application.engine.petrinet.domain.throwable.MissingPetriNetMetaDataException; @@ -207,8 +208,6 @@ public ImportPetriNetEventOutcome importPetriNet(ImportPetriNetParams importPetr if (importPetriNetParams.isTransactional() && !TransactionSynchronizationManager.isSynchronizationActive()) { NaeTransaction transaction = NaeTransaction.builder() - .timeout(TransactionDefinition.TIMEOUT_DEFAULT) - .forceCreation(false) .transactionManager(transactionManager) .event(new Closure(null) { @Override @@ -565,8 +564,38 @@ private void addValueCriteria(Query query, Query queryTotal, Criteria criteria) queryTotal.addCriteria(criteria); } + /** + * Removes {@link PetriNet} along with its Cases and roles + * + * @param deletePetriNetParams parameters for PetriNet removal + *
+ * Required parameters + *
    + *
  • petriNetId
    • + *
+ * */ @Override - public void deletePetriNet(String processId, LoggedUser loggedUser) { + public void deletePetriNet(DeletePetriNetParams deletePetriNetParams) { + if (deletePetriNetParams.isTransactional() && !TransactionSynchronizationManager.isSynchronizationActive()) { + NaeTransaction transaction = NaeTransaction.builder() + .transactionManager(transactionManager) + .event(new Closure<>(null) { + @Override + public Object call() { + doDeletePetriNet(deletePetriNetParams); + return null; + } + }) + .build(); + transaction.begin(); + } else { + doDeletePetriNet(deletePetriNetParams); + } + } + + private void doDeletePetriNet(DeletePetriNetParams deletePetriNetParams) { + String processId = deletePetriNetParams.getPetriNetId(); + Optional petriNetOptional = repository.findById(processId); if (petriNetOptional.isEmpty()) { throw new IllegalArgumentException("Could not find process with id [" + processId + "]"); @@ -577,7 +606,7 @@ public void deletePetriNet(String processId, LoggedUser loggedUser) { this.userService.removeRoleOfDeletedPetriNet(petriNet); this.workflowService.deleteInstancesOfPetriNet(petriNet); - this.processRoleService.deleteRolesOfNet(petriNet, loggedUser); + this.processRoleService.deleteRolesOfNet(petriNet, deletePetriNetParams.getLoggedUser()); try { ldapGroupService.deleteProcessRoleByPetrinet(petriNet.getStringId()); } catch (NullPointerException e) { @@ -586,7 +615,6 @@ public void deletePetriNet(String processId, LoggedUser loggedUser) { log.error("LdapGroup", ex); } - log.info("[{}]: User [{}] is deleting Petri net {} version {}", processId, userService.getLoggedOrSystem().getStringId(), petriNet.getIdentifier(), petriNet.getVersion().toString()); this.repository.deleteById(petriNet.getObjectId()); diff --git a/src/main/java/com/netgrif/application/engine/petrinet/service/interfaces/IPetriNetService.java b/src/main/java/com/netgrif/application/engine/petrinet/service/interfaces/IPetriNetService.java index 825c7fc9ce7..b9fba5a7244 100644 --- a/src/main/java/com/netgrif/application/engine/petrinet/service/interfaces/IPetriNetService.java +++ b/src/main/java/com/netgrif/application/engine/petrinet/service/interfaces/IPetriNetService.java @@ -7,6 +7,7 @@ import com.netgrif.application.engine.petrinet.domain.Transition; import com.netgrif.application.engine.petrinet.domain.dataset.Field; import com.netgrif.application.engine.petrinet.domain.dataset.logic.action.Action; +import com.netgrif.application.engine.petrinet.domain.params.DeletePetriNetParams; import com.netgrif.application.engine.petrinet.domain.params.ImportPetriNetParams; import com.netgrif.application.engine.petrinet.domain.throwable.MissingPetriNetMetaDataException; import com.netgrif.application.engine.petrinet.domain.version.Version; @@ -91,7 +92,7 @@ static DataFieldReference transformToReference(PetriNet net, Transition transiti List get(List petriNetIds); - void deletePetriNet(String id, LoggedUser loggedUser); + void deletePetriNet(DeletePetriNetParams deletePetriNetParams); void runActions(List actions, PetriNet petriNet); diff --git a/src/main/java/com/netgrif/application/engine/petrinet/web/PetriNetController.java b/src/main/java/com/netgrif/application/engine/petrinet/web/PetriNetController.java index f8862d6ee96..4eacba1cebc 100644 --- a/src/main/java/com/netgrif/application/engine/petrinet/web/PetriNetController.java +++ b/src/main/java/com/netgrif/application/engine/petrinet/web/PetriNetController.java @@ -7,6 +7,7 @@ import com.netgrif.application.engine.petrinet.domain.PetriNet; import com.netgrif.application.engine.petrinet.domain.PetriNetSearch; import com.netgrif.application.engine.petrinet.domain.VersionType; +import com.netgrif.application.engine.petrinet.domain.params.DeletePetriNetParams; import com.netgrif.application.engine.petrinet.domain.params.ImportPetriNetParams; import com.netgrif.application.engine.petrinet.domain.throwable.MissingPetriNetMetaDataException; import com.netgrif.application.engine.petrinet.domain.version.StringToVersionConverter; @@ -201,7 +202,7 @@ public MessageResource deletePetriNet(@PathVariable("id") String processId, Auth return MessageResource.errorMessage("Deleting Petri net " + processId + " failed!"); } LoggedUser user = (LoggedUser) auth.getPrincipal(); - asyncRunner.execute(() -> this.service.deletePetriNet(decodedProcessId, user)); + asyncRunner.execute(() -> this.service.deletePetriNet(new DeletePetriNetParams(decodedProcessId, user))); return MessageResource.successMessage("Petri net " + decodedProcessId + " is being deleted"); } diff --git a/src/main/java/com/netgrif/application/engine/transaction/NaeTransaction.java b/src/main/java/com/netgrif/application/engine/transaction/NaeTransaction.java index c58caf5b1a7..10fa60c8072 100644 --- a/src/main/java/com/netgrif/application/engine/transaction/NaeTransaction.java +++ b/src/main/java/com/netgrif/application/engine/transaction/NaeTransaction.java @@ -26,12 +26,14 @@ public class NaeTransaction { /** * Timeout for the transaction in milliseconds. When the timeout is reached, transaction fails on commit. * */ - private int timeout; + @Builder.Default + private int timeout = TransactionDefinition.TIMEOUT_DEFAULT; /** * If set to true, new transaction is created in any situation (uses {@link Propagation#REQUIRES_NEW}). If set to * false, transaction is created only if none exists (uses {@link Propagation#REQUIRED}). * */ - private boolean forceCreation; + @Builder.Default + private boolean forceCreation = false; /** * Transaction code to be executed under transaction. * */ @@ -52,7 +54,8 @@ public class NaeTransaction { private Exception onCallBackException; private Exception onEventException; - private Propagation propagation; + @Builder.Default + private Propagation propagation = Propagation.REQUIRED; private Date deadline; private boolean wasRolledBack; @@ -166,8 +169,8 @@ private void throwIfDeadlineReached() throws TransactionTimedOutException { * */ public static class NaeTransactionBuilder { public NaeTransactionBuilder forceCreation(boolean forceCreation) { - propagation = forceCreation ? Propagation.REQUIRES_NEW : Propagation.REQUIRED; - this.forceCreation = forceCreation; + this.propagation$value = forceCreation ? Propagation.REQUIRES_NEW : Propagation.REQUIRED; + this.forceCreation$value = forceCreation; return this; } } diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/DataService.java b/src/main/java/com/netgrif/application/engine/workflow/service/DataService.java index 71390114711..885b55713ce 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/DataService.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/DataService.java @@ -117,8 +117,6 @@ public GetDataEventOutcome getData(GetDataParams getDataParams) { if (getDataParams.isTransactional() && !TransactionSynchronizationManager.isSynchronizationActive()) { NaeTransaction transaction = NaeTransaction.builder() - .timeout(TransactionDefinition.TIMEOUT_DEFAULT) - .forceCreation(false) .transactionManager(transactionManager) .event(new Closure(null) { @Override @@ -214,8 +212,6 @@ public SetDataEventOutcome setData(SetDataParams setDataParams) { if (setDataParams.isTransactional() && !TransactionSynchronizationManager.isSynchronizationActive()) { NaeTransaction transaction = NaeTransaction.builder() - .timeout(TransactionDefinition.TIMEOUT_DEFAULT) - .forceCreation(false) .transactionManager(transactionManager) .event(new Closure(null) { @Override diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/TaskService.java b/src/main/java/com/netgrif/application/engine/workflow/service/TaskService.java index 2cb0cf68cbc..a774ee09a2d 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/TaskService.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/TaskService.java @@ -185,8 +185,6 @@ public AssignTaskEventOutcome assignTask(TaskParams taskParams) throws Transitio if (taskParams.isTransactional() && !TransactionSynchronizationManager.isSynchronizationActive()) { NaeTransaction transaction = NaeTransaction.builder() - .timeout(TransactionDefinition.TIMEOUT_DEFAULT) - .forceCreation(false) .transactionManager(transactionManager) .event(new Closure(null) { @Override @@ -315,8 +313,6 @@ public FinishTaskEventOutcome finishTask(TaskParams taskParams) throws Transitio if (taskParams.isTransactional() && !TransactionSynchronizationManager.isSynchronizationActive()) { NaeTransaction transaction = NaeTransaction.builder() - .timeout(TransactionDefinition.TIMEOUT_DEFAULT) - .forceCreation(false) .transactionManager(transactionManager) .event(new Closure(null) { @Override @@ -446,8 +442,6 @@ public CancelTaskEventOutcome cancelTask(TaskParams taskParams) { if (taskParams.isTransactional() && !TransactionSynchronizationManager.isSynchronizationActive()) { NaeTransaction transaction = NaeTransaction.builder() - .timeout(TransactionDefinition.TIMEOUT_DEFAULT) - .forceCreation(false) .transactionManager(transactionManager) .event(new Closure(null) { @Override diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/WorkflowService.java b/src/main/java/com/netgrif/application/engine/workflow/service/WorkflowService.java index 9505e0dbef0..4c7bf0ec766 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/WorkflowService.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/WorkflowService.java @@ -227,8 +227,6 @@ public CreateCaseEventOutcome createCase(CreateCaseParams createCaseParams) { if (createCaseParams.isTransactional() && !TransactionSynchronizationManager.isSynchronizationActive()) { NaeTransaction transaction = NaeTransaction.builder() - .timeout(TransactionDefinition.TIMEOUT_DEFAULT) - .forceCreation(false) .transactionManager(transactionManager) .event(new Closure(null) { @Override @@ -378,8 +376,6 @@ public DeleteCaseEventOutcome deleteCase(DeleteCaseParams deleteCaseParams) { if (deleteCaseParams.isTransactional() && !TransactionSynchronizationManager.isSynchronizationActive()) { NaeTransaction transaction = NaeTransaction.builder() - .timeout(TransactionDefinition.TIMEOUT_DEFAULT) - .forceCreation(false) .transactionManager(transactionManager) .event(new Closure(null) { @Override diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/FunctionsTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/FunctionsTest.groovy index 3257e6815be..bdf7c84bab4 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/FunctionsTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/FunctionsTest.groovy @@ -4,6 +4,7 @@ import com.netgrif.application.engine.TestHelper import com.netgrif.application.engine.auth.domain.IUser import com.netgrif.application.engine.auth.service.interfaces.IUserService import com.netgrif.application.engine.petrinet.domain.dataset.* +import com.netgrif.application.engine.petrinet.domain.params.DeletePetriNetParams import com.netgrif.application.engine.petrinet.domain.params.ImportPetriNetParams import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService import com.netgrif.application.engine.startup.SuperCreator @@ -114,8 +115,10 @@ class FunctionsTest { assert user userService.deleteUser(user) - petriNetService.deletePetriNet(functionResNet.stringId, userService.getLoggedOrSystem().transformToLoggedUser()) - petriNetService.deletePetriNet(functionTestNet.stringId, userService.getLoggedOrSystem().transformToLoggedUser()) + petriNetService.deletePetriNet(new DeletePetriNetParams(functionResNet.stringId, + userService.getLoggedOrSystem().transformToLoggedUser())) + petriNetService.deletePetriNet(new DeletePetriNetParams(functionTestNet.stringId, + userService.getLoggedOrSystem().transformToLoggedUser())) } @Test @@ -144,7 +147,8 @@ class FunctionsTest { def fieldBehavior = field.behaviors assert fieldBehavior.get("1").behavior == EDITABLE - petriNetService.deletePetriNet(functionTestNet.stringId, userService.getLoggedOrSystem().transformToLoggedUser()) + petriNetService.deletePetriNet(new DeletePetriNetParams(functionTestNet.stringId, + userService.getLoggedOrSystem().transformToLoggedUser())) } @Test @@ -157,7 +161,8 @@ class FunctionsTest { def nets = petriNetService.getByIdentifier(FUNCTION_RES_IDENTIFIER) if (nets) { nets.each { - petriNetService.deletePetriNet(it.getStringId(), userService.getLoggedOrSystem().transformToLoggedUser()) + petriNetService.deletePetriNet(new DeletePetriNetParams(it.getStringId(), + userService.getLoggedOrSystem().transformToLoggedUser())) } } @@ -183,7 +188,8 @@ class FunctionsTest { def nets = petriNetService.getByIdentifier(FUNCTION_TEST_IDENTIFIER) if (nets) { nets.each { - petriNetService.deletePetriNet(it.getStringId(), userService.getLoggedOrSystem().transformToLoggedUser()) + petriNetService.deletePetriNet(new DeletePetriNetParams(it.getStringId(), + userService.getLoggedOrSystem().transformToLoggedUser())) } } diff --git a/src/test/groovy/com/netgrif/application/engine/petrinet/service/PetriNetServiceTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/service/PetriNetServiceTest.groovy index 9d975461d95..0d6adae7bd0 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/service/PetriNetServiceTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/service/PetriNetServiceTest.groovy @@ -10,6 +10,7 @@ import com.netgrif.application.engine.elastic.domain.ElasticPetriNet import com.netgrif.application.engine.elastic.domain.ElasticPetriNetRepository import com.netgrif.application.engine.ipc.TaskApiTest import com.netgrif.application.engine.petrinet.domain.* +import com.netgrif.application.engine.petrinet.domain.params.DeletePetriNetParams import com.netgrif.application.engine.petrinet.domain.params.ImportPetriNetParams import com.netgrif.application.engine.petrinet.domain.repositories.PetriNetRepository import com.netgrif.application.engine.petrinet.domain.roles.ProcessRole @@ -134,7 +135,7 @@ class PetriNetServiceTest { assert user.processRoles.size() == 2 assert petriNetService.get(new ObjectId(testNet.stringId)) != null - petriNetService.deletePetriNet(testNet.stringId, superCreator.getLoggedSuper()) + petriNetService.deletePetriNet(new DeletePetriNetParams(testNet.stringId, superCreator.getLoggedSuper())) assert petriNetRepository.count() == processCount Thread.sleep(5000) assert elasticPetriNetRepository.findByStringId(testNet.stringId) == null From 110e14538f285cfa11085796e426c63cbd351aa1 Mon Sep 17 00:00:00 2001 From: chvostek Date: Wed, 28 Aug 2024 10:47:00 +0200 Subject: [PATCH 46/48] [NAE-1998] Implement transactions for events - implement and apply NaeTransactionProperties with default values - fix NaeTransactionBuilder.forceCreation - add and use application-test-transaction.properties --- .../engine/transaction/NaeTransaction.java | 4 ++++ .../configuration/NaeTransactionProperties.java | 16 ++++++++++++++++ .../workflow/domain/params/CreateCaseParams.java | 3 +-- .../workflow/domain/params/DeleteCaseParams.java | 3 +-- .../workflow/domain/params/GetDataParams.java | 3 +-- .../workflow/domain/params/SetDataParams.java | 3 +-- .../workflow/domain/params/TaskParams.java | 3 +-- .../engine/workflow/service/DataService.java | 14 ++++++++++++-- .../engine/workflow/service/TaskService.java | 13 ++++++++++--- .../engine/workflow/service/WorkflowService.java | 15 ++++++++++++--- .../engine/transaction/TransactionTest.groovy | 2 +- .../engine/workflow/service/TaskServiceTest.java | 6 +++--- .../application-test-transaction.properties | 6 ++++++ 13 files changed, 69 insertions(+), 22 deletions(-) create mode 100644 src/main/java/com/netgrif/application/engine/transaction/configuration/NaeTransactionProperties.java create mode 100644 src/test/resources/application-test-transaction.properties diff --git a/src/main/java/com/netgrif/application/engine/transaction/NaeTransaction.java b/src/main/java/com/netgrif/application/engine/transaction/NaeTransaction.java index 10fa60c8072..8cb7f46d85a 100644 --- a/src/main/java/com/netgrif/application/engine/transaction/NaeTransaction.java +++ b/src/main/java/com/netgrif/application/engine/transaction/NaeTransaction.java @@ -169,8 +169,12 @@ private void throwIfDeadlineReached() throws TransactionTimedOutException { * */ public static class NaeTransactionBuilder { public NaeTransactionBuilder forceCreation(boolean forceCreation) { + this.propagation$set = true; this.propagation$value = forceCreation ? Propagation.REQUIRES_NEW : Propagation.REQUIRED; + + this.forceCreation$set = true; this.forceCreation$value = forceCreation; + return this; } } diff --git a/src/main/java/com/netgrif/application/engine/transaction/configuration/NaeTransactionProperties.java b/src/main/java/com/netgrif/application/engine/transaction/configuration/NaeTransactionProperties.java new file mode 100644 index 00000000000..81643889ddc --- /dev/null +++ b/src/main/java/com/netgrif/application/engine/transaction/configuration/NaeTransactionProperties.java @@ -0,0 +1,16 @@ +package com.netgrif.application.engine.transaction.configuration; + +import lombok.Data; +import org.springframework.boot.context.properties.ConfigurationProperties; +import org.springframework.context.annotation.Configuration; + +@Data +@Configuration +@ConfigurationProperties(prefix = "nae.transaction") +public class NaeTransactionProperties { + private boolean createCaseTransactional = true; + private boolean deleteCaseTransactional = true; + private boolean setDataTransactional = true; + private boolean getDataTransactional = true; + private boolean taskEventTransactional = true; +} diff --git a/src/main/java/com/netgrif/application/engine/workflow/domain/params/CreateCaseParams.java b/src/main/java/com/netgrif/application/engine/workflow/domain/params/CreateCaseParams.java index abda8951fa0..ff2201dd247 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/domain/params/CreateCaseParams.java +++ b/src/main/java/com/netgrif/application/engine/workflow/domain/params/CreateCaseParams.java @@ -26,8 +26,7 @@ public class CreateCaseParams { private LoggedUser loggedUser; @Builder.Default private Locale locale = LocaleContextHolder.getLocale(); - @Builder.Default - private boolean isTransactional = false; + private Boolean isTransactional; @Builder.Default private Map params = new HashMap<>(); diff --git a/src/main/java/com/netgrif/application/engine/workflow/domain/params/DeleteCaseParams.java b/src/main/java/com/netgrif/application/engine/workflow/domain/params/DeleteCaseParams.java index cdf43ba6877..23774afab35 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/domain/params/DeleteCaseParams.java +++ b/src/main/java/com/netgrif/application/engine/workflow/domain/params/DeleteCaseParams.java @@ -15,8 +15,7 @@ public class DeleteCaseParams { private String useCaseId; private Case useCase; - @Builder.Default - private boolean isTransactional = false; + private Boolean isTransactional; @Builder.Default private Map params = new HashMap<>(); diff --git a/src/main/java/com/netgrif/application/engine/workflow/domain/params/GetDataParams.java b/src/main/java/com/netgrif/application/engine/workflow/domain/params/GetDataParams.java index a1a6468da4f..0ce5aca41b6 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/domain/params/GetDataParams.java +++ b/src/main/java/com/netgrif/application/engine/workflow/domain/params/GetDataParams.java @@ -19,8 +19,7 @@ public class GetDataParams { private Task task; private IUser user; private Case useCase; - @Builder.Default - private boolean isTransactional = false; + private Boolean isTransactional; @Builder.Default private Map params = new HashMap<>(); diff --git a/src/main/java/com/netgrif/application/engine/workflow/domain/params/SetDataParams.java b/src/main/java/com/netgrif/application/engine/workflow/domain/params/SetDataParams.java index 49077726f40..d5a1d52ec91 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/domain/params/SetDataParams.java +++ b/src/main/java/com/netgrif/application/engine/workflow/domain/params/SetDataParams.java @@ -21,8 +21,7 @@ public class SetDataParams { private Case useCase; private DataSet dataSet; private IUser user; - @Builder.Default - private boolean isTransactional = false; + private Boolean isTransactional; @Builder.Default private Map params = new HashMap<>(); diff --git a/src/main/java/com/netgrif/application/engine/workflow/domain/params/TaskParams.java b/src/main/java/com/netgrif/application/engine/workflow/domain/params/TaskParams.java index 9dd0d7a6bd4..d71fd9a116c 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/domain/params/TaskParams.java +++ b/src/main/java/com/netgrif/application/engine/workflow/domain/params/TaskParams.java @@ -19,8 +19,7 @@ public class TaskParams { private Task task; private Case useCase; private IUser user; - @Builder.Default - private boolean isTransactional = false; + private Boolean isTransactional; @Builder.Default private Map params = new HashMap<>(); diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/DataService.java b/src/main/java/com/netgrif/application/engine/workflow/service/DataService.java index 885b55713ce..24ba670fb76 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/DataService.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/DataService.java @@ -17,6 +17,7 @@ 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.transaction.configuration.NaeTransactionProperties; 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; @@ -87,6 +88,9 @@ public class DataService implements IDataService { @Autowired private IValidationService validation; + @Autowired + private NaeTransactionProperties transactionProperties; + @Value("${nae.image.preview.scaling.px:400}") private int imageScale; @@ -115,7 +119,7 @@ public GetDataEventOutcome getData(GetDataParams getDataParams) { log.info("[{}]: Getting data of task {} [{}]", useCase.getStringId(), task.getTransitionId(), task.getStringId()); - if (getDataParams.isTransactional() && !TransactionSynchronizationManager.isSynchronizationActive()) { + if (getDataParams.getIsTransactional() && !TransactionSynchronizationManager.isSynchronizationActive()) { NaeTransaction transaction = NaeTransaction.builder() .transactionManager(transactionManager) .event(new Closure(null) { @@ -184,6 +188,9 @@ private void fillMissingAttributes(GetDataParams getDataParams) throws IllegalAr Case useCase = workflowService.findOne(getDataParams.getTask().getCaseId()); getDataParams.setUseCase(useCase); } + if (getDataParams.getIsTransactional() == null) { + getDataParams.setIsTransactional(transactionProperties.isGetDataTransactional()); + } } /** @@ -210,7 +217,7 @@ public SetDataEventOutcome setData(SetDataParams setDataParams) { task.setUser(userService.findById(task.getUserId())); } - if (setDataParams.isTransactional() && !TransactionSynchronizationManager.isSynchronizationActive()) { + if (setDataParams.getIsTransactional() && !TransactionSynchronizationManager.isSynchronizationActive()) { NaeTransaction transaction = NaeTransaction.builder() .transactionManager(transactionManager) .event(new Closure(null) { @@ -260,6 +267,9 @@ private void fillMissingAttributes(SetDataParams setDataParams) { throw new IllegalArgumentException("Cannot set data without provided task."); } } + if (setDataParams.getIsTransactional() == null) { + setDataParams.setIsTransactional(transactionProperties.isSetDataTransactional()); + } } @Override diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/TaskService.java b/src/main/java/com/netgrif/application/engine/workflow/service/TaskService.java index a774ee09a2d..d8278df783f 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/TaskService.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/TaskService.java @@ -28,6 +28,7 @@ import com.netgrif.application.engine.rules.domain.facts.TransitionEventFact; import com.netgrif.application.engine.rules.service.interfaces.IRuleEngine; import com.netgrif.application.engine.transaction.NaeTransaction; +import com.netgrif.application.engine.transaction.configuration.NaeTransactionProperties; import com.netgrif.application.engine.utils.DateUtils; import com.netgrif.application.engine.utils.FullPageRequest; import com.netgrif.application.engine.workflow.domain.*; @@ -114,6 +115,9 @@ public class TaskService implements ITaskService { @Autowired private MongoTransactionManager transactionManager; + @Autowired + private NaeTransactionProperties transactionProperties; + /** * Executes provided {@link Task} in provided {@link Case} * @@ -183,7 +187,7 @@ public List assignTasks(List tasks, IUser user, Ma public AssignTaskEventOutcome assignTask(TaskParams taskParams) throws TransitionNotExecutableException { fillMissingAttributes(taskParams); - if (taskParams.isTransactional() && !TransactionSynchronizationManager.isSynchronizationActive()) { + if (taskParams.getIsTransactional() && !TransactionSynchronizationManager.isSynchronizationActive()) { NaeTransaction transaction = NaeTransaction.builder() .transactionManager(transactionManager) .event(new Closure(null) { @@ -311,7 +315,7 @@ public List finishTasks(List tasks, IUser user, Ma public FinishTaskEventOutcome finishTask(TaskParams taskParams) throws TransitionNotExecutableException { fillMissingAttributes(taskParams); - if (taskParams.isTransactional() && !TransactionSynchronizationManager.isSynchronizationActive()) { + if (taskParams.getIsTransactional() && !TransactionSynchronizationManager.isSynchronizationActive()) { NaeTransaction transaction = NaeTransaction.builder() .transactionManager(transactionManager) .event(new Closure(null) { @@ -440,7 +444,7 @@ public List cancelTasks(List tasks, IUser user, Ma public CancelTaskEventOutcome cancelTask(TaskParams taskParams) { fillMissingAttributes(taskParams); - if (taskParams.isTransactional() && !TransactionSynchronizationManager.isSynchronizationActive()) { + if (taskParams.getIsTransactional() && !TransactionSynchronizationManager.isSynchronizationActive()) { NaeTransaction transaction = NaeTransaction.builder() .transactionManager(transactionManager) .event(new Closure(null) { @@ -588,6 +592,9 @@ private void fillMissingAttributes(TaskParams taskParams) { IUser user = userService.getLoggedOrSystem(); taskParams.setUser(user); } + if (taskParams.getIsTransactional() == null) { + taskParams.setIsTransactional(transactionProperties.isTaskEventTransactional()); + } } private Case evaluateRules(Case useCase, Task task, EventType eventType, EventPhase eventPhase) { diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/WorkflowService.java b/src/main/java/com/netgrif/application/engine/workflow/service/WorkflowService.java index 4c7bf0ec766..78bd1c4fb26 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/WorkflowService.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/WorkflowService.java @@ -20,6 +20,7 @@ import com.netgrif.application.engine.rules.service.interfaces.IRuleEngine; import com.netgrif.application.engine.security.service.EncryptionService; import com.netgrif.application.engine.transaction.NaeTransaction; +import com.netgrif.application.engine.transaction.configuration.NaeTransactionProperties; import com.netgrif.application.engine.utils.FullPageRequest; import com.netgrif.application.engine.workflow.domain.Case; import com.netgrif.application.engine.workflow.domain.DataFieldValue; @@ -51,7 +52,6 @@ import org.springframework.data.mongodb.core.query.BasicQuery; import org.springframework.data.util.Pair; import org.springframework.stereotype.Service; -import org.springframework.transaction.TransactionDefinition; import org.springframework.transaction.support.TransactionSynchronizationManager; import java.time.LocalDateTime; @@ -103,6 +103,9 @@ public class WorkflowService implements IWorkflowService { @Autowired private MongoTransactionManager transactionManager; + @Autowired + private NaeTransactionProperties transactionProperties; + @Autowired public void setElasticCaseService(IElasticCaseService elasticCaseService) { this.elasticCaseService = elasticCaseService; @@ -225,7 +228,7 @@ private List getExistingUsers(UserListFieldValue userListValue) { public CreateCaseEventOutcome createCase(CreateCaseParams createCaseParams) { fillMissingAttributes(createCaseParams); - if (createCaseParams.isTransactional() && !TransactionSynchronizationManager.isSynchronizationActive()) { + if (createCaseParams.getIsTransactional() && !TransactionSynchronizationManager.isSynchronizationActive()) { NaeTransaction transaction = NaeTransaction.builder() .transactionManager(transactionManager) .event(new Closure(null) { @@ -316,6 +319,9 @@ private void fillMissingAttributes(CreateCaseParams createCaseParams) throws Ill if (createCaseParams.getLoggedUser() == null) { throw new IllegalArgumentException("Logged user cannot be null on Case creation."); } + if (createCaseParams.getIsTransactional() == null) { + createCaseParams.setIsTransactional(transactionProperties.isCreateCaseTransactional()); + } if (createCaseParams.getPetriNet() == null) { PetriNet petriNet; if (createCaseParams.getPetriNetId() != null) { @@ -374,7 +380,7 @@ public Page findAllByAuthor(String authorId, String petriNet, Pageable pag public DeleteCaseEventOutcome deleteCase(DeleteCaseParams deleteCaseParams) { fillMissingAttributes(deleteCaseParams); - if (deleteCaseParams.isTransactional() && !TransactionSynchronizationManager.isSynchronizationActive()) { + if (deleteCaseParams.getIsTransactional() && !TransactionSynchronizationManager.isSynchronizationActive()) { NaeTransaction transaction = NaeTransaction.builder() .transactionManager(transactionManager) .event(new Closure(null) { @@ -423,6 +429,9 @@ private void fillMissingAttributes(DeleteCaseParams deleteCaseParams) throws Ill throw new IllegalArgumentException("At least case id must be provided on case removal."); } } + if (deleteCaseParams.getIsTransactional() == null) { + deleteCaseParams.setIsTransactional(transactionProperties.isDeleteCaseTransactional()); + } } @Override diff --git a/src/test/groovy/com/netgrif/application/engine/transaction/TransactionTest.groovy b/src/test/groovy/com/netgrif/application/engine/transaction/TransactionTest.groovy index e638544d47e..536c94afb37 100644 --- a/src/test/groovy/com/netgrif/application/engine/transaction/TransactionTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/transaction/TransactionTest.groovy @@ -38,7 +38,7 @@ import org.springframework.test.context.ActiveProfiles import static org.junit.jupiter.api.Assertions.assertThrows @SpringBootTest -@ActiveProfiles(["test"]) +@ActiveProfiles(["test", "test-transaction"]) class TransactionTest { @Autowired diff --git a/src/test/java/com/netgrif/application/engine/workflow/service/TaskServiceTest.java b/src/test/java/com/netgrif/application/engine/workflow/service/TaskServiceTest.java index 6984fba360a..3b33e8f0b08 100644 --- a/src/test/java/com/netgrif/application/engine/workflow/service/TaskServiceTest.java +++ b/src/test/java/com/netgrif/application/engine/workflow/service/TaskServiceTest.java @@ -159,7 +159,7 @@ public LoggedUser mockLoggedUser() { } @Test - public void testTransactionalAssignTaskFailure() throws IOException, MissingPetriNetMetaDataException, TransitionNotExecutableException { + public void testTransactionalAssignTaskFailure() throws IOException, MissingPetriNetMetaDataException { String taskId = createCaseAndReturnTaskId("src/test/resources/transactional_task_event_test.xml", "assignTest"); @@ -210,7 +210,7 @@ public void testTransactionalCancelTaskFailure() throws IOException, MissingPetr Task aTask = taskService.assignTask(taskParams).getTask(); assert Objects.equals(aTask.getUserId(), superCreator.getSuperUser().getStringId()); - taskParams.setTransactional(true); + taskParams.setIsTransactional(true); assertThrows(RuntimeException.class, () -> taskService.cancelTask(taskParams)); aTask = taskService.findOne(taskId); @@ -255,7 +255,7 @@ public void testTransactionalFinishTaskFailure() throws IOException, MissingPetr Task aTask = taskService.assignTask(taskParams).getTask(); assert Objects.equals(aTask.getUserId(), superCreator.getSuperUser().getStringId()); - taskParams.setTransactional(true); + taskParams.setIsTransactional(true); assertThrows(RuntimeException.class, () -> taskService.finishTask(taskParams)); aTask = taskService.findOne(taskId); diff --git a/src/test/resources/application-test-transaction.properties b/src/test/resources/application-test-transaction.properties new file mode 100644 index 00000000000..1f08f62e173 --- /dev/null +++ b/src/test/resources/application-test-transaction.properties @@ -0,0 +1,6 @@ +# Transactions for API +nae.transaction.create-case-transactional=false +nae.transaction.delete-case-transactional=false +nae.transaction.get-data-transactional=false +nae.transaction.set-data-transactional=false +nae.transaction.task-event-transactional=false \ No newline at end of file From 8a362d674ab6ff409c40c461633697d27a8699d0 Mon Sep 17 00:00:00 2001 From: chvostek Date: Fri, 30 Aug 2024 14:39:26 +0200 Subject: [PATCH 47/48] [NAE-1998] Implement transactions for events - implement performance test in TransactionTest - add javadoc in TaskDataSets --- .../web/responsebodies/TaskDataSets.java | 3 + .../engine/transaction/TransactionTest.groovy | 161 +++++++++++++++--- 2 files changed, 142 insertions(+), 22 deletions(-) diff --git a/src/main/java/com/netgrif/application/engine/workflow/web/responsebodies/TaskDataSets.java b/src/main/java/com/netgrif/application/engine/workflow/web/responsebodies/TaskDataSets.java index dd47c1b2065..bdb3632b2a8 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/web/responsebodies/TaskDataSets.java +++ b/src/main/java/com/netgrif/application/engine/workflow/web/responsebodies/TaskDataSets.java @@ -11,6 +11,9 @@ @NoArgsConstructor public class TaskDataSets { + /** + * Key is taskId, value is DataSet + * */ private Map body; } diff --git a/src/test/groovy/com/netgrif/application/engine/transaction/TransactionTest.groovy b/src/test/groovy/com/netgrif/application/engine/transaction/TransactionTest.groovy index 536c94afb37..50d31a3d5a0 100644 --- a/src/test/groovy/com/netgrif/application/engine/transaction/TransactionTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/transaction/TransactionTest.groovy @@ -10,6 +10,7 @@ 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.dataset.TextField import com.netgrif.application.engine.petrinet.domain.params.ImportPetriNetParams import com.netgrif.application.engine.petrinet.domain.throwable.MissingPetriNetMetaDataException import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService @@ -24,6 +25,9 @@ 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 import com.netgrif.application.engine.workflow.web.responsebodies.DataSet +import com.netgrif.application.engine.workflow.web.responsebodies.TaskDataSets +import groovy.json.JsonOutput +import groovy.json.JsonSlurper import groovy.time.TimeCategory import groovy.time.TimeDuration import org.junit.jupiter.api.BeforeEach @@ -33,9 +37,26 @@ import org.springframework.beans.factory.annotation.Autowired import org.springframework.boot.test.context.SpringBootTest import org.springframework.data.domain.Page import org.springframework.data.domain.PageRequest +import org.springframework.data.util.Pair +import org.springframework.hateoas.MediaTypes +import org.springframework.mock.web.MockHttpServletRequest +import org.springframework.security.authentication.UsernamePasswordAuthenticationToken +import org.springframework.security.core.Authentication +import org.springframework.security.web.authentication.WebAuthenticationDetails import org.springframework.test.context.ActiveProfiles +import org.springframework.test.web.servlet.MockMvc +import org.springframework.test.web.servlet.MvcResult +import org.springframework.test.web.servlet.setup.MockMvcBuilders +import org.springframework.web.context.WebApplicationContext + +import java.nio.charset.StandardCharsets import static org.junit.jupiter.api.Assertions.assertThrows +import static org.springframework.http.MediaType.APPLICATION_JSON +import static org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors.authentication +import static org.springframework.security.test.web.servlet.setup.SecurityMockMvcConfigurers.springSecurity +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post @SpringBootTest @ActiveProfiles(["test", "test-transaction"]) @@ -71,7 +92,17 @@ class TransactionTest { @Autowired private SuperCreator superCreator + @Autowired + private WebApplicationContext wac + private PetriNet testNet + private Authentication auth + private MockMvc mvc + private static final String USER_EMAIL = "super@netgrif.com" + private static final String CASE_CREATE_URL = "/api/workflow/case" + private static final String ASSIGN_TASK_URL = "/api/task/assign/" + private static final String SET_GET_DATA_URL_TEMPLATE = "/api/task/%s/data" + private static final String FINISH_TASK_URL = "/api/task/finish/" @BeforeEach void before() throws IOException, MissingPetriNetMetaDataException { @@ -348,31 +379,38 @@ class TransactionTest { @Test @Disabled void testPerformance() { - int iterations = 1000 - Case useCase = importHelper.createCase("performance test case", testNet) - - long totalTransactionalDuration = 0 - (0..iterations).each { - Date startTime = new Date() - dataService.setData(new SetDataParams(useCase, new DataSet(["testCreateCaseInTransactionPerformance": new ButtonField(rawValue: 1)] - as Map>), superCreator.getSuperUser())).getCase() - Date endTime = new Date() - TimeDuration elapsedTimeTransactional = TimeCategory.minus( endTime, startTime ) - totalTransactionalDuration += elapsedTimeTransactional.toMilliseconds() - } + beforeMvcTest() + + PetriNet net = petriNetService.importPetriNet(new ImportPetriNetParams( + new FileInputStream("src/test/resources/petriNets/mortgage.xml"), + VersionType.MAJOR, superCreator.getLoggedSuper())).getNet() - long totalNonTransactionalDuration = 0 - (0..iterations).each { - Date startTime = new Date() - dataService.setData(new SetDataParams(useCase, new DataSet(["testCreateCasePerformance": new ButtonField(rawValue: 1)] - as Map>), superCreator.getSuperUser())).getCase() - Date endTime = new Date() - TimeDuration elapsedTimeTransactional = TimeCategory.minus( endTime, startTime ) - totalNonTransactionalDuration += elapsedTimeTransactional.toMilliseconds() + int iterations = 500 + long totalCreateCaseDuration = 0 + long totalAssignTaskDuration = 0 + long totalGetDataDuration = 0 + long totalSetDataDuration = 0 + long totalFinishTaskDuration = 0 + (0..iterations).each {idx -> + Pair createCasePair = createCase(net.stringId, "Case" + idx) + totalCreateCaseDuration += createCasePair.first.toMilliseconds() + String taskId = createCasePair.second["tasks"]["t2"]["taskStringId"] + Pair assignTaskPair = assignTask(taskId) + totalAssignTaskDuration += assignTaskPair.first.toMilliseconds() + TimeDuration getDataDuration = getData(taskId) + totalGetDataDuration += getDataDuration.toMilliseconds() + TimeDuration setDataDuration = setData(taskId, "surname", "xxxx") + totalSetDataDuration += setDataDuration.toMilliseconds() + // todo mvc.finishTask requires some additional changed due to problem with user.getLoggedUser() (password is not initialized) + Pair finishTaskPair = finishTask(taskId) + totalFinishTaskDuration += finishTaskPair.first.toMilliseconds() } - println("AVG transactional for 1 create case: " + totalTransactionalDuration / iterations + "ms") - println("AVG non-transactional for 1 create case: " + totalNonTransactionalDuration / iterations + "ms") + println("AVG for " + iterations + " iterations createCase is " + totalCreateCaseDuration / iterations + " ms") + println("AVG for " + iterations + " iterations assignTask is " + totalAssignTaskDuration / iterations + " ms") + println("AVG for " + iterations + " iterations getData is " + totalGetDataDuration / iterations + " ms") + println("AVG for " + iterations + " iterations setData is " + totalSetDataDuration / iterations + " ms") + println("AVG for " + iterations + " iterations finishTask is " + totalFinishTaskDuration / iterations + " ms") } private Case createTestCaseAndSetButton(String title, String buttonFieldId) { @@ -430,4 +468,83 @@ class TransactionTest { ) >= 1 } + private void beforeMvcTest() { + mvc = MockMvcBuilders + .webAppContextSetup(wac) + .apply(springSecurity()) + .build() + auth = new UsernamePasswordAuthenticationToken(USER_EMAIL, "password") + auth.setDetails(new WebAuthenticationDetails(new MockHttpServletRequest())) + } + + private Pair createCase(String petriNetStringId, String caseTitle) { + String content = JsonOutput.toJson([ + title: caseTitle, + netId: petriNetStringId, + color: "color" + ]) + Date startTime = new Date() + MvcResult result = mvc.perform(post(CASE_CREATE_URL) + .accept(MediaTypes.HAL_JSON_VALUE) + .content(content) + .contentType(APPLICATION_JSON) + .with(authentication(auth))) + .andReturn() + Date endTime = new Date() + return Pair.of(TimeCategory.minus( endTime, startTime ), parseResult(result).outcome.case) + } + + private Pair assignTask(String taskId) { + Date startTime = new Date() + MvcResult result = mvc.perform(get(ASSIGN_TASK_URL+taskId) + .accept(MediaTypes.HAL_JSON_VALUE) + .contentType(APPLICATION_JSON) + .with(authentication(auth))) + .andReturn() + Date endTime = new Date() + return Pair.of(TimeCategory.minus( endTime, startTime ), parseResult(result).outcome.task) + } + + private Pair finishTask(String taskId) { + Date startTime = new Date() + MvcResult result = mvc.perform(get(FINISH_TASK_URL+taskId) + .accept(MediaTypes.HAL_JSON_VALUE) + .contentType(APPLICATION_JSON) + .with(authentication(auth))) + .andReturn() + Date endTime = new Date() + return Pair.of(TimeCategory.minus( endTime, startTime ), parseResult(result).outcome.task) + } + + private TimeDuration getData(String taskId) { + Date startTime = new Date() + mvc.perform(get(String.format(SET_GET_DATA_URL_TEMPLATE, taskId)) + .contentType(APPLICATION_JSON) + .with(authentication(auth))) + Date endTime = new Date() + return TimeCategory.minus( endTime, startTime ) + } + + private TimeDuration setData(String taskId, String fieldId, String newValue) { + Field surnameField = new TextField() + surnameField.setRawValue(newValue) + + def body = [(taskId): new DataSet([(fieldId): (Field) surnameField])] + + String content = JsonOutput.toJson(new TaskDataSets(body)) + + Date startTime = new Date() + mvc.perform(post(String.format(SET_GET_DATA_URL_TEMPLATE, taskId)) + .content(content) + .contentType(APPLICATION_JSON) + .with(authentication(auth))) + Date endTime = new Date() + return TimeCategory.minus( endTime, startTime ) + } + + @SuppressWarnings("GrMethodMayBeStatic") + private def parseResult(MvcResult result) { + return (new JsonSlurper()).parseText(result.response.getContentAsString(StandardCharsets.UTF_8)) + } + } From 01ffba30e978d78d37f9b0c98ac2f93eee8e41ad Mon Sep 17 00:00:00 2001 From: chvostek Date: Mon, 2 Sep 2024 09:51:44 +0200 Subject: [PATCH 48/48] [NAE-1998] Implement transactions for events - add test net from builder with some changes --- src/test/resources/petriNets/mortgage.xml | 1544 +++++++++++++++++++++ 1 file changed, 1544 insertions(+) create mode 100644 src/test/resources/petriNets/mortgage.xml diff --git a/src/test/resources/petriNets/mortgage.xml b/src/test/resources/petriNets/mortgage.xml new file mode 100644 index 00000000000..ecbb49ad8cb --- /dev/null +++ b/src/test/resources/petriNets/mortgage.xml @@ -0,0 +1,1544 @@ + + mortgage + 1.0.0 + MTG + Mortgage + true + false + false + + + account_clerk + + true + + + + default + + true + + + + loan_officer + + true + + + + property_appraiser + + true + + + + author + + true + + + + account_clerk + Account clerk + + + loan_officer + Loan officer + + + property_appraiser + Property appraiser + + + system + System + + + account_number + Account number + Please enter your account number - IBAN + + + application_form + Mortgage application form + t24 + + + appraisal + Appraisal report + + + appraised_value + Appraised value + 0 + + + author + Author + + + calc + + <desc>Recalculate the monthly payment</desc> + <event type="set"> + <id>set_event_2</id> + <actions phase="post"> + <action id="action_2"> + <![CDATA[ + loan: f.loan_amount, + period: f.period, + monthly: f.monthly_payment; + change monthly value { return (loan.value+loan.value*0.02*period.value)/(period.value*12);} + ]]> + </action> + </actions> + </event> + </data> + <data type="enumeration"> + <id>city</id> + <title>City + + + confirm + Lien inscription confirmation + Please confirm the lien inscription + + + date_of_birth + Date of Birth + + + delete_instruction + Delete instruction + In order to delete press finish button + + + email + Email + + + first_name + Name + + + income + Monthly Income in EUR + Your average monthly income + + + insurance + Insurance + + + + + + + + Union + + + loan_amount + Loan amount in EUR + + + inrange 10000,1000000 + + + 100000 + + set_event_0 + + + + + + + + + monthly_payment + Monthly payment in EUR + 444 + + + period + Repayment period in years + + + inrange 1,30 + + + 30 + + set_event_1 + + + + + + + + + postal + Postal code + + set_event_3 + + + + + + + + + sign + Signing instruction + Please sign the mortgage by pressing finish button + + + status + Status + + + street + Street + + + streetnumber + Street Number + + + surname + Surname + + + text_2 + Mortgage approved by loan officer + Please confirm that you approve this mortgage request + + area + + + + text_3 + Mortgage rejected by loan officer + Please confirm that you reject this mortgage request + + area + + + + type + Property + + + + + + + House + + + t10 + 624 + 208 + + + 0 + + + property_appraiser + + true + + + + DataGroup + grid + + appraised_value + + editable + required + + + 0 + 0 + 1 + 4 + 0 + + outline + + + + appraisal + + editable + + + 0 + 1 + 1 + 4 + 0 + + + + + + t10_finish + + + = loan_amount.value) { + change status value { return "Mortgage Approved"; } + async.run{ + assignTask("t11") + finishTask("t11") + } + } else { + change status value { return "Mortgage Rejected"; } + async.run{ + assignTask("t15") + finishTask("t15") + } + } + ]]> + + + + + + t11 + 880 + 208 + + + 0 + + + system + + true + + + + t11_finish + + + + + + + + + t15 + 752 + 336 + + + 0 + + + system + + true + + + + + t17 + 1136 + 208 + + + 0 + + + account_clerk + + false + + + + loan_officer + + false + + + + property_appraiser + + false + + + + system + + false + + + + author + + true + + + + DataGroup + grid + + account_number + + editable + required + + + 0 + 0 + 1 + 4 + 0 + + outline + + + + sign + + visible + + + 0 + 1 + 1 + 4 + 0 + + outline + + + + + t17_finish + + + + + + + + + t19 + 1552 + 208 + + + 0 + + + account_clerk + + true + + + + DataGroup + grid + + account_number + + visible + + + 0 + 0 + 1 + 4 + 0 + + outline + + + + loan_amount + + visible + + + 0 + 1 + 1 + 4 + 0 + + outline + + + + + t19_finish + + + + + + + + + t2 + 176 + 272 + + + 0 + + auto + + author + + true + + + + DataGroup + grid + + application_form + + editable + + + 0 + 0 + 1 + 4 + 0 + + outline + + + + + t2_finish + + + + + + + + + t21 + 1328 + 272 + + + 0 + + + account_clerk + + false + + + + loan_officer + + false + + + + property_appraiser + + false + + + + system + + false + + + + author + + true + + + + DataGroup + grid + + insurance + + editable + required + + + 0 + 0 + 1 + 4 + 0 + + outline + + + + + t21_finish + + + + + + + + + t23 + 1328 + 144 + + + 0 + + + loan_officer + + true + + + + DataGroup + grid + + confirm + + visible + + + 0 + 0 + 1 + 4 + 0 + + outline + + + + account_number + + editable + required + + + 0 + 1 + 1 + 4 + 0 + + outline + + + + + t23_finish + + + + + + + + + t24 + 176 + 464 + + + 0 + + + system + + true + + + + DataGroup + grid + + first_name + + editable + + + 0 + 0 + 1 + 2 + 0 + + outline + + + + surname + + editable + + + 2 + 0 + 1 + 2 + 0 + + outline + + + + date_of_birth + + editable + + + 0 + 1 + 1 + 2 + 0 + + outline + + + + email + + editable + + + 2 + 1 + 1 + 2 + 0 + + outline + + + + streetnumber + + editable + + + 0 + 2 + 1 + 2 + 0 + + outline + + + + street + + editable + + + 2 + 2 + 1 + 2 + 0 + + outline + + + + postal + + editable + + + 0 + 3 + 1 + 2 + 0 + + outline + + + + city + + editable + + + 2 + 3 + 1 + 2 + 0 + + outline + + + + type + + editable + + + 0 + 4 + 1 + 4 + 0 + + outline + + + + income + + editable + + + 0 + 5 + 1 + 2 + 0 + + outline + + + + loan_amount + + editable + + + 2 + 5 + 1 + 2 + 0 + + outline + + + + period + + editable + + + 0 + 6 + 1 + 2 + 0 + + outline + + + + monthly_payment + + visible + + + 2 + 6 + 1 + 2 + 0 + + outline + + + + + + t25 + 48 + 144 + + + 0 + + + + system + + true + + + + author + + true + + + + t25_finish + + + + + + + + + t3 + 400 + 48 + + + 0 + + + loan_officer + + true + + + + property_appraiser + + true + + + + DataGroup + grid + + application_form + + visible + + + 0 + 0 + 1 + 4 + 0 + + outline + + + + appraised_value + + hidden + + + 0 + 1 + 1 + 4 + 0 + + outline + + + + + + t4 + 464 + 560 + + + 0 + + + account_clerk + + false + + + + loan_officer + + false + + + + property_appraiser + + false + + + + system + + false + + + + author + + true + + + + DataGroup + grid + + status + + visible + + + 0 + 0 + 1 + 4 + 0 + + outline + + + + application_form + + visible + + + 0 + 1 + 1 + 4 + 0 + + outline + + + + + + t5 + 624 + 464 + + + 0 + + + author + + true + + + + DataGroup + grid + + delete_instruction + + visible + + + 0 + 0 + 1 + 4 + 0 + + outline + + + + + t5_finish + + + + + + + + + t7 + 368 + 336 + + + 0 + + + loan_officer + + true + + + + DataGroup + grid + + text_3 + + visible + + + 0 + 0 + 1 + 4 + 0 + + outline + + + + + t7_finish + + + + + + + + + t8 + 368 + 208 + + + 0 + + + loan_officer + + true + + + + DataGroup + grid + + text_2 + + visible + + + 0 + 0 + 1 + 4 + 0 + + outline + + + + + t8_finish + + + + + + + + + p10 + 496 + 208 + 0 + false + + + p11 + 752 + 208 + 0 + false + + + p12 + 1008 + 208 + 0 + false + + + p13 + 624 + 336 + 0 + false + + + p16 + 1200 + 144 + 0 + false + + + p17 + 1456 + 144 + 0 + false + + + p18 + 1680 + 208 + 0 + false + + + p19 + 1200 + 272 + 0 + false + + + p2 + 48 + 272 + + 0 + false + + + p20 + 1456 + 272 + 0 + false + + + p23 + 752 + 560 + 0 + false + + + p24 + 48 + 48 + + 1 + false + + + p3 + 304 + 144 + 0 + false + + + p5 + 368 + 464 + 0 + false + + + p8 + 304 + 272 + 0 + false + + + a10 + read + p5 + t4 + 1 + + + a12 + regular + p5 + t5 + 1 + + + a15 + regular + t2 + p8 + 1 + + + a16 + regular + p8 + t7 + 1 + + + a18 + regular + p8 + t8 + 1 + + + a19 + regular + t8 + p10 + 1 + + + a21 + regular + p10 + t10 + 1 + + + a22 + regular + t10 + p11 + 1 + + + a23 + regular + p11 + t11 + 1 + + + a24 + regular + t11 + p12 + 1 + + + a26 + regular + t7 + p13 + 1 + + + a27 + regular + p13 + t5 + 1 + + + a3 + regular + p2 + t2 + 1 + + + a30 + regular + p11 + t15 + 1 + + + a31 + regular + t15 + p13 + 1 + + + a33 + regular + p12 + t17 + 1 + + + a34 + regular + t17 + p16 + 1 + + + a37 + regular + p17 + t19 + 1 + + + a38 + regular + t19 + p18 + 1 + + + a4 + regular + t2 + p3 + 1 + + + a40 + regular + t17 + p19 + 1 + + + a41 + regular + p19 + t21 + 1 + + + a42 + regular + t21 + p20 + 1 + + + a43 + regular + p20 + t19 + 1 + + + a45 + regular + p16 + t23 + 1 + + + a46 + regular + t23 + p17 + 1 + + + a48 + regular + t5 + p23 + 1 + + + a49 + regular + p24 + t25 + 1 + + + a50 + regular + t25 + p2 + 1 + + + a6 + read + p3 + t3 + 1 + + + a8 + regular + t2 + p5 + 1 + + \ No newline at end of file